name string | code string | asm string | file string |
|---|---|---|---|
pybind11::class_<sdf_tools::sdf::SdfUnion, std::shared_ptr<sdf_tools::sdf::SdfUnion>>& pybind11::class_<sdf_tools::sdf::SdfUnion, std::shared_ptr<sdf_tools::sdf::SdfUnion>>::def<void pybind11::detail::initimpl::constructor<std::shared_ptr<sdf_tools::sdf::Sdf>, std::shared_ptr<sdf_tools::sdf::Sdf>>::execute<pybind11::cl... | class_ &def(const char *name_, Func&& f, const Extra&... extra) {
cpp_function cf(method_adaptor<type>(std::forward<Func>(f)), name(name_), is_method(*this),
sibling(getattr(*this, name_, none())), extra...);
add_class_method(*this, name_, cf);
return *this;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r12
movq %r8, 0x18(%rsp)
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x28(%rsp)
movq (%rdi), %rdi
movq %rdi, 0x20(%rsp)
movq 0x27a66(%rip), %r15 # 0x52ec8
movq %r15, 0x10(%rsp)
incq (%r15)
ca... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pybind11.h |
bool pybind11::detail::copyable_holder_caster<sdf_tools::sdf::Sdf, std::shared_ptr<sdf_tools::sdf::Sdf>, void>::try_implicit_casts<std::shared_ptr<sdf_tools::sdf::Sdf>, 0>(pybind11::handle, bool) | bool try_implicit_casts(handle src, bool convert) {
for (auto &cast : typeinfo->implicit_casts) {
copyable_holder_caster sub_caster(*cast.first);
if (sub_caster.load(src, convert)) {
value = cast.second(sub_caster.value);
holder = holder_type(sub_caster.ho... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, 0x8(%rsp)
movq (%rdi), %rax
movq 0x58(%rax), %rbx
movq 0x60(%rax), %r15
cmpq %r15, %rbx
setne %r12b
je 0x2bd0f
movq %rdi, %r14
movzbl %dl, %ebp
movq (%rbx), %rsi
leaq 0x10(%rsp), %r13
movq %r13, %rdi
callq 0x2333a
leaq 0x28(%r... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/cast.h |
pybind11::class_<sdf_tools::sdf::SdfIntersection, std::shared_ptr<sdf_tools::sdf::SdfIntersection>>::init_instance(pybind11::detail::instance*, void const*) | static void init_instance(detail::instance *inst, const void *holder_ptr) {
auto v_h = inst->get_value_and_holder(detail::get_type_info(typeid(type)));
if (!v_h.instance_registered()) {
register_instance(inst, v_h.value_ptr(), v_h.type);
v_h.set_instance_registered();
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x26053(%rip), %rax # 0x51f68
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
xorl %esi, %esi
callq 0x19ecd
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
movl $0x1, %ecx
callq 0x1c8... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pybind11.h |
pybind11::class_<sdf_tools::sdf::SdfIntersection, std::shared_ptr<sdf_tools::sdf::SdfIntersection>>::dealloc(pybind11::detail::value_and_holder&) | static void dealloc(detail::value_and_holder &v_h) {
// We could be deallocating because we are cleaning up after a Python exception.
// If so, the Python error indicator will be set. We need to clear that before
// running the destructor, in case the destructor code calls more Python.
/... | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rsi
leaq 0x18(%rsp), %rdx
leaq 0x8(%rsp), %rdi
callq 0xbd20
movq (%rbx), %rcx
movb 0x30(%rcx), %al
testb $0x2, %al
jne 0x2c02f
movq 0x18(%rcx), %rax
movq 0x8(%rbx), %rcx
movb (%rax,%rcx), %al
jmp 0x2c032
shrb $0x2, %al
movq 0x18(%rbx), %rcx
testb $0x1, %al
j... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pybind11.h |
pybind11::class_<sdf_tools::sdf::SdfIntersection, std::shared_ptr<sdf_tools::sdf::SdfIntersection>>& pybind11::class_<sdf_tools::sdf::SdfIntersection, std::shared_ptr<sdf_tools::sdf::SdfIntersection>>::def<void pybind11::detail::initimpl::constructor<std::shared_ptr<sdf_tools::sdf::Sdf>, std::shared_ptr<sdf_tools::sdf:... | class_ &def(const char *name_, Func&& f, const Extra&... extra) {
cpp_function cf(method_adaptor<type>(std::forward<Func>(f)), name(name_), is_method(*this),
sibling(getattr(*this, name_, none())), extra...);
add_class_method(*this, name_, cf);
return *this;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r12
movq %r8, 0x18(%rsp)
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x28(%rsp)
movq (%rdi), %rdi
movq %rdi, 0x20(%rsp)
movq 0x26cda(%rip), %r15 # 0x52ec8
movq %r15, 0x10(%rsp)
incq (%r15)
ca... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pybind11.h |
void pybind11::cpp_function::initialize<void pybind11::detail::initimpl::constructor<std::shared_ptr<sdf_tools::sdf::Sdf>, std::shared_ptr<sdf_tools::sdf::Sdf>>::execute<pybind11::class_<sdf_tools::sdf::SdfIntersection, std::shared_ptr<sdf_tools::sdf::SdfIntersection>>, pybind11::arg, pybind11::arg, char [87], 0>(pybin... | void initialize(Func &&f, Return (*)(Args...), const Extra&... extra) {
using namespace detail;
struct capture { remove_reference_t<Func> f; };
/* Store the function including any extra state it might have (e.g. a lambda capture object) */
// The unique_ptr makes sure nothing is leaked ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r15
movq %r8, %r12
movq %rcx, %r13
movq %rdi, %rbx
movq 0x48(%rsp), %rbp
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x18208
movq (%r14), %r14
leaq 0x9c(%rip), %rax # 0x2c3de
movq %rax, 0x30(%r14)
movq (%r13), %rax
... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pybind11.h |
pybind11::class_<sdf_tools::sdf::SdfDifference, std::shared_ptr<sdf_tools::sdf::SdfDifference>>& pybind11::class_<sdf_tools::sdf::SdfDifference, std::shared_ptr<sdf_tools::sdf::SdfDifference>>::def<void pybind11::detail::initimpl::constructor<std::shared_ptr<sdf_tools::sdf::Sdf>, std::shared_ptr<sdf_tools::sdf::Sdf>>::... | class_ &def(const char *name_, Func&& f, const Extra&... extra) {
cpp_function cf(method_adaptor<type>(std::forward<Func>(f)), name(name_), is_method(*this),
sibling(getattr(*this, name_, none())), extra...);
add_class_method(*this, name_, cf);
return *this;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r12
movq %r8, 0x18(%rsp)
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x28(%rsp)
movq (%rdi), %rdi
movq %rdi, 0x20(%rsp)
movq 0x265e0(%rip), %r15 # 0x52ec8
movq %r15, 0x10(%rsp)
incq (%r15)
ca... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pybind11.h |
sdf_tools::exportVectorTypes(pybind11::module_&) | void exportVectorTypes(py::module &m)
{
PYBIND11_NUMPY_DTYPE(real2, x, y);
py::class_<real2>(m, "real2")
.def(py::init<real, real>(), "x"_a, "y"_a)
.def(py::init([](py::tuple t) {
if (py::len(t) != 2)
throw std::runtime_error("Should have l... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rdi, 0x58(%rsp)
leaq 0xfedc(%rip), %r12 # 0x3db89
leaq 0x78(%rsp), %rdi
movq %r12, -0x18(%rdi)
movq $0x0, -0x10(%rdi)
movq $0x4, -0x8(%rdi)
leaq 0x88(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x60(%rsp)... | /amlucas[P]sdfTools/src/sdf_tools/bindings/types.cpp |
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 0x23ae2(%rip), %rax # 0x52f28
movq 0x8(%rax), %rax
xorl %esi, %esi
cmpb $0x2a, (%rax)
sete %sil
addq %rax, %rsi
leaq 0x7(%rsp), %rdx
callq 0xbd90
movq %rbx, %rdi
callq 0x156b7
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq (%rbx), ... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/detail/typeid.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> pybind11::type_id<char const (&) [9]>() | 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)
movq 0x23a37(%rip), %rsi # 0x52fa0
leaq 0x4(%rsi), %rdx
callq 0xb250
movq %rbx, %rdi
callq 0x156b7
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x2f599
movq (%r15), %rs... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/detail/typeid.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> pybind11::type_id<pybind11::none>() | 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 0xfa23(%rip), %rsi # 0x3f4de
leaq 0xfa2c(%rip), %rdx # 0x3f4ee
callq 0xb250
movq %rbx, %rdi
callq 0x156b7
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x2fae... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/detail/typeid.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> pybind11::type_id<sdf_tools::real3>() | 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 0xd4b3(%rip), %rsi # 0x3da2e
leaq 0xd4be(%rip), %rdx # 0x3da40
callq 0xb250
movq %rbx, %rdi
callq 0x156b7
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x305a... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/detail/typeid.h |
pybind11::detail::object_api<pybind11::handle>::operator[](char const*) const | item_accessor object_api<D>::operator[](const char *key) const {
return {derived(), pybind11::str(key)};
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rsi), %r15
movq %rsp, %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0x149f0
movq (%r14), %rax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
xorl %ecx, %ecx
movq %rcx, (%r14)
movq %r15, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movq %rcx, (%rdi)
movq %rcx, 0x18(%rbx)
... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pytypes.h |
pybind11::detail::npy_api::lookup() | static npy_api lookup() {
module_ m = module_::import("numpy.core.multiarray");
auto c = m.attr("_ARRAY_API");
#if PY_MAJOR_VERSION >= 3
void **api_ptr = (void **) PyCapsule_GetPointer(c.ptr(), NULL);
#else
void **api_ptr = (void **) PyCObject_AsVoidPtr(c.ptr());
#endif
npy_api a... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0xb520(%rip), %rsi # 0x3eecf
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x33afc
movq (%r14), %rax
leaq 0x28(%rsp), %r14
movq %rax, -0x10(%r14)
leaq 0xb516(%rip), %rax # 0x3eee5
movq %rax, -0x8(%r14)
movq $0x0, (%r14)
leaq 0x10(%rsp), %rdi
... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/numpy.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 {
#if !defined(NDEBUG) && PY_VERSION_HEX >= 0x03060000
if (!PyGILState_Check()) {
pybind11_fail("pybind11::object_api<>::operator() PyGILState_Check() failure.");
}
#endif
return detail::collect_arguments<policy>(std::forward<Args>(args)..... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0xbc10
testl %eax, %eax
je 0x34c9c
movq %rsp, %rdi
xorl %esi, %esi
callq 0x1563c
movq %r14, %rdi
callq 0x1663c
movq (%rax), %rdx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x15392
movq %rsp, %rdi
callq 0x149d2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
po... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/cast.h |
pybind11::operator!=(pybind11::iterator const&, pybind11::iterator const&) | bool operator!=(const iterator &a, const iterator &b) { return a->ptr() != b->ptr(); } | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, (%rdi)
je 0x34d43
cmpq $0x0, 0x8(%r14)
jne 0x34d43
movq %r14, %rdi
callq 0x34dbc
movq 0x8(%r14), %r14
cmpq $0x0, (%rbx)
je 0x34d5c
cmpq $0x0, 0x8(%rbx)
jne 0x34d5c
movq %rbx, %rdi
callq 0x34dbc
cmpq 0x8(%rbx), %r14
setne %al
addq $0x8, %rsp
pop... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pytypes.h |
pybind11::tuple pybind11::cast<pybind11::tuple, 0>(pybind11::handle const&) | T cast(const handle &handle) { return T(reinterpret_borrow<object>(handle)); } | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x34e50
incq (%rax)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x34e86
leaq 0x8(%rsp), %rdi
callq 0x149d2
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x149d2
movq %rbx, %... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/cast.h |
pybind11::int_ pybind11::cast<pybind11::int_, 0>(pybind11::handle const&) | T cast(const handle &handle) { return T(reinterpret_borrow<object>(handle)); } | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x34fbf
incq (%rax)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x34ff4
leaq 0x8(%rsp), %rdi
callq 0x149d2
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x149d2
movq %rbx, %... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/cast.h |
pybind11::class_<sdf_tools::real2>::init_instance(pybind11::detail::instance*, void const*) | static void init_instance(detail::instance *inst, const void *holder_ptr) {
auto v_h = inst->get_value_and_holder(detail::get_type_info(typeid(type)));
if (!v_h.instance_registered()) {
register_instance(inst, v_h.value_ptr(), v_h.type);
v_h.set_instance_registered();
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1b877(%rip), %rax # 0x52608
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
xorl %esi, %esi
callq 0x19ecd
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
movl $0x1, %ecx
callq 0x1c8... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pybind11.h |
pybind11::class_<sdf_tools::real2>::dealloc(pybind11::detail::value_and_holder&) | static void dealloc(detail::value_and_holder &v_h) {
// We could be deallocating because we are cleaning up after a Python exception.
// If so, the Python error indicator will be set. We need to clear that before
// running the destructor, in case the destructor code calls more Python.
/... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %rsp, %rdi
callq 0xbd20
movq (%rbx), %rcx
movb 0x30(%rcx), %al
testb $0x2, %al
jne 0x36eab
movq 0x18(%rcx), %rax
movq 0x8(%rbx), %rcx
movb (%rax,%rcx), %al
jmp 0x36eae
shrb $0x2, %al
movq 0x18(%rbx), %r14
testb $0x1, ... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pybind11.h |
bool pybind11::detail::argument_loader<sdf_tools::real2&, float const&>::load_impl_sequence<0ul, 1ul>(pybind11::detail::function_call&, std::integer_sequence<unsigned long, 0ul, 1ul>) | bool load_impl_sequence(function_call &call, index_sequence<Is...>) {
#ifdef __cpp_fold_expressions
if ((... || !std::get<Is>(argcasters).load(call.args[Is], call.args_convert[Is])))
return false;
#else
for (bool r : {std::get<Is>(argcasters).load(call.args[Is], call.args_convert[Is])...})
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x8, %rdi
movq 0x8(%rsi), %rax
movq 0x20(%rsi), %rcx
movq (%rax), %rsi
movl (%rcx), %edx
andl $0x1, %edx
callq 0x22d2c
testb %al, %al
je 0x3781d
movq 0x8(%r14), %rax
movq 0x20(%r14), %rcx
movq 0x8(%rax), %rsi
movl (%rcx), %edx
andl $0x2, %edx
shrl %... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/cast.h |
pybind11::class_<sdf_tools::real2>& pybind11::class_<sdf_tools::real2>::def_property_static<pybind11::is_method, pybind11::return_value_policy>(char const*, pybind11::cpp_function const&, pybind11::cpp_function const&, pybind11::is_method const&, pybind11::return_value_policy const&) | class_ &def_property_static(const char *name, const cpp_function &fget, const cpp_function &fset, const Extra& ...extra) {
static_assert( 0 == detail::constexpr_sum(std::is_base_of<arg, Extra>::value...),
"Argument annotations are not allowed for properties");
auto rec_fget = get_f... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, (%rsp)
movq %rdi, %rbx
movq (%rdx), %rdi
callq 0x378b6
movq %rax, %r13
movq (%r15), %rdi
callq 0x378b6
testq %r13, %r13
je 0x37871
orb $0x10, 0x59(%r13)
movq (%r14), %rcx... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pybind11.h |
pybind11::object pybind11::detail::object_api<pybind11::handle>::operator()<(pybind11::return_value_policy)1, pybind11::handle, pybind11::handle, pybind11::none, pybind11::str>(pybind11::handle&&, pybind11::handle&&, pybind11::none&&, pybind11::str&&) const | object object_api<Derived>::operator()(Args &&...args) const {
#if !defined(NDEBUG) && PY_VERSION_HEX >= 0x03060000
if (!PyGILState_Check()) {
pybind11_fail("pybind11::object_api<>::operator() PyGILState_Check() failure.");
}
#endif
return detail::collect_arguments<policy>(std::forward<Args>(args)..... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r15
movq %rdi, %rbx
callq 0xbc10
testl %eax, %eax
je 0x37b68
movq %rsp, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r14, %r8
callq 0x37b87
movq (%r15), %r... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/cast.h |
bool pybind11::detail::argument_loader<sdf_tools::real2 const&, unsigned long>::load_impl_sequence<0ul, 1ul>(pybind11::detail::function_call&, std::integer_sequence<unsigned long, 0ul, 1ul>) | bool load_impl_sequence(function_call &call, index_sequence<Is...>) {
#ifdef __cpp_fold_expressions
if ((... || !std::get<Is>(argcasters).load(call.args[Is], call.args_convert[Is])))
return false;
#else
for (bool r : {std::get<Is>(argcasters).load(call.args[Is], call.args_convert[Is])...})
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x8, %rdi
movq 0x8(%rsi), %rax
movq 0x20(%rsi), %rcx
movq (%rax), %rsi
movl (%rcx), %edx
andl $0x1, %edx
callq 0x22d2c
testb %al, %al
je 0x37e85
movq 0x8(%r14), %rax
movq 0x20(%r14), %rcx
movq 0x8(%rax), %rsi
movl (%rcx), %edx
andl $0x2, %edx
shrl %... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/cast.h |
pybind11::tuple pybind11::make_tuple<(pybind11::return_value_policy)1, float const&, float const&>(float const&, float 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 %r12
pushq %rbx
subq $0x90, %rsp
movq %rdx, %r15
movq %rdi, %rbx
cvtss2sd (%rsi), %xmm0
movq %rsp, %r12
movq %r12, %r14
callq 0xb500
leaq 0x8(%rsp), %r14
movq %rax, -0x8(%r14)
xorps %xmm0, %xmm0
cvtss2sd (%r15), %xmm0
callq 0xb500
movq %rsp, %rcx
movq %rax, 0x8(%rcx)
xorl %r12d, %... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/cast.h |
pybind11::detail::npy_format_descriptor<sdf_tools::real3, void>::dtype_ptr() | static PyObject* dtype_ptr() {
static PyObject* ptr = get_numpy_internals().get_type_info<T>(true)->dtype_ptr;
return ptr;
} | pushq %rbx
movb 0x1b427(%rip), %al # 0x53c00
testb %al, %al
je 0x387e6
movq 0x1b414(%rip), %rax # 0x53bf8
popq %rbx
retq
callq 0xccb7
testw %ax, %ax
je 0x387dd
movzwl %ax, %eax
cmpl $0x1, %eax
jne 0x38804
leaq 0x1b339(%rip), %rdi # 0x53b38
callq 0x326de
movq 0x1b32d(%rip), %rdi # 0x53b38
leaq 0x19b26(%... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/numpy.h |
pybind11::class_<sdf_tools::real3>::dealloc(pybind11::detail::value_and_holder&) | static void dealloc(detail::value_and_holder &v_h) {
// We could be deallocating because we are cleaning up after a Python exception.
// If so, the Python error indicator will be set. We need to clear that before
// running the destructor, in case the destructor code calls more Python.
/... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %rsp, %rdi
callq 0xbd20
movq (%rbx), %rcx
movb 0x30(%rcx), %al
testb $0x2, %al
jne 0x38981
movq 0x18(%rcx), %rax
movq 0x8(%rbx), %rcx
movb (%rax,%rcx), %al
jmp 0x38984
shrb $0x2, %al
movq 0x18(%rbx), %r14
testb $0x1, ... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pybind11.h |
pybind11::class_<sdf_tools::real3>::init_holder(pybind11::detail::instance*, pybind11::detail::value_and_holder&, std::unique_ptr<sdf_tools::real3, std::default_delete<sdf_tools::real3>> const*, void const*) | static void init_holder(detail::instance *inst, detail::value_and_holder &v_h,
const holder_type *holder_ptr, const void * /* dummy -- not enable_shared_from_this<T>) */) {
if (holder_ptr) {
init_holder_from_existing(v_h, holder_ptr, std::is_copy_constructible<holder_type>());
... | testq %rdx, %rdx
je 0x38a1d
movq 0x18(%rsi), %rax
movq (%rdx), %rcx
movq %rcx, 0x8(%rax)
movq $0x0, (%rdx)
jmp 0x38a2e
testb $0x1, 0x30(%rdi)
je 0x38a45
movq 0x18(%rsi), %rax
movq (%rax), %rcx
movq %rcx, 0x8(%rax)
movq (%rsi), %rax
movb 0x30(%rax), %cl
testb $0x2, %cl
jne 0x38a46
movq 0x18(%rax), %rax
movq 0x8(%rsi), %... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pybind11.h |
void pybind11::cpp_function::initialize<void pybind11::detail::initimpl::constructor<float, float, float>::execute<pybind11::class_<sdf_tools::real3>, pybind11::arg, pybind11::arg, pybind11::arg, 0>(pybind11::class_<sdf_tools::real3>&, pybind11::arg const&, pybind11::arg const&, pybind11::arg const&)::'lambda'(pybind11... | void initialize(Func &&f, Return (*)(Args...), const Extra&... extra) {
using namespace detail;
struct capture { remove_reference_t<Func> f; };
/* Store the function including any extra state it might have (e.g. a lambda capture object) */
// The unique_ptr makes sure nothing is leaked ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rdi, %rbx
movq 0x48(%rsp), %rbp
movq %rsp, %r13
movq %r13, %rdi
movq %rbx, %rsi
callq 0x18208
movq (%r13), %rax
leaq 0xd5(%rip), %rcx # 0x38cae
movq %rcx, 0x30(%rax)
movq %r12, %rdi
mo... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pybind11.h |
bool pybind11::detail::argument_loader<sdf_tools::real3&, float const&>::load_impl_sequence<0ul, 1ul>(pybind11::detail::function_call&, std::integer_sequence<unsigned long, 0ul, 1ul>) | bool load_impl_sequence(function_call &call, index_sequence<Is...>) {
#ifdef __cpp_fold_expressions
if ((... || !std::get<Is>(argcasters).load(call.args[Is], call.args_convert[Is])))
return false;
#else
for (bool r : {std::get<Is>(argcasters).load(call.args[Is], call.args_convert[Is])...})
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x8, %rdi
movq 0x8(%rsi), %rax
movq 0x20(%rsi), %rcx
movq (%rax), %rsi
movl (%rcx), %edx
andl $0x1, %edx
callq 0x22d2c
testb %al, %al
je 0x3906f
movq 0x8(%r14), %rax
movq 0x20(%r14), %rcx
movq 0x8(%rax), %rsi
movl (%rcx), %edx
andl $0x2, %edx
shrl %... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/cast.h |
pybind11::class_<sdf_tools::real3>::get_function_record(pybind11::handle) | static detail::function_record *get_function_record(handle h) {
h = detail::get_function(h);
return h ? (detail::function_record *) reinterpret_borrow<capsule>(PyCFunction_GET_SELF(h.ptr()))
: nullptr;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x39134
movq 0x8(%rbx), %rax
cmpq 0x19d51(%rip), %rax # 0x52e70
setne %cl
cmpq 0x19e5f(%rip), %rax # 0x52f88
setne %al
testb %al, %cl
jne 0x39134
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
je 0x39149
movq 0x10(%rbx), %rax
testb $0x20, 0x10(%rax)
j... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pybind11.h |
bool pybind11::detail::argument_loader<sdf_tools::real3 const&, unsigned long>::load_impl_sequence<0ul, 1ul>(pybind11::detail::function_call&, std::integer_sequence<unsigned long, 0ul, 1ul>) | bool load_impl_sequence(function_call &call, index_sequence<Is...>) {
#ifdef __cpp_fold_expressions
if ((... || !std::get<Is>(argcasters).load(call.args[Is], call.args_convert[Is])))
return false;
#else
for (bool r : {std::get<Is>(argcasters).load(call.args[Is], call.args_convert[Is])...})
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x8, %rdi
movq 0x8(%rsi), %rax
movq 0x20(%rsi), %rcx
movq (%rax), %rsi
movl (%rcx), %edx
andl $0x1, %edx
callq 0x22d2c
testb %al, %al
je 0x391db
movq 0x8(%r14), %rax
movq 0x20(%r14), %rcx
movq 0x8(%rax), %rsi
movl (%rcx), %edx
andl $0x2, %edx
shrl %... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/cast.h |
pybind11::str pybind11::str::format<float const&, float const&, float const&>(float const&, float const&, float const&) 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 0x3355(%rip), %rax # 0x3c558
movq %rax, -0x8(%rbx)
movq $0x0, (%rbx)
movq %rsp, %rdi
leaq 0x8(%rsp), %rsi
callq 0x39262
movq %rsp, %rsi
movq %r14, %rdi
callq 0x1e082
movq %rsp, %rdi
callq 0x14... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pytypes.h |
pybind11::object pybind11::detail::object_api<pybind11::detail::accessor<pybind11::detail::accessor_policies::str_attr>>::operator()<(pybind11::return_value_policy)1, float const&, float const&, float const&>(float const&, float const&, float const&) const | object object_api<Derived>::operator()(Args &&...args) const {
#if !defined(NDEBUG) && PY_VERSION_HEX >= 0x03060000
if (!PyGILState_Check()) {
pybind11_fail("pybind11::object_api<>::operator() PyGILState_Check() failure.");
}
#endif
return detail::collect_arguments<policy>(std::forward<Args>(args)..... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
callq 0xbc10
testl %eax, %eax
je 0x392cd
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x392ee
movq %r14, %rdi
callq 0x1663c
movq (%rax), %r... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/cast.h |
pybind11::detail::npy_format_descriptor<sdf_tools::int3, void>::direct_converter(_object*, void*&) | static bool direct_converter(PyObject *obj, void*& value) {
auto& api = npy_api::get();
if (!PyObject_TypeCheck(obj, api.PyVoidArrType_Type_))
return false;
if (auto descr = reinterpret_steal<object>(api.PyArray_DescrFromScalar_(obj))) {
if (api.PyArray_EquivTypes_(dtype_... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x32492
movq %rax, %r15
movq 0x38(%rax), %rsi
movq 0x8(%r14), %rdi
cmpq %rsi, %rdi
je 0x397ff
callq 0xb280
testl %eax, %eax
je 0x39841
movq %r14, %rdi
callq *0x48(%r15)
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x39833
movq 0x60(%r15... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/numpy.h |
pybind11::class_<sdf_tools::int3>::init_instance(pybind11::detail::instance*, void const*) | static void init_instance(detail::instance *inst, const void *holder_ptr) {
auto v_h = inst->get_value_and_holder(detail::get_type_info(typeid(type)));
if (!v_h.instance_registered()) {
register_instance(inst, v_h.value_ptr(), v_h.type);
v_h.set_instance_registered();
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18a2f(%rip), %rax # 0x52328
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
xorl %esi, %esi
callq 0x19ecd
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
movl $0x1, %ecx
callq 0x1c8... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pybind11.h |
pybind11::class_<sdf_tools::int3>& pybind11::class_<sdf_tools::int3>::def<void pybind11::detail::initimpl::constructor<int, int, int>::execute<pybind11::class_<sdf_tools::int3>, pybind11::arg, pybind11::arg, pybind11::arg, 0>(pybind11::class_<sdf_tools::int3>&, pybind11::arg const&, pybind11::arg const&, pybind11::arg ... | class_ &def(const char *name_, Func&& f, const Extra&... extra) {
cpp_function cf(method_adaptor<type>(std::forward<Func>(f)), name(name_), is_method(*this),
sibling(getattr(*this, name_, none())), extra...);
add_class_method(*this, name_, cf);
return *this;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r12
movq %r8, 0x18(%rsp)
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, 0x28(%rsp)
movq (%rdi), %rdi
movq %rdi, 0x20(%rsp)
movq 0x193b2(%rip), %r15 # 0x52ec8
movq %r15, 0x10(%rsp)
incq (%r15)
ca... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pybind11.h |
bool pybind11::detail::argument_loader<pybind11::detail::value_and_holder&, int, int, int>::load_impl_sequence<0ul, 1ul, 2ul, 3ul>(pybind11::detail::function_call&, std::integer_sequence<unsigned long, 0ul, 1ul, 2ul, 3ul>) | bool load_impl_sequence(function_call &call, index_sequence<Is...>) {
#ifdef __cpp_fold_expressions
if ((... || !std::get<Is>(argcasters).load(call.args[Is], call.args_convert[Is])))
return false;
#else
for (bool r : {std::get<Is>(argcasters).load(call.args[Is], call.args_convert[Is])...})
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq 0x20(%rsi), %rcx
movq (%rax), %rsi
movl (%rcx), %edx
movq %rsi, 0x10(%rdi)
addq $0x8, %rdi
movq 0x8(%rax), %rsi
andl $0x2, %edx
shrl %edx
callq 0x24d68
testb %al, %al
je 0x39dcb
leaq 0x4(%rbx), %rdi
movq 0x8(%r14), %rax
movq 0x20... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/cast.h |
void pybind11::cpp_function::initialize<pybind11::class_<sdf_tools::int3>& pybind11::class_<sdf_tools::int3>::def_readwrite<sdf_tools::int3, int>(char const*, int sdf_tools::int3::*)::'lambda'(sdf_tools::int3 const&), int const&, sdf_tools::int3 const&, pybind11::is_method>(sdf_tools::int3&&, int (*)(), pybind11::is_me... | void initialize(Func &&f, Return (*)(Args...), const Extra&... extra) {
using namespace detail;
struct capture { remove_reference_t<Func> f; };
/* Store the function including any extra state it might have (e.g. a lambda capture object) */
// The unique_ptr makes sure nothing is leaked ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x18208
movq (%r12), %rax
movq (%r14), %rcx
movq %rcx, 0x38(%rax)
leaq 0x55(%rip), %rcx # 0x39ec4
movq %rcx, 0x30(%rax)
orb $0x10, 0x59(%rax)
movq (%rbx), %... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pybind11.h |
pybind11::class_<sdf_tools::int3>::get_function_record(pybind11::handle) | static detail::function_record *get_function_record(handle h) {
h = detail::get_function(h);
return h ? (detail::function_record *) reinterpret_borrow<capsule>(PyCFunction_GET_SELF(h.ptr()))
: nullptr;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x3a14e
movq 0x8(%rbx), %rax
cmpq 0x18d37(%rip), %rax # 0x52e70
setne %cl
cmpq 0x18e45(%rip), %rax # 0x52f88
setne %al
testb %al, %cl
jne 0x3a14e
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
je 0x3a163
movq 0x10(%rbx), %rax
testb $0x20, 0x10(%rax)
j... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pybind11.h |
pybind11::str pybind11::str::format<int const&, int const&, int const&>(int const&, int const&, int const&) 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 0x233b(%rip), %rax # 0x3c558
movq %rax, -0x8(%rbx)
movq $0x0, (%rbx)
movq %rsp, %rdi
leaq 0x8(%rsp), %rsi
callq 0x3a27c
movq %rsp, %rsi
movq %r14, %rdi
callq 0x1e082
movq %rsp, %rdi
callq 0x14... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/pytypes.h |
pybind11::object pybind11::detail::object_api<pybind11::detail::accessor<pybind11::detail::accessor_policies::str_attr>>::operator()<(pybind11::return_value_policy)1, int const&, int const&, int const&>(int const&, int const&, int const&) const | object object_api<Derived>::operator()(Args &&...args) const {
#if !defined(NDEBUG) && PY_VERSION_HEX >= 0x03060000
if (!PyGILState_Check()) {
pybind11_fail("pybind11::object_api<>::operator() PyGILState_Check() failure.");
}
#endif
return detail::collect_arguments<policy>(std::forward<Args>(args)..... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
callq 0xbc10
testl %eax, %eax
je 0x3a2e7
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0x3a308
movq %r14, %rdi
callq 0x1663c
movq (%rax), %r... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/cast.h |
pybind11::tuple pybind11::make_tuple<(pybind11::return_value_policy)1, int const&, int const&, int const&>(int const&, int const&, int 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 %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbx
movslq (%rsi), %rdi
movq %rsp, %r13
movq %r13, %r14
callq 0xb0b0
leaq 0x8(%rsp), %r14
movq %rax, -0x8(%r14)
movslq (%r12), %rdi
callq 0xb0b0
leaq 0x10(%rsp), %r14
movq %rax, -0x8(%r14)
movs... | /amlucas[P]sdfTools/src/extern/pybind11/include/pybind11/cast.h |
main | int main(int argc, char const *argv[])
{
sisl::utility::isosurface mc;
// This reads the data into memory, we specify float here,
// which means that the lattice will hold floating values
// but we could choose other, more compact data types
cartesian_cubic<float> *cc = sisl::io::read_raw_file<float>... | pushq %rbp
movq %rsp, %rbp
subq $0x44c0, %rsp # imm = 0x44C0
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x4270(%rbp), %rdi
callq 0x38bc0
movl $0x20, -0x427c(%rbp)
movl $0x20, -0x4280(%rbp)
movl $0x20, -0x4284(%rbp)
leaq -0x42a9(%rbp), %rdi
movq %rdi, -0x4478(%rbp)
callq 0x382f0
movq -0x4478(%rbp), %rd... | /jjh13[P]sisl/examples/3_volumetric/301_bucky_isosurface/main.cpp |
sisl::cartesian_cubic<float>* sisl::io::read_raw_file<float>(int const&, int const&, int const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, sisl::e_datatype const&, bool const&) | inline cartesian_cubic<O>
*read_raw_file(const int &rx, const int &ry, const int &rz,
const std::string &file,
const e_datatype &type,
const bool &swap_endian = false) {
using namespace std;
// Define this to help indexing the raw data
... | pushq %rbp
movq %rsp, %rbp
subq $0x3a0, %rsp # imm = 0x3A0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x380b0
movq %rax, -0x300(%rbp)
movl $0x8, %edi
movl $0x4, %esi
callq 0x46fc0
movl %e... | /jjh13[P]sisl/examples/../include/sisl/io/raw_3d.hpp |
sisl::utility::isosurface::cache_vertex(std::map<int, sisl::vertex3, std::less<int>, std::allocator<std::pair<int const, sisl::vertex3>>>*, int const&, sisl::vertex3 const&, sisl::vertex3 const&, double const&, double const&, double const&, double const&, sisl::function*, bool) | inline void cache_vertex(
std::map<int, sisl::vertex3 > *vMap,
const int &vIndex,
const vertex3 &v1,
const vertex3 &v2,
const double &iVal1,
const double &iVal2,
const double &isoV... | pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp # imm = 0x1D0
movb 0x30(%rbp), %al
movq 0x28(%rbp), %r10
movq 0x20(%rbp), %r10
movq 0x18(%rbp), %r10
movq 0x10(%rbp), %r10
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
andb $... | /jjh13[P]sisl/examples/../include/sisl/utility/iso_surface.hpp |
sisl::vertex3::vertex3(double const&, double const&, double const&, double const&, double const&, double const&) | vertex3(
const double &x, const double &y, const double &z,
const double &i, const double &j, const double &k) : p(vector(3)), n(vector(3)) {
p << x,y,z;
n << i,j,k;
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movl $0x3, -0x34(%rbp)
leaq -0x34(%... | /jjh13[P]sisl/examples/../include/sisl/primitives.hpp |
sisl::utility::isosurface::processFaces(std::map<int, sisl::vertex3, std::less<int>, std::allocator<std::pair<int const, sisl::vertex3>>>*, std::vector<std::tuple<int, int, int>, std::allocator<std::tuple<int, int, int>>> const&) | void processFaces(
std::map<int, sisl::vertex3 > *vMap,
const std::vector<std::tuple<int,int,int>> &faces){
std::map<int, int> faceMap;
for(auto itr = vMap->begin(); itr != vMap->end(); ++itr) {
sisl::vertex3 v = itr->second;
int vIndex = itr->first;
... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x41c10
movq -0x10(%rbp), %rdi
callq 0x41c30
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3edf0
movq %rax, -0x58(%rbp)
leaq -... | /jjh13[P]sisl/examples/../include/sisl/utility/iso_surface.hpp |
sisl::cartesian_cubic<float>::get_nearest_site(Eigen::Matrix<double, -1, 1, 0, -1, 1> const&) const | virtual lattice_site get_nearest_site(const vector &pt) const {
int x = round(pt[0]);
int y = round(pt[1]);
int z = round(pt[2]);
lattice_site r(3);
r << x, y, z;
return r;
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x47000
movsd (%rax), %xmm0
callq 0x380c0
cvttsd2si %xmm0, %eax
movl %eax, -0x1c(%rbp... | /jjh13[P]sisl/examples/../include/sisl/lattice/3d/cartesian_cubic.hpp |
sisl::cartesian_cubic<float>::each_site(std::function<void (Eigen::Matrix<int, -1, 1, 0, -1, 1> const&)> const&, bool) | virtual void each_site(const std::function<void(const lattice_site &)> &func, bool parallel = false) {
#pragma omp parallel for if(parallel)
for(int i = 0; i <= _nx; i++) {
for(int j = 0; j <= _ny; j++) {
for(int k = 0; k <= _nz; k++) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x70(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x8(%rcx), %eax
ja 0x48c81
movl $0x0, -0x1c(%rbp)
movq -0x70(... | /jjh13[P]sisl/examples/../include/sisl/lattice/3d/cartesian_cubic.hpp |
sisl::cartesian_cubic<float>::set_extension_type(sisl::LatticeExtensionType const&, sisl::LatticeRegionShift const&) | virtual void set_extension_type(const LatticeExtensionType &e,
const LatticeRegionShift &s) {
// Check validity of the extension type
if(s == LatticeRegionShift::NoShift && e == LatticeExtensionType::ForceZero) {
m_Shift = s;
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x48e76
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x48e76
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movl (%rcx)... | /jjh13[P]sisl/examples/../include/sisl/lattice/3d/cartesian_cubic.hpp |
sisl::cartesian_cubic<float>::operator()(int, __va_list_tag*) | virtual T& operator()(int d0, va_list vl) {
unsigned int _x = d0, _y = 0, _z = 0;
_y = va_arg(vl, unsigned int);
_z = va_arg(vl, unsigned int);
__zero = 0;
if(!in_bound(_x, _y, _z)) return __zero;
return _array(_x, _y, _z);
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movl (%rax), %eax
movl ... | /jjh13[P]sisl/examples/../include/sisl/lattice/3d/cartesian_cubic.hpp |
sisl::cartesian_cubic<float>::operator()(int, __va_list_tag*) const | virtual const T& operator()(int d0, va_list vl) const {
unsigned int _x = d0, _y = 0, _z = 0;
_y = va_arg(vl, unsigned int);
_z = va_arg(vl, unsigned int);
T *__hack = (T *)&__zero; *__hack = 0;
if(!in_bound(_x, _y, _z)) return __zero;
return _arr... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
movl (%rax), %eax
movl ... | /jjh13[P]sisl/examples/../include/sisl/lattice/3d/cartesian_cubic.hpp |
sisl::array_n<float, 3, std::allocator<float>>::dump_to_stream(std::basic_ofstream<char, std::char_traits<char>>&) const | bool dump_to_stream(std::ofstream &stream) const {
if(!stream.good()) return false;
unsigned int sig = 0x53534c41; // TODO: Move this sig out into a DEFINE
unsigned int size = 1;
for(int i = 0; i < N; i++) {
size *= _dims[i];
}
s... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x382b0
testb $0x1, %al
jne 0x4a2b2
movb $0x0, -0x1(%rbp)
jmp 0x4a330
movl $0x53534c41, -0x1c(%rbp) # imm = 0x5353... | /jjh13[P]sisl/examples/../include/sisl/memory/array.hpp |
sisl::si_function<sisl::cartesian_cubic<float>, sisl::tp_linear, 3>::operator()(double, ...) const | virtual const double operator()(double d0, ...) const {
va_list vl;
vector V(N);
V[0] = d0;
va_start(vl, d0);
for(unsigned int i = 1; i < N; i++) {
V[i] = va_arg(vl, double);
}
va_end(vl);
return (*this)(V)... | pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
testb %al, %al
je 0x4a5ca
movaps %xmm1, -0xd0(%rbp)
movaps %xmm2, -0xc0(%rbp)
movaps %xmm3, -0xb0(%rbp)
movaps %xmm4, -0xa0(%rbp)
movaps %xmm5, -0x90(%rbp)
movaps %xmm6, -0x80(%rbp)
movaps %xmm7, -0x70(%rbp)
movq %r9, -0xe8(%rbp)
movq %r8, -0xf0(%rbp... | /jjh13[P]sisl/examples/../include/sisl/function/si_function.hpp |
sisl::si_function<sisl::cartesian_cubic<float>, sisl::tp_linear, 3>::d(int, Eigen::Matrix<double, -1, 1, 0, -1, 1> const&) const | virtual const double d(int component, const vector &p) const {
if(_bUseBasisDerivative && BF::has_derivative()) {
if(!_bForceScale)
return BF::template convolution_sum_deriv<N, L, BF>(
_mSpaceTransform*p,
(const L*)_... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
testb $0x1, 0x28(%rax)
je 0x4aeb2
callq 0x58000
testb $0x1, %al
jne 0x4ad89
jmp 0x4aeb2
movq -0xb8(%rbp), %rax
testb $0x1, 0x29(%rax)
j... | /jjh13[P]sisl/examples/../include/sisl/function/si_function.hpp |
sisl::si_function<sisl::cartesian_cubic<float>, sisl::tp_linear, 3>::grad(double, ...) const | virtual const vector grad(double d0, ...) const {
va_list vl;
vector V(N);
V[0] = d0;
va_start(vl, d0);
for(unsigned int i = 1; i < N; i++) {
V[i] = va_arg(vl, double);
}
va_end(vl);
return grad(V);
... | pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
movq %rdi, -0x140(%rbp)
movq %rdi, %r10
movq %r10, -0x138(%rbp)
testb %al, %al
je 0x4b07b
movaps %xmm1, -0xd0(%rbp)
movaps %xmm2, -0xc0(%rbp)
movaps %xmm3, -0xb0(%rbp)
movaps %xmm4, -0xa0(%rbp)
movaps %xmm5, -0x90(%rbp)
movaps %xmm6, -0x80(%rbp)
mova... | /jjh13[P]sisl/examples/../include/sisl/function/si_function.hpp |
double sisl::basis_function::convolution_sum_deriv<3, sisl::cartesian_cubic<float>, sisl::tp_linear>(Eigen::Matrix<double, -1, 1, 0, -1, 1> const&, sisl::cartesian_cubic<float> const*, int const&) | static double convolution_sum_deriv(const vector &p, const L *lattice, const int &component) {
auto sites = BF::template get_integer_support<N>();
lattice_site c = lattice->get_nearest_site(p);
lattice_site extent = lattice->get_dimensions();
double value = 0;
... | pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp # imm = 0x1F0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x52590
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
movq (%rsi), %rax
movq 0x70(%rax), %rax
leaq -0x40(%rbp), %rdi
callq *%rax
jmp 0x580b7
movq -0x10(%r... | /jjh13[P]sisl/examples/../include/sisl/basis/basis_function.hpp |
sisl::tp_linear::dbspline_1(double const&) | static const double dbspline_1(const double &t){
if(t > -1 && t <= 1) {
if(t < 0) {
return 1;
} else {
return -1;
}
}
return 0;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movsd 0x3a80(%rip), %xmm1 # 0x5c028
ucomisd %xmm1, %xmm0
jbe 0x585eb
movq -0x10(%rbp), %rax
movsd 0x3a66(%rip), %xmm0 # 0x5c020
ucomisd (%rax), %xmm0
jb 0x585eb
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
ucomisd (%rax), ... | /jjh13[P]sisl/examples/../include/sisl/basis/tp_linear.hpp |
Eigen::Matrix<double, -1, 1, 0, -1, 1> sisl::basis_function::grad_convolution_sum<3, sisl::cartesian_cubic<float>, sisl::tp_linear>(Eigen::Matrix<double, -1, 1, 0, -1, 1> const&, sisl::cartesian_cubic<float> const*) | static vector grad_convolution_sum(const vector &p, const L *lattice) {
auto sites = BF::template get_integer_support<N>();
lattice_site c = lattice->get_nearest_site(p);
lattice_site extent = lattice->get_dimensions();
vector value(N);
value.setZero();
... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x1b8(%rbp)
movq %rdi, %rax
movq %rax, -0x1b0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x52590
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq (%rsi), %rax
movq 0x70(%rax), ... | /jjh13[P]sisl/examples/../include/sisl/basis/basis_function.hpp |
Eigen::Matrix<double, -1, 1, 0, -1, 1> sisl::basis_function::grad_convolution_sum_h<3, sisl::cartesian_cubic<float>, sisl::tp_linear>(Eigen::Matrix<double, -1, 1, 0, -1, 1> const&, sisl::cartesian_cubic<float> const*, double const&) | static vector grad_convolution_sum_h(const vector &p, const L *lattice, const double &h) {
auto sites = BF::template get_integer_support<N>();
lattice_site c = lattice->get_nearest_site(p);
lattice_site extent = lattice->get_dimensions();
vector value(N);
val... | pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp # imm = 0x220
movq %rdi, -0x1c0(%rbp)
movq %rdi, %rax
movq %rax, -0x1b8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x52590
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq (%rsi),... | /jjh13[P]sisl/examples/../include/sisl/basis/basis_function.hpp |
Eigen::Matrix<double, -1, 1, 0, -1, 1> sisl::basis_function::grad_convolution_sum<3, sisl::cartesian_cubic<float>, sisl::tp_linear>(Eigen::Matrix<double, -1, 1, 0, -1, 1> const&, sisl::cartesian_cubic<float> const*, sisl::cartesian_cubic<float> const**) | static vector grad_convolution_sum(const vector &p, const L* base, const L **lattices) {
auto sites = BF::template get_integer_support<N>();
lattice_site c = base->get_nearest_site(p);
lattice_site extent = base->get_dimensions();
vector value(N);
value.setZe... | pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp # imm = 0x220
movq %rdi, -0x1c0(%rbp)
movq %rdi, %rax
movq %rax, -0x1b8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x52590
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq (%rsi),... | /jjh13[P]sisl/examples/../include/sisl/basis/basis_function.hpp |
Eigen::Matrix<double, -1, 1, 0, -1, 1> sisl::basis_function::grad_convolution_sum_h<3, sisl::cartesian_cubic<float>, sisl::tp_linear>(Eigen::Matrix<double, -1, 1, 0, -1, 1> const&, sisl::cartesian_cubic<float> const*, sisl::cartesian_cubic<float> const**, double const&) | static vector grad_convolution_sum_h(const vector &p, const L* base, const L **lattices, const double &h) {
auto sites = BF::template get_integer_support<N>();
lattice_site c = base->get_nearest_site(p);
lattice_site extent = base->get_dimensions();
vector value(N);
... | pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp # imm = 0x230
movq %rdi, -0x1c8(%rbp)
movq %rdi, %rax
movq %rax, -0x1c0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x52590
movq -0x18(%rbp), %rsi
movq -0x10(%r... | /jjh13[P]sisl/examples/../include/sisl/basis/basis_function.hpp |
glad_gl_has_extension | static int glad_gl_has_extension(int version, const char *exts, unsigned int num_exts_i, char **exts_i, const char *ext) {
if(GLAD_VERSION_MAJOR(version) < 3 || !GLAD_GL_IS_SOME_NEW_VERSION) {
const char *extensions;
const char *loc;
const char *terminator;
extensions = exts;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
cmpl $0x7530, %edi # imm = 0x7530
jge 0x1c5b8
movq %rsi, %r14
testq %rsi, %rsi
sete %al
testq %rbx, %rbx
sete %cl
xorl %ebp, %ebp
orb %al, %cl
jne 0x1c604
movq %r14, %rdi
movq %rbx, %rsi
callq 0x140d0
testq %rax, %rax
je 0x1c604
movq %rax, ... | /tuket[P]gltf_viewer/libs/glfw/deps/glad_gl.c |
glfwIsValidContextConfig | GLFWbool _glfwIsValidContextConfig(const _GLFWctxconfig* ctxconfig)
{
if (ctxconfig->share)
{
if (ctxconfig->client == GLFW_NO_API ||
ctxconfig->share->context.client == GLFW_NO_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
return GLFW_FALSE;
}... | pushq %rbx
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x1c630
cmpl $0x0, (%rdi)
je 0x1c69b
cmpl $0x0, 0x1f8(%rax)
je 0x1c69b
movl 0x4(%rdi), %edx
leal -0x36001(%rdx), %eax
cmpl $0x3, %eax
jae 0x1c6ad
movl (%rdi), %edx
testl %edx, %edx
je 0x1c782
cmpl $0x30001, %edx # imm = 0x30001
je 0x1c6c4
cmpl $0x30002, %edx... | /tuket[P]gltf_viewer/libs/glfw/src/context.c |
glfwRefreshContextAttribs | GLFWbool _glfwRefreshContextAttribs(_GLFWwindow* window,
const _GLFWctxconfig* ctxconfig)
{
int i;
_GLFWwindow* previous;
const char* version;
const char* prefixes[] =
{
"OpenGL ES-CM ",
"OpenGL ES-CL ",
"OpenGL ES ",
NULL
};
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r12
movq %rdi, %r14
movl 0x4(%rsi), %eax
movl %eax, 0x1fc(%rdi)
movl $0x30001, 0x1f8(%rdi) # imm = 0x30001
movl $0x1fe1c, %edi # imm = 0x1FE1C
addq 0x3b5e0(%rip), %rdi # 0x57fd8
callq 0x2a31d
movq %rax, %r15
mo... | /tuket[P]gltf_viewer/libs/glfw/src/context.c |
glfwStringInExtensionString | GLFWbool _glfwStringInExtensionString(const char* string, const char* extensions)
{
const char* start = extensions;
for (;;)
{
const char* where;
const char* terminator;
where = strstr(start, string);
if (!where)
return GLFW_FALSE;
terminator = where + ... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x140d0
testq %rax, %rax
je 0x1cfe9
movq %rax, %r15
movq %rbx, %rdi
callq 0x14230
addq %r15, %rax
cmpq %r14, %r15
je 0x1cfd5
cmpb $0x20, -0x1(%r15)
jne 0x1cfe2
movzbl (%rax), %edx
movl $0x2, %ecx
testb $-0x21, %dl
je ... | /tuket[P]gltf_viewer/libs/glfw/src/context.c |
glfwSwapInterval | GLFWAPI void glfwSwapInterval(int interval)
{
_GLFWwindow* window;
_GLFW_REQUIRE_INIT();
window = _glfwPlatformGetTls(&_glfw.contextSlot);
if (!window)
{
_glfwInputError(GLFW_NO_CURRENT_CONTEXT,
"Cannot set swap interval without a current OpenGL or OpenGL ES context... | pushq %rbx
leaq 0x75426(%rip), %rax # 0x924c0
cmpl $0x0, (%rax)
je 0x1d0c0
movl %edi, %ebx
movl $0x1fe1c, %edi # imm = 0x1FE1C
addq 0x3af2b(%rip), %rdi # 0x57fd8
callq 0x2a31d
testq %rax, %rax
je 0x1d0c9
movl %ebx, %edi
popq %rbx
jmpq *0x250(%rax)
movl $0x10001, %edi # imm = 0x10001
xorl %esi,... | /tuket[P]gltf_viewer/libs/glfw/src/context.c |
glfwGetProcAddress | GLFWAPI GLFWglproc glfwGetProcAddress(const char* procname)
{
_GLFWwindow* window;
assert(procname != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
window = _glfwPlatformGetTls(&_glfw.contextSlot);
if (!window)
{
_glfwInputError(GLFW_NO_CURRENT_CONTEXT,
"Cannot que... | pushq %rbx
testq %rdi, %rdi
je 0x1d132
leaq 0x753d6(%rip), %rax # 0x924c0
cmpl $0x0, (%rax)
je 0x1d112
movq %rdi, %rbx
movl $0x1fe1c, %edi # imm = 0x1FE1C
addq 0x3aeda(%rip), %rdi # 0x57fd8
callq 0x2a31d
testq %rax, %rax
je 0x1d11b
movq %rbx, %rdi
popq %rbx
jmpq *0x260(%rax)
movl $0x10001, %edi ... | /tuket[P]gltf_viewer/libs/glfw/src/context.c |
glfwGetError | GLFWAPI int glfwGetError(const char** description)
{
_GLFWerror* error;
int code = GLFW_NO_ERROR;
if (description)
*description = NULL;
if (_glfw.initialized)
error = _glfwPlatformGetTls(&_glfw.errorSlot);
else
error = &_glfwMainThreadError;
if (error)
{
co... | pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x1d79b
movq $0x0, (%rbx)
leaq 0x74d1e(%rip), %rax # 0x924c0
cmpl $0x0, (%rax)
je 0x1d7ba
movl $0x1fe14, %edi # imm = 0x1FE14
addq 0x3a825(%rip), %rdi # 0x57fd8
callq 0x2a31d
jmp 0x1d7c1
leaq 0x95d77(%rip), %rax # 0xb3538
testq %rax, %rax
je 0x1d7ee
te... | /tuket[P]gltf_viewer/libs/glfw/src/init.c |
glfwInputChar | void _glfwInputChar(_GLFWwindow* window, unsigned int codepoint, int mods, GLFWbool plain)
{
if (codepoint < 32 || (codepoint > 126 && codepoint < 160))
return;
if (!window->lockKeyMods)
mods &= ~(GLFW_MOD_CAPS_LOCK | GLFW_MOD_NUM_LOCK);
if (window->callbacks.charmods)
window->call... | pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %ebp
movl %esi, %ebx
cmpl $0x20, %esi
setb %al
leal -0x7f(%rbx), %ecx
cmpl $0x21, %ecx
setb %cl
orb %al, %cl
jne 0x1d8dc
movq %rdi, %r14
movq 0x330(%rdi), %rcx
testq %rcx, %rcx
je 0x1d8c1
movl %edx, %eax
andl $-0x31, %eax
cmpl $0x0, 0x70(%r14)
cmovnel %edx, %eax
movq %r14, %r... | /tuket[P]gltf_viewer/libs/glfw/src/input.c |
glfwInputCursorPos | void _glfwInputCursorPos(_GLFWwindow* window, double xpos, double ypos)
{
if (window->virtualCursorPosX == xpos && window->virtualCursorPosY == ypos)
return;
window->virtualCursorPosX = xpos;
window->virtualCursorPosY = ypos;
if (window->callbacks.cursorPos)
window->callbacks.cursorPos... | movsd 0x1e0(%rdi), %xmm2
ucomisd %xmm0, %xmm2
jne 0x1d948
jp 0x1d948
movsd 0x1e8(%rdi), %xmm2
ucomisd %xmm1, %xmm2
jne 0x1d948
jnp 0x1d966
movsd %xmm0, 0x1e0(%rdi)
movsd %xmm1, 0x1e8(%rdi)
movq 0x308(%rdi), %rax
testq %rax, %rax
je 0x1d966
jmpq *%rax
retq
| /tuket[P]gltf_viewer/libs/glfw/src/input.c |
glfwGetKey | GLFWAPI int glfwGetKey(GLFWwindow* handle, int key)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(GLFW_RELEASE);
if (key < GLFW_KEY_SPACE || key > GLFW_KEY_LAST)
{
_glfwInputError(GLFW_INVALID_ENUM, "Invalid key %i", key);
retur... | pushq %rbx
testq %rdi, %rdi
je 0x1dfb4
leaq 0x74569(%rip), %rax # 0x924c0
cmpl $0x0, (%rax)
je 0x1df82
movl %esi, %edx
leal -0x15d(%rdx), %eax
cmpl $0xfffffec2, %eax # imm = 0xFFFFFEC2
ja 0x1df94
leaq 0x2ea4b(%rip), %rsi # 0x4c9bd
xorl %ebx, %ebx
movl $0x10003, %edi # imm = 0x10003
xorl %eax, %ea... | /tuket[P]gltf_viewer/libs/glfw/src/input.c |
glfwUpdateGamepadMappings | GLFWAPI int glfwUpdateGamepadMappings(const char* string)
{
int jid;
const char* c = string;
assert(string != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
while (*c)
{
if ((*c >= '0' && *c <= '9') ||
(*c >= 'a' && *c <= 'f') ||
(*c >= 'A' && *c <= 'F'))
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x678, %rsp # imm = 0x678
testq %rdi, %rdi
je 0x1f36a
leaq 0x73825(%rip), %r12 # 0x924c0
cmpl $0x0, (%r12)
je 0x1f346
movq %rdi, %rbx
movb (%rdi), %al
testb %al, %al
je 0x1f30a
leaq 0x2e284(%rip), %r14 # 0x4cf3e
leal -0x30(%rax),... | /tuket[P]gltf_viewer/libs/glfw/src/input.c |
glfwAllocMonitor | _GLFWmonitor* _glfwAllocMonitor(const char* name, int widthMM, int heightMM)
{
_GLFWmonitor* monitor = calloc(1, sizeof(_GLFWmonitor));
monitor->widthMM = widthMM;
monitor->heightMM = heightMM;
if (name)
monitor->name = _glfw_strdup(name);
return monitor;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
movl $0x1, %edi
movl $0xa8, %esi
callq 0x14330
movq %rax, %rbx
movl %r15d, 0x10(%rax)
movl %ebp, 0x14(%rax)
testq %r14, %r14
je 0x1fc57
movq %r14, %rdi
callq 0x1d154
movq %rax, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
... | /tuket[P]gltf_viewer/libs/glfw/src/monitor.c |
glfwGetMonitorPhysicalSize | GLFWAPI void glfwGetMonitorPhysicalSize(GLFWmonitor* handle, int* widthMM, int* heightMM)
{
_GLFWmonitor* monitor = (_GLFWmonitor*) handle;
assert(monitor != NULL);
if (widthMM)
*widthMM = 0;
if (heightMM)
*heightMM = 0;
_GLFW_REQUIRE_INIT();
if (widthMM)
*widthMM = mo... | testq %rdi, %rdi
je 0x2008d
testq %rsi, %rsi
je 0x20053
movl $0x0, (%rsi)
testq %rdx, %rdx
je 0x2005e
movl $0x0, (%rdx)
leaq 0x7245b(%rip), %rax # 0x924c0
cmpl $0x0, (%rax)
je 0x2007f
testq %rsi, %rsi
je 0x20074
movl 0x10(%rdi), %eax
movl %eax, (%rsi)
testq %rdx, %rdx
je 0x2007e
movl 0x14(%rdi), %eax
movl %eax, (%r... | /tuket[P]gltf_viewer/libs/glfw/src/monitor.c |
glfwGetMonitorContentScale | GLFWAPI void glfwGetMonitorContentScale(GLFWmonitor* handle,
float* xscale, float* yscale)
{
_GLFWmonitor* monitor = (_GLFWmonitor*) handle;
assert(monitor != NULL);
if (xscale)
*xscale = 0.f;
if (yscale)
*yscale = 0.f;
_GLFW_REQUIRE_INIT();
... | testq %rdi, %rdi
je 0x200e7
testq %rsi, %rsi
je 0x200bd
movl $0x0, (%rsi)
testq %rdx, %rdx
je 0x200c8
movl $0x0, (%rdx)
leaq 0x723f1(%rip), %rax # 0x924c0
cmpl $0x0, (%rax)
je 0x200d9
jmp 0x25269
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x1d1a1
pushq %rax
leaq 0x2d099(%rip), ... | /tuket[P]gltf_viewer/libs/glfw/src/monitor.c |
glfwGetVideoModes | GLFWAPI const GLFWvidmode* glfwGetVideoModes(GLFWmonitor* handle, int* count)
{
_GLFWmonitor* monitor = (_GLFWmonitor*) handle;
assert(monitor != NULL);
assert(count != NULL);
*count = 0;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (!refreshVideoModes(monitor))
return NULL;
*count = m... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2026f
movq %rsi, %r14
testq %rsi, %rsi
je 0x2028e
movl $0x0, (%r14)
leaq 0x7228d(%rip), %rax # 0x924c0
cmpl $0x0, (%rax)
je 0x20250
movq %rdi, %rbx
callq 0x1fe00
testl %eax, %eax
je 0x20262
movl 0x28(%rbx), %eax
movl %eax, (%r14)
movq 0x20(%rbx), %rbx
jmp 0x202... | /tuket[P]gltf_viewer/libs/glfw/src/monitor.c |
glfwGetGammaRamp | GLFWAPI const GLFWgammaramp* glfwGetGammaRamp(GLFWmonitor* handle)
{
_GLFWmonitor* monitor = (_GLFWmonitor*) handle;
assert(monitor != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
_glfwFreeGammaArrays(&monitor->currentRamp);
if (!_glfwPlatformGetGammaRamp(monitor, &monitor->currentRamp))
ret... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x20508
leaq 0x71ffc(%rip), %rax # 0x924c0
cmpl $0x0, (%rax)
je 0x204ed
movq %rdi, %rbx
leaq 0x68(%rdi), %r14
movq %r14, %rdi
callq 0x1fc65
movq %rbx, %rdi
movq %r14, %rsi
callq 0x256d4
xorl %ebx, %ebx
testl %eax, %eax
cmovneq %r14, %rbx
jmp 0x204fd
xorl %ebx, %e... | /tuket[P]gltf_viewer/libs/glfw/src/monitor.c |
glfwInitVulkan | GLFWbool _glfwInitVulkan(int mode)
{
VkResult err;
VkExtensionProperties* ep;
uint32_t i, count;
if (_glfw.vk.available)
return GLFW_TRUE;
#if !defined(_GLFW_VULKAN_STATIC)
#if defined(_GLFW_VULKAN_LIBRARY)
_glfw.vk.handle = _glfw_dlopen(_GLFW_VULKAN_LIBRARY);
#elif defined(_GLFW_WIN32)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x71e36(%rip), %rbx # 0x924c0
movl $0x1, %r14d
cmpl $0x0, 0x1fe70(%rbx)
je 0x206ab
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %edi, %ebp
leaq 0x2ce54(%rip), %rdi # 0x4d50... | /tuket[P]gltf_viewer/libs/glfw/src/vulkan.c |
glfwCreateWindowSurface | GLFWAPI VkResult glfwCreateWindowSurface(VkInstance instance,
GLFWwindow* handle,
const VkAllocationCallbacks* allocator,
VkSurfaceKHR* surface)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x20ca5
movq %rsi, %r15
testq %rsi, %rsi
je 0x20cc4
movq %rcx, %rbx
testq %rcx, %rcx
je 0x20ce3
movq $0x0, (%rbx)
leaq 0x718b5(%rip), %r13 # 0x924c0
cmpl $0x0, (%r13)
je 0x20c54
movq %rdx, %r14
movq %rdi, %r12
movl $0x2, %edi
callq 0x20678
t... | /tuket[P]gltf_viewer/libs/glfw/src/vulkan.c |
glfwSetWindowTitle | GLFWAPI void glfwSetWindowTitle(GLFWwindow* handle, const char* title)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
assert(title != NULL);
_GLFW_REQUIRE_INIT();
_glfwPlatformSetWindowTitle(window, title);
} | pushq %rax
testq %rdi, %rdi
je 0x21526
testq %rsi, %rsi
je 0x21545
leaq 0x70fb4(%rip), %rax # 0x924c0
cmpl $0x0, (%rax)
je 0x21517
popq %rax
jmp 0x26c83
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
popq %rcx
jmp 0x1d1a1
leaq 0xff75(%rip), %rdi # 0x314a2
leaq 0x2c99e(%rip), %rsi ... | /tuket[P]gltf_viewer/libs/glfw/src/window.c |
glfwSetWindowPos | GLFWAPI void glfwSetWindowPos(GLFWwindow* handle, int xpos, int ypos)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
if (window->monitor)
return;
_glfwPlatformSetWindowPos(window, xpos, ypos);
} | testq %rdi, %rdi
je 0x2167e
leaq 0x70e61(%rip), %rax # 0x924c0
cmpl $0x0, (%rax)
je 0x21670
cmpq $0x0, 0x40(%rdi)
je 0x26f49
retq
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x1d1a1
pushq %rax
leaq 0xfe1c(%rip), %rdi # 0x314a2
leaq 0x2c845(%rip), %rsi # 0x4ded2
leaq 0x2... | /tuket[P]gltf_viewer/libs/glfw/src/window.c |
glfwGetFramebufferSize | GLFWAPI void glfwGetFramebufferSize(GLFWwindow* handle, int* width, int* height)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
if (width)
*width = 0;
if (height)
*height = 0;
_GLFW_REQUIRE_INIT();
_glfwPlatformGetFramebufferSize(window, width, height);
... | testq %rdi, %rdi
je 0x21985
testq %rsi, %rsi
je 0x2195b
movl $0x0, (%rsi)
testq %rdx, %rdx
je 0x21966
movl $0x0, (%rdx)
leaq 0x70b53(%rip), %rax # 0x924c0
cmpl $0x0, (%rax)
je 0x21977
jmp 0x272b3
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x1d1a1
pushq %rax
leaq 0xfb15(%rip), %... | /tuket[P]gltf_viewer/libs/glfw/src/window.c |
glfwSetWindowOpacity | GLFWAPI void glfwSetWindowOpacity(GLFWwindow* handle, float opacity)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
assert(opacity == opacity);
assert(opacity >= 0.f);
assert(opacity <= 1.f);
_GLFW_REQUIRE_INIT();
if (opacity != opacity || opacity < 0.f || opacity >... | pushq %rax
testq %rdi, %rdi
je 0x21b29
ucomiss %xmm0, %xmm0
jp 0x21b48
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jb 0x21b67
movss 0xc53e(%rip), %xmm1 # 0x2e01c
ucomiss %xmm0, %xmm1
jb 0x21b86
leaq 0x709d2(%rip), %rax # 0x924c0
cmpl $0x0, (%rax)
je 0x21b14
ucomiss 0xc522(%rip), %xmm0 # 0x2e01c
jbe 0x21b23
cvts... | /tuket[P]gltf_viewer/libs/glfw/src/window.c |
glfwGetWindowAttrib | GLFWAPI int glfwGetWindowAttrib(GLFWwindow* handle, int attrib)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(0);
switch (attrib)
{
case GLFW_FOCUSED:
return _glfwPlatformWindowFocused(window);
case GLFW_ICONIFIED:
... | pushq %rbx
testq %rdi, %rdi
je 0x21ed1
leaq 0x70701(%rip), %rax # 0x924c0
cmpl $0x0, (%rax)
je 0x21df4
movl %esi, %edx
leal -0x20001(%rdx), %eax
cmpl $0xb, %eax
jbe 0x21e08
leal -0x22001(%rdx), %eax
cmpl $0xa, %eax
ja 0x21e1e
leaq 0x2c08d(%rip), %rcx # 0x4de70
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%r... | /tuket[P]gltf_viewer/libs/glfw/src/window.c |
glfwCreateCursorX11 | Cursor _glfwCreateCursorX11(const GLFWimage* image, int xhot, int yhot)
{
int i;
Cursor cursor;
if (!_glfw.x11.xcursor.handle)
return None;
XcursorImage* native = XcursorImageCreate(image->width, image->height);
if (native == NULL)
return None;
native->xhot = xhot;
native-... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x6fe70(%rip), %r12 # 0x924c0
cmpq $0x0, 0x20d50(%r12)
je 0x22736
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
movl (%rdi), %edi
movl 0x4(%rbx), %esi
callq *0x20d58(%r12)
testq %rax, %rax
je 0x22736
movq %rax, %r14
movl %r15d, 0x10(%rax)
movl %ebp, 0x1... | /tuket[P]gltf_viewer/libs/glfw/src/x11_init.c |
glfwPollMonitorsX11 | void _glfwPollMonitorsX11(void)
{
if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
{
int disconnectedCount, screenCount = 0;
_GLFWmonitor** disconnected = NULL;
XineramaScreenInfo* screens = NULL;
XRRScreenResources* sr = XRRGetScreenResourcesCurrent(_glfw.x11.dis... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq 0x6daf3(%rip), %r13 # 0x924c0
cmpl $0x0, 0x20c50(%r13)
je 0x24a3f
cmpl $0x0, 0x20c74(%r13)
jne 0x24a3f
movl $0x0, 0x4(%rsp)
movq 0x1fec0(%r13), %rdi
movq 0x1fed0(%r13), %rsi
callq *0x20cc8(%r13)
movq %rax, %r14
movq 0x1fec0(%r13... | /tuket[P]gltf_viewer/libs/glfw/src/x11_monitor.c |
glfwPlatformSetGammaRamp | void _glfwPlatformSetGammaRamp(_GLFWmonitor* monitor, const GLFWgammaramp* ramp)
{
if (_glfw.x11.randr.available && !_glfw.x11.randr.gammaBroken)
{
if (XRRGetCrtcGammaSize(_glfw.x11.display, monitor->x11.crtc) != ramp->size)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x6cca3(%rip), %rcx # 0x924c0
cmpl $0x0, 0x20c50(%rcx)
je 0x258d2
cmpl $0x0, 0x20c70(%rcx)
jne 0x258d2
movq %rdi, %r14
movq 0x1fec0(%rcx), %rdi
movq 0x90(%r14), %rsi
movq %rcx, %r15
callq *0x20ca8(%rcx)
movl 0x18(%rbx), %edi
cmpl %edi, %eax... | /tuket[P]gltf_viewer/libs/glfw/src/x11_monitor.c |
waitForEvent | static GLFWbool waitForEvent(double* timeout)
{
fd_set fds;
const int fd = ConnectionNumber(_glfw.x11.display);
int count = fd + 1;
#if defined(__linux__)
if (_glfw.linjs.inotify > fd)
count = _glfw.linjs.inotify + 1;
#endif
for (;;)
{
FD_ZERO(&fds);
FD_SET(fd, &fds);
#i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
leaq 0x6c675(%rip), %rdx # 0x924c0
movq 0x1fec0(%rdx), %rax
movl 0x10(%rax), %ecx
movl 0x20f38(%rdx), %ebx
cmpl %ecx, %ebx
cmovlel %ecx, %ebx
incl %ebx
leal 0x3f(%rcx), %eax
testl %ecx, %ecx
cmovnsl %ecx, %eax
movl %eax, %edx
andl $-... | /tuket[P]gltf_viewer/libs/glfw/src/x11_window.c |
glfwPlatformDestroyWindow | void _glfwPlatformDestroyWindow(_GLFWwindow* window)
{
if (_glfw.x11.disabledCursorWindow == window)
_glfw.x11.disabledCursorWindow = NULL;
if (window->monitor)
releaseMonitor(window);
if (window->x11.ic)
{
XDestroyIC(window->x11.ic);
window->x11.ic = NULL;
}
i... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6b968(%rip), %r14 # 0x924c0
cmpq %rdi, 0x20ab8(%r14)
jne 0x26b6c
movq $0x0, 0x20ab8(%r14)
cmpq $0x0, 0x40(%rbx)
je 0x26b7b
movq %rbx, %rdi
callq 0x26c2e
movq 0x358(%rbx), %rdi
testq %rdi, %rdi
je 0x26b97
callq 0x144c0
movq $0x0, 0x358(%rbx)
movq 0x268(%rbx), %... | /tuket[P]gltf_viewer/libs/glfw/src/x11_window.c |
glfwPlatformGetWindowPos | void _glfwPlatformGetWindowPos(_GLFWwindow* window, int* xpos, int* ypos)
{
Window dummy;
int x, y;
XTranslateCoordinates(_glfw.x11.display, window->x11.handle, _glfw.x11.root,
0, 0, &x, &y, &dummy);
if (xpos)
*xpos = x;
if (ypos)
*ypos = y;
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x6b5cb(%rip), %rax # 0x924c0
movq 0x348(%rdi), %rsi
movq 0x1fec0(%rax), %rdi
movq 0x1fed0(%rax), %rdx
leaq 0x10(%rsp), %rax
leaq 0x8(%rsp), %r10
leaq 0xc(%rsp), %r9
xorl %ecx, %ecx
xorl %r8d, %r8d
pushq %rax
pushq %r10
callq 0x14890
addq $... | /tuket[P]gltf_viewer/libs/glfw/src/x11_window.c |
glfwPlatformGetWindowFrameSize | void _glfwPlatformGetWindowFrameSize(_GLFWwindow* window,
int* left, int* top,
int* right, int* bottom)
{
long* extents = NULL;
if (window->monitor || !window->decorated)
return;
if (_glfw.x11.NET_FRAME_EXTENTS == None)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq $0x0, 0x8(%rsp)
cmpq $0x0, 0x40(%rdi)
je 0x272eb
addq $0x1b8, %rsp # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %rbp
cmpl $0x0, 0xc(%rdi)
je 0x272d9
l... | /tuket[P]gltf_viewer/libs/glfw/src/x11_window.c |
glfwPlatformPostEmptyEvent | void _glfwPlatformPostEmptyEvent(void)
{
XEvent event = { ClientMessage };
event.xclient.window = _glfw.x11.helperWindowHandle;
event.xclient.format = 32; // Data is 32-bit longs
event.xclient.message_type = _glfw.x11.NULL_;
XSendEvent(_glfw.x11.display, _glfw.x11.helperWindowHandle, False, 0, &eve... | pushq %r14
pushq %rbx
subq $0xc8, %rsp
leaq 0x8(%rsp), %rbx
movl $0xc0, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x142b0
movl $0x21, (%rbx)
leaq 0x69034(%rip), %r14 # 0x924c0
movq 0x1fec0(%r14), %rdi
movq 0x1fee0(%r14), %rsi
movq %rsi, 0x20(%rbx)
movl $0x20, 0x30(%rbx)
movq 0x20c28(%r14), %rax
movq %rax, 0x28(%rb... | /tuket[P]gltf_viewer/libs/glfw/src/x11_window.c |
disableCursor | static void disableCursor(_GLFWwindow* window)
{
if (window->rawMouseMotion)
enableRawMouseMotion(window);
_glfw.x11.disabledCursorWindow = window;
_glfwPlatformGetCursorPos(window,
&_glfw.x11.restoreCursorPosX,
&_glfw.x11.restoreCursorPos... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x1f0(%rdi)
je 0x29631
leaq 0x4(%rsp), %rax
movw $0x0, (%rax)
movabsq $0x300000001, %rcx # imm = 0x300000001
leaq 0x8(%rsp), %rdx
movq %rcx, (%rdx)
movq %rax, 0x8(%rdx)
movb $0x2, 0x2(%rax)
leaq 0x68ea8(%rip), %rax # 0x924c0
movq 0x1fec0(%rax), ... | /tuket[P]gltf_viewer/libs/glfw/src/x11_window.c |
glfwPlatformGetPhysicalDevicePresentationSupport | int _glfwPlatformGetPhysicalDevicePresentationSupport(VkInstance instance,
VkPhysicalDevice device,
uint32_t queuefamily)
{
VisualID visualID = XVisualIDFromVisual(DefaultVisual(_glfw.x11.display,
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r12
leaq 0x68738(%rip), %r13 # 0x924c0
movq 0x1fec0(%r13), %rax
movq 0xe8(%rax), %rax
movslq 0x1fec8(%r13), %rcx
shlq $0x7, %rcx
movq 0x40(%rax,%rcx), %rdi
callq 0x148e0
movq %rax, %r15
cmpl $0x0, 0x1fea8(%r13)
movq 0... | /tuket[P]gltf_viewer/libs/glfw/src/x11_window.c |
glfwSetX11SelectionString | GLFWAPI void glfwSetX11SelectionString(const char* string)
{
_GLFW_REQUIRE_INIT();
free(_glfw.x11.primarySelectionString);
_glfw.x11.primarySelectionString = _glfw_strdup(string);
XSetSelectionOwner(_glfw.x11.display,
_glfw.x11.PRIMARY,
_glfw.x11.helperWin... | pushq %r14
pushq %rbx
pushq %rax
leaq 0x68489(%rip), %r14 # 0x924c0
cmpl $0x0, (%r14)
je 0x2a09b
movq %rdi, %rbx
movq 0x1ff08(%r14), %rdi
callq 0x14600
movq %rbx, %rdi
callq 0x1d154
movq %rax, 0x1ff08(%r14)
movq 0x20c10(%r14), %rsi
movq 0x1fec0(%r14), %rdi
movq 0x1fee0(%r14), %rdx
xorl %ecx, %ecx
callq 0x14570
movq... | /tuket[P]gltf_viewer/libs/glfw/src/x11_window.c |
convertLatin1toUTF8 | static char* convertLatin1toUTF8(const char* source)
{
size_t size = 1;
const char* sp;
for (sp = source; *sp; sp++)
size += (*sp & 0x80) ? 2 : 1;
char* target = calloc(size, 1);
char* tp = target;
for (sp = source; *sp; sp++)
tp += encodeUTF8(tp, *sp);
return target;... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb (%rdi), %cl
testb %cl, %cl
je 0x2a13f
leaq 0x1(%rbx), %rax
movl $0x1, %edi
xorl %edx, %edx
testb %cl, %cl
setns %dl
subq %rdx, %rdi
addq $0x2, %rdi
movb (%rax), %cl
incq %rax
testb %cl, %cl
jne 0x2a126
jmp 0x2a144
movl $0x1, %edi
movl $0x1, %esi
callq 0x14330
movq %... | /tuket[P]gltf_viewer/libs/glfw/src/x11_window.c |
destroyContextGLX | static void destroyContextGLX(_GLFWwindow* window)
{
if (window->context.glx.window)
{
glXDestroyWindow(_glfw.x11.display, window->context.glx.window);
window->context.glx.window = None;
}
if (window->context.glx.handle)
{
glXDestroyContext(_glfw.x11.display, window->context... | pushq %rbx
movq %rdi, %rbx
movq 0x278(%rdi), %rsi
testq %rsi, %rsi
je 0x2b380
leaq 0x67158(%rip), %rax # 0x924c0
movq 0x1fec0(%rax), %rdi
callq *0x20ed0(%rax)
movq $0x0, 0x278(%rbx)
movq 0x270(%rbx), %rsi
testq %rsi, %rsi
je 0x2b3ab
leaq 0x6712d(%rip), %rax # 0x924c0
movq 0x1fec0(%rax), %rdi
callq *0x20e98(%rax... | /tuket[P]gltf_viewer/libs/glfw/src/glx_context.c |
glfwInitEGL | GLFWbool _glfwInitEGL(void)
{
int i;
const char* sonames[] =
{
#if defined(_GLFW_EGL_LIBRARY)
_GLFW_EGL_LIBRARY,
#elif defined(_GLFW_WIN32)
"libEGL.dll",
"EGL.dll",
#elif defined(_GLFW_COCOA)
"libEGL.dylib",
#elif defined(__CYGWIN__)
"libEGL-1.so",
#else
"libE... | pushq %r14
pushq %rbx
pushq %rax
leaq 0x6700d(%rip), %r14 # 0x924c0
movl $0x1, %ebx
cmpq $0x0, 0x20fb0(%r14)
jne 0x2b886
leaq 0x25c5f(%rip), %rdi # 0x5112c
movl $0x1, %esi
callq 0x146a0
movq %rax, 0x20fb0(%r14)
testq %rax, %rax
je 0x2b816
movl $0x1, 0x20f98(%r14)
leaq 0x25c5a(%rip), %rsi # 0x51153
movq %rax... | /tuket[P]gltf_viewer/libs/glfw/src/egl_context.c |
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.