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::class_<sdf_tools::sdf::SdfUnion, std::shared_ptr<sdf_tools::sdf::SdfUnion>>, pybind11::arg, pybind11::arg, char [87], 0>(pybind11::class_<sdf_tools::sdf::SdfUnion, std::shared_ptr<sdf_tools::sdf::SdfUnion>>&, pybind11::arg const&, pybind11::arg const&, char const (&) [87])::'lambda'(pybind11::detail::value_and_holder&, std::shared_ptr<sdf_tools::sdf::Sdf>, std::shared_ptr<sdf_tools::sdf::Sdf>), pybind11::detail::is_new_style_constructor, pybind11::arg, pybind11::arg, char [87]>(char const*, pybind11::class_<sdf_tools::sdf::SdfUnion, std::shared_ptr<sdf_tools::sdf::SdfUnion>>&&, pybind11::arg const&, pybind11::arg const&, char const (&) [87])
|
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)
callq 0xb1e0
testq %rax, %rax
je 0x2b47a
movq %rax, (%rsp)
jmp 0x2b486
callq 0xb780
movq %r15, (%rsp)
incq (%r15)
movq 0x70(%rsp), %rax
movq (%rsp), %rcx
leaq 0x30(%rsp), %r8
movq %rcx, (%r8)
subq $0x8, %rsp
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rdx
leaq 0x28(%rsp), %rcx
movq %rbp, %rsi
movq %r13, %r9
pushq %rax
pushq %r12
pushq 0x30(%rsp)
callq 0x2b52a
addq $0x20, %rsp
movq %rsp, %rdi
callq 0x149d2
leaq 0x10(%rsp), %rdi
callq 0x149d2
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x234d7
leaq 0x8(%rsp), %rdi
callq 0x149d2
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x2b51d
movq %rax, %rbx
movq %rsp, %rdi
callq 0x149d2
jmp 0x2b518
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x149d2
movq %rbx, %rdi
callq 0xbe20
|
/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.holder, (type *) value);
return true;
}
}
return false;
}
|
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(%rsp), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %r13, %rdi
movq 0x8(%rsp), %rsi
movl %ebp, %edx
callq 0x2b7e4
movl %eax, %r13d
testb %al, %al
je 0x2bcbf
movq 0x20(%rsp), %rdi
callq *0x8(%rbx)
movq %rax, 0x10(%r14)
movq 0x30(%rsp), %rcx
testq %rcx, %rcx
je 0x2bcd4
movq 0x2729b(%rip), %rdx # 0x52f50
cmpb $0x0, (%rdx)
je 0x2bcd0
incl 0x8(%rcx)
jmp 0x2bcd4
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x2bcfe
callq 0xb5b0
jmp 0x2bcfe
lock
incl 0x8(%rcx)
movq %rax, 0x18(%r14)
movq 0x20(%r14), %rdi
movq %rcx, 0x20(%r14)
testq %rdi, %rdi
je 0x2bcea
callq 0xb5b0
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x2bcf9
callq 0xb5b0
testb %r13b, %r13b
jne 0x2bd0f
addq $0x10, %rbx
cmpq %r15, %rbx
setne %r12b
jne 0x2bc67
andb $0x1, %r12b
movl %r12d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x2bd37
callq 0xb5b0
movq %rbx, %rdi
callq 0xbe20
nop
|
/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();
}
init_holder(inst, v_h, (const holder_type *) holder_ptr, v_h.value_ptr<type>());
}
|
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 0x1c8f8
movq (%r15), %rcx
movb 0x30(%rcx), %al
testb $0x2, %al
jne 0x2bf56
movq 0x18(%rcx), %rax
movq 0x18(%rsp), %rcx
movb (%rax,%rcx), %al
andb $0x2, %al
jmp 0x2bf5b
shrb $0x3, %al
andb $0x1, %al
testb %al, %al
jne 0x2bfd5
movq 0x20(%rsp), %r15
movq 0x28(%rsp), %rax
movq (%rax), %r12
leaq 0x8(%rsp), %r13
movq %r12, (%r13)
leaq 0x30(%rsp), %rbp
movq %r14, (%rbp)
callq 0x14436
leaq 0x70(%rax), %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %rbp, %rcx
callq 0x20dd8
testb $0x2, 0x90(%r15)
jne 0x2bfb3
leaq -0xb204(%rip), %rcx # 0x20da1
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1f0a7
movq 0x10(%rsp), %rax
movb 0x30(%rax), %cl
testb $0x2, %cl
jne 0x2bfcf
movq 0x18(%rax), %rax
movq 0x18(%rsp), %rcx
orb $0x2, (%rax,%rcx)
jmp 0x2bfd5
orb $0x8, %cl
movb %cl, 0x30(%rax)
leaq 0x10(%rsp), %rsi
movq 0x18(%rsi), %rax
movq (%rax), %rcx
movq %r14, %rdi
movq %rbx, %rdx
callq 0x2c0a6
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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.
// If we don't, the Python API will exit with an exception, and pybind11 will
// throw error_already_set from the C++ destructor which is forbidden and triggers
// std::terminate().
error_scope scope;
if (v_h.holder_constructed()) {
v_h.holder<holder_type>().~holder_type();
v_h.set_holder_constructed(false);
}
else {
detail::call_operator_delete(v_h.value_ptr<type>(),
v_h.type->type_size,
v_h.type->type_align
);
}
v_h.value_ptr() = nullptr;
}
|
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
jne 0x2c056
movq (%rcx), %rdi
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
cmpq $0x11, %rdx
jb 0x2c07d
callq 0xb110
jmp 0x2c08a
movq 0x10(%rcx), %rdi
testq %rdi, %rdi
je 0x2c064
callq 0xb5b0
movq (%rbx), %rax
movb 0x30(%rax), %cl
testb $0x2, %cl
jne 0x2c084
movq 0x18(%rax), %rax
movq 0x8(%rbx), %rcx
andb $-0x2, (%rax,%rcx)
jmp 0x2c08a
callq 0xb800
jmp 0x2c08a
andb $-0x5, %cl
movb %cl, 0x30(%rax)
movq 0x18(%rbx), %rax
movq $0x0, (%rax)
leaq 0x8(%rsp), %rdi
callq 0x1661e
addq $0x20, %rsp
popq %rbx
retq
nop
|
/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::Sdf>>::execute<pybind11::class_<sdf_tools::sdf::SdfIntersection, std::shared_ptr<sdf_tools::sdf::SdfIntersection>>, pybind11::arg, pybind11::arg, char [87], 0>(pybind11::class_<sdf_tools::sdf::SdfIntersection, std::shared_ptr<sdf_tools::sdf::SdfIntersection>>&, pybind11::arg const&, pybind11::arg const&, char const (&) [87])::'lambda'(pybind11::detail::value_and_holder&, std::shared_ptr<sdf_tools::sdf::Sdf>, std::shared_ptr<sdf_tools::sdf::Sdf>), pybind11::detail::is_new_style_constructor, pybind11::arg, pybind11::arg, char [87]>(char const*, pybind11::class_<sdf_tools::sdf::SdfIntersection, std::shared_ptr<sdf_tools::sdf::SdfIntersection>>&&, pybind11::arg const&, pybind11::arg const&, char const (&) [87])
|
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)
callq 0xb1e0
testq %rax, %rax
je 0x2c206
movq %rax, (%rsp)
jmp 0x2c212
callq 0xb780
movq %r15, (%rsp)
incq (%r15)
movq 0x70(%rsp), %rax
movq (%rsp), %rcx
leaq 0x30(%rsp), %r8
movq %rcx, (%r8)
subq $0x8, %rsp
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rdx
leaq 0x28(%rsp), %rcx
movq %rbp, %rsi
movq %r13, %r9
pushq %rax
pushq %r12
pushq 0x30(%rsp)
callq 0x2c2b6
addq $0x20, %rsp
movq %rsp, %rdi
callq 0x149d2
leaq 0x10(%rsp), %rdi
callq 0x149d2
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x234d7
leaq 0x8(%rsp), %rdi
callq 0x149d2
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x2c2a9
movq %rax, %rbx
movq %rsp, %rdi
callq 0x149d2
jmp 0x2c2a4
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x149d2
movq %rbx, %rdi
callq 0xbe20
|
/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>(pybind11::class_<sdf_tools::sdf::SdfIntersection, std::shared_ptr<sdf_tools::sdf::SdfIntersection>>&, pybind11::arg const&, pybind11::arg const&, char const (&) [87])::'lambda'(pybind11::detail::value_and_holder&, std::shared_ptr<sdf_tools::sdf::Sdf>, std::shared_ptr<sdf_tools::sdf::Sdf>), void, pybind11::detail::value_and_holder&, std::shared_ptr<sdf_tools::sdf::Sdf>, std::shared_ptr<sdf_tools::sdf::Sdf>, pybind11::name, pybind11::is_method, pybind11::sibling, pybind11::detail::is_new_style_constructor, pybind11::arg, pybind11::arg, char [87]>(pybind11::class_<sdf_tools::sdf::SdfIntersection, std::shared_ptr<sdf_tools::sdf::SdfIntersection>>&&, void (*)(pybind11::detail::value_and_holder&, std::shared_ptr<sdf_tools::sdf::Sdf>, std::shared_ptr<sdf_tools::sdf::Sdf>), pybind11::name const&, pybind11::is_method const&, pybind11::sibling const&, pybind11::detail::is_new_style_constructor const&, pybind11::arg const&, pybind11::arg const&, char const (&) [87])
|
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 in case of an exception.
auto unique_rec = make_function_record();
auto rec = unique_rec.get();
/* Store the capture object directly in the function record if there is enough space */
if (sizeof(capture) <= sizeof(rec->data)) {
/* Without these pragmas, GCC warns that there might not be
enough space to use the placement new operator. However, the
'if' statement above ensures that this is the case. */
#if defined(__GNUG__) && __GNUC__ >= 6 && !defined(__clang__) && !defined(__INTEL_COMPILER)
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wplacement-new"
#endif
new ((capture *) &rec->data) capture { std::forward<Func>(f) };
#if defined(__GNUG__) && __GNUC__ >= 6 && !defined(__clang__) && !defined(__INTEL_COMPILER)
# pragma GCC diagnostic pop
#endif
if (!std::is_trivially_destructible<Func>::value)
rec->free_data = [](function_record *r) { ((capture *) &r->data)->~capture(); };
} else {
rec->data[0] = new capture { std::forward<Func>(f) };
rec->free_data = [](function_record *r) { delete ((capture *) r->data[0]); };
}
/* Type casters for the function arguments and return value */
using cast_in = argument_loader<Args...>;
using cast_out = make_caster<
conditional_t<std::is_void<Return>::value, void_type, Return>
>;
static_assert(expected_num_args<Extra...>(sizeof...(Args), cast_in::has_args, cast_in::has_kwargs),
"The number of argument annotations does not match the number of function arguments");
/* Dispatch code which converts function arguments and performs the actual function call */
rec->impl = [](function_call &call) -> handle {
cast_in args_converter;
/* Try to cast the function arguments into the C++ domain */
if (!args_converter.load_args(call))
return PYBIND11_TRY_NEXT_OVERLOAD;
/* Invoke call policy pre-call hook */
process_attributes<Extra...>::precall(call);
/* Get a pointer to the capture object */
auto data = (sizeof(capture) <= sizeof(call.func.data)
? &call.func.data : call.func.data[0]);
auto *cap = const_cast<capture *>(reinterpret_cast<const capture *>(data));
/* Override policy for rvalues -- usually to enforce rvp::move on an rvalue */
return_value_policy policy = return_value_policy_override<Return>::policy(call.func.policy);
/* Function scope guard -- defaults to the compile-to-nothing `void_type` */
using Guard = extract_guard_t<Extra...>;
/* Perform the function call */
handle result = cast_out::cast(
std::move(args_converter).template call<Return, Guard>(cap->f), policy, call.parent);
/* Invoke call policy post-call hook */
process_attributes<Extra...>::postcall(call, result);
return result;
};
/* Process any user-provided function attributes */
process_attributes<Extra...>::init(extra..., rec);
{
constexpr bool has_kw_only_args = any_of<std::is_same<kw_only, Extra>...>::value,
has_pos_only_args = any_of<std::is_same<pos_only, Extra>...>::value,
has_args = any_of<std::is_same<args, Args>...>::value,
has_arg_annotations = any_of<is_keyword<Extra>...>::value;
static_assert(has_arg_annotations || !has_kw_only_args, "py::kw_only requires the use of argument annotations");
static_assert(has_arg_annotations || !has_pos_only_args, "py::pos_only requires the use of argument annotations (for docstrings and aligning the annotations to the argument)");
static_assert(!(has_args && has_kw_only_args), "py::kw_only cannot be combined with a py::args argument");
}
/* Generate a readable signature describing the function's arguments and return value types */
static constexpr auto signature = _("(") + cast_in::arg_names + _(") -> ") + cast_out::name;
PYBIND11_DESCR_CONSTEXPR auto types = decltype(signature)::types();
/* Register the function with Python from generic (non-templated) code */
// Pass on the ownership over the `unique_rec` to `initialize_generic`. `rec` stays valid.
initialize_generic(std::move(unique_rec), signature.text, types.data(), sizeof...(Args));
if (cast_in::has_args) rec->has_args = true;
if (cast_in::has_kwargs) rec->has_kwargs = true;
/* Stash some additional information used by an important optimization in 'functional.h' */
using FunctionType = Return (*)(Args...);
constexpr bool is_function_ptr =
std::is_convertible<Func, FunctionType>::value &&
sizeof(capture) == sizeof(void *);
if (is_function_ptr) {
rec->is_stateless = true;
rec->data[1] = const_cast<void *>(reinterpret_cast<const void *>(&typeid(FunctionType)));
}
}
|
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
movq %rax, (%r14)
movzwl 0x59(%r14), %eax
movl %eax, %ecx
orl $0x10, %ecx
movw %cx, 0x59(%r14)
movq (%r12), %rcx
movq %rcx, 0x70(%r14)
movq (%r15), %rcx
movq %rcx, 0x78(%r14)
orl $0x12, %eax
movw %ax, 0x59(%r14)
movq %rbp, %rdi
movq %r14, %rsi
callq 0x23a62
movq 0x50(%rsp), %rdi
movq %r14, %rsi
callq 0x23a62
movq 0x58(%rsp), %rax
movq %rax, 0x8(%r14)
leaq 0x128d4(%rip), %rdx # 0x3ec6f
leaq 0x264e6(%rip), %rcx # 0x52888
movq %rsp, %rsi
movl $0x3, %r8d
movq %rbx, %rdi
callq 0x1824e
movq %rsp, %rdi
callq 0x19c8a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x19c8a
movq %rbx, %rdi
callq 0xbe20
nop
|
/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>>::execute<pybind11::class_<sdf_tools::sdf::SdfDifference, std::shared_ptr<sdf_tools::sdf::SdfDifference>>, pybind11::arg, pybind11::arg, char [138], 0>(pybind11::class_<sdf_tools::sdf::SdfDifference, std::shared_ptr<sdf_tools::sdf::SdfDifference>>&, pybind11::arg const&, pybind11::arg const&, char const (&) [138])::'lambda'(pybind11::detail::value_and_holder&, std::shared_ptr<sdf_tools::sdf::Sdf>, std::shared_ptr<sdf_tools::sdf::Sdf>), pybind11::detail::is_new_style_constructor, pybind11::arg, pybind11::arg, char [138]>(char const*, pybind11::class_<sdf_tools::sdf::SdfDifference, std::shared_ptr<sdf_tools::sdf::SdfDifference>>&&, pybind11::arg const&, pybind11::arg const&, char const (&) [138])
|
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)
callq 0xb1e0
testq %rax, %rax
je 0x2c900
movq %rax, (%rsp)
jmp 0x2c90c
callq 0xb780
movq %r15, (%rsp)
incq (%r15)
movq 0x70(%rsp), %rax
movq (%rsp), %rcx
leaq 0x30(%rsp), %r8
movq %rcx, (%r8)
subq $0x8, %rsp
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rdx
leaq 0x28(%rsp), %rcx
movq %rbp, %rsi
movq %r13, %r9
pushq %rax
pushq %r12
pushq 0x30(%rsp)
callq 0x2c9b0
addq $0x20, %rsp
movq %rsp, %rdi
callq 0x149d2
leaq 0x10(%rsp), %rdi
callq 0x149d2
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x234d7
leaq 0x8(%rsp), %rdi
callq 0x149d2
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x2c9a3
movq %rax, %rbx
movq %rsp, %rdi
callq 0x149d2
jmp 0x2c99e
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x149d2
movq %rbx, %rdi
callq 0xbe20
|
/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 length 2.");
return real2{t[0].cast<real>(), t[1].cast<real>()};
}))
.def(py::init([](py::list t) {
if (py::len(t) != 2)
throw std::runtime_error("Should have length 2.");
return real2{t[0].cast<real>(), t[1].cast<real>()};
}))
.def_readwrite("x", &real2::x)
.def_readwrite("y", &real2::y)
.def("__getitem__",
[](const real2 &v, size_t i) {
if (i == 0) return v.x;
if (i == 1) return v.y;
throw py::index_error();
return 0._r;
})
.def("__str__", [](const real2 &v) { return "({}, {})"_s.format(v.x, v.y); })
.def("__repr__",
[](const real2 &v) { return "real2({}, {})"_s.format(v.x, v.y); });
py::implicitly_convertible<py::tuple, real2>();
py::implicitly_convertible<py::list, real2>();
PYBIND11_NUMPY_DTYPE(real3, x, y, z);
py::class_<real3>(m, "real3")
.def(py::init<real, real, real>(), "x"_a, "y"_a, "z"_a)
.def(py::init([](py::tuple t) {
if (py::len(t) != 3)
throw std::runtime_error("Should have length 3.");
return real3{t[0].cast<real>(), t[1].cast<real>(), t[2].cast<real>()};
}))
.def(py::init([](py::list t) {
if (py::len(t) != 3)
throw std::runtime_error("Should have length 3.");
return real3{t[0].cast<real>(), t[1].cast<real>(), t[2].cast<real>()};
}))
.def_readwrite("x", &real3::x)
.def_readwrite("y", &real3::y)
.def_readwrite("z", &real3::z)
.def("__getitem__",
[](const real3 &v, size_t i) {
if (i == 0) return v.x;
if (i == 1) return v.y;
if (i == 2) return v.z;
throw py::index_error();
return 0._r;
})
.def("__str__", [](const real3 &v) { return "({}, {}, {})"_s.format(v.x, v.y, v.z); })
.def("__repr__",
[](const real3 &v) { return "real3({}, {}, {})"_s.format(v.x, v.y, v.z); });
py::implicitly_convertible<py::tuple, real3>();
py::implicitly_convertible<py::list, real3>();
PYBIND11_NUMPY_DTYPE(int3, x, y, z);
py::class_<int3>(m, "int3")
.def(py::init<int, int, int>(), "x"_a, "y"_a, "z"_a)
.def(py::init([](py::tuple t) {
if (py::len(t) != 3) throw std::runtime_error("Should have length 3.");
return int3{t[0].cast<int>(), t[1].cast<int>(), t[2].cast<int>()};
}))
.def(py::init([](py::list t) {
if (py::len(t) != 3) throw std::runtime_error("Should have length 3.");
return int3{t[0].cast<int>(), t[1].cast<int>(), t[2].cast<int>()};
}))
.def_readwrite("x", &int3::x)
.def_readwrite("y", &int3::y)
.def_readwrite("z", &int3::z)
.def("__getitem__",
[](const int3 &v, size_t i) {
if (i == 0) return v.x;
if (i == 1) return v.y;
if (i == 2) return v.z;
throw py::index_error();
return 0;
})
.def("__str__", [](const int3 &v) { return "({}, {}, {})"_s.format(v.x, v.y, v.z); })
.def("__repr__",
[](const int3 &v) { return "int3({}, {}, {})"_s.format(v.x, v.y, v.z); });
py::implicitly_convertible<py::tuple, int3>();
py::implicitly_convertible<py::list, int3>();
}
|
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), %r14
movl $0x1, %esi
movl $0x66, %edx
callq 0xb8f0
leaq 0x98(%rsp), %rdi
callq 0x30dfa
leaq 0xa0(%rsp), %r14
leaq 0x111e1(%rip), %r13 # 0x3eee3
movq %r13, (%r14)
movl $0x4, %eax
movq %rax, 0x8(%r14)
movq %rax, 0x10(%r14)
leaq 0xb8(%rsp), %rdi
leaq 0xc8(%rsp), %rax
movq %rax, -0x10(%rax)
movl $0x1, %esi
movl $0x66, %edx
callq 0xb8f0
leaq 0xd8(%rsp), %r15
movq %r15, %rdi
callq 0x30dfa
leaq 0x40(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x30(%rsp), %rcx
movl $0x2, %edx
callq 0x30e4c
movaps 0x40(%rsp), %xmm0
leaq 0x160(%rsp), %rdi
movaps %xmm0, (%rdi)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movq $0x0, 0x50(%rsp)
callq 0x30d9a
leaq 0x160(%rsp), %rdi
callq 0x30e94
leaq 0x40(%rsp), %rdi
callq 0x30e94
movq $-0x80, %rbx
movq %r15, %rdi
callq 0x149d2
movq -0x20(%r15), %rdi
leaq -0x10(%r15), %rax
cmpq %rdi, %rax
je 0x2ddcb
movq (%rax), %rsi
incq %rsi
callq 0xb800
addq $-0x40, %r15
addq $0x40, %rbx
jne 0x2ddab
movq 0x58(%rsp), %rax
movq (%rax), %rsi
leaq 0x10fe9(%rip), %rdx # 0x3edcd
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x30ec4
leaq 0x60(%rsp), %r14
movq %r12, (%r14)
movb $0x2, %al
movb %al, 0x8(%r14)
leaq 0x40(%rsp), %r9
movq %r13, (%r9)
movb %al, 0x8(%r9)
leaq 0xe063(%rip), %rsi # 0x3be75
leaq 0x30(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %r8
callq 0x36f78
movq 0x20(%rsp), %r15
movq 0x25095(%rip), %r12 # 0x52ec8
movq %r12, 0x18(%rsp)
incq (%r12)
leaq 0xe032(%rip), %rbx # 0x3be75
movq %r15, %rdi
movq %rbx, %rsi
callq 0xb1e0
testq %rax, %rax
je 0x2de5a
movq %rax, 0x8(%rsp)
jmp 0x2de68
callq 0xb780
movq %r12, 0x8(%rsp)
incq (%r12)
movq 0x8(%rsp), %r13
leaq 0x10(%rsp), %rsi
movq $0x0, (%rsi)
leaq 0x30(%rsp), %rdi
callq 0x18208
leaq 0x30(%rsp), %rsi
movq (%rsi), %rax
leaq 0x1710(%rip), %rcx # 0x2f5a2
movq %rcx, 0x30(%rax)
movq %rbx, (%rax)
movq %r15, 0x70(%rax)
movq %r13, 0x78(%rax)
orb $0x12, 0x59(%rax)
leaq 0x114f5(%rip), %rdx # 0x3f3a1
leaq 0x24b7d(%rip), %rcx # 0x52a30
leaq 0x10(%rsp), %rdi
movl $0x2, %r8d
callq 0x1824e
leaq 0x30(%rsp), %rdi
callq 0x19c8a
leaq 0x8(%rsp), %rdi
callq 0x149d2
leaq 0x18(%rsp), %rdi
callq 0x149d2
leaq 0xdf8d(%rip), %rsi # 0x3be75
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x234d7
leaq 0x10(%rsp), %rdi
callq 0x149d2
movq 0x20(%rsp), %rbx
movq %r12, 0x18(%rsp)
incq (%r12)
leaq 0xdf5f(%rip), %r15 # 0x3be75
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb1e0
testq %rax, %rax
je 0x2df2d
movq %rax, 0x8(%rsp)
jmp 0x2df3b
callq 0xb780
movq %r12, 0x8(%rsp)
incq (%r12)
movq 0x8(%rsp), %r13
leaq 0x10(%rsp), %rsi
movq $0x0, (%rsi)
leaq 0x30(%rsp), %rdi
callq 0x18208
leaq 0x30(%rsp), %rsi
movq (%rsi), %rax
leaq 0x18c5(%rip), %rcx # 0x2f82a
movq %rcx, 0x30(%rax)
movq %r15, (%rax)
movq %rbx, 0x70(%rax)
movq %r13, 0x78(%rax)
orb $0x12, 0x59(%rax)
leaq 0x11435(%rip), %rdx # 0x3f3b4
leaq 0x24ac2(%rip), %rcx # 0x52a48
leaq 0x10(%rsp), %rdi
movl $0x2, %r8d
callq 0x1824e
leaq 0x30(%rsp), %rdi
callq 0x19c8a
leaq 0x8(%rsp), %rdi
callq 0x149d2
leaq 0x18(%rsp), %rdi
callq 0x149d2
leaq 0xdeba(%rip), %rsi # 0x3be75
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x234d7
leaq 0x10(%rsp), %rdi
callq 0x149d2
leaq 0xfbae(%rip), %rsi # 0x3db89
leaq 0x20(%rsp), %rdi
xorl %edx, %edx
callq 0x30f6c
leaq 0x10ef5(%rip), %rsi # 0x3eee3
movl $0x4, %edx
movq %rax, %rdi
callq 0x30f6c
movq %rax, %r13
movq (%rax), %rbp
movq %r12, 0x18(%rsp)
incq (%r12)
leaq 0x10dc2(%rip), %rbx # 0x3edd3
movq %rbp, %rdi
movq %rbx, %rsi
callq 0xb1e0
testq %rax, %rax
je 0x2e028
movq %rax, 0x8(%rsp)
jmp 0x2e036
callq 0xb780
movq %r12, 0x8(%rsp)
incq (%r12)
movq 0x8(%rsp), %r15
leaq 0x10(%rsp), %rsi
movq $0x0, (%rsi)
leaq 0x30(%rsp), %rdi
callq 0x18208
leaq 0x30(%rsp), %rsi
movq (%rsi), %rax
leaq 0x1a96(%rip), %rcx # 0x2faf6
movq %rcx, 0x30(%rax)
movq %rbx, (%rax)
orb $0x10, 0x59(%rax)
movq %rbp, 0x70(%rax)
movq %r15, 0x78(%rax)
leaq 0x1134d(%rip), %rdx # 0x3f3c7
leaq 0x249df(%rip), %rcx # 0x52a60
leaq 0x10(%rsp), %rdi
movl $0x2, %r8d
callq 0x1824e
leaq 0x30(%rsp), %rdi
callq 0x19c8a
leaq 0x8(%rsp), %rdi
callq 0x149d2
leaq 0x18(%rsp), %rdi
callq 0x149d2
leaq 0x10d1d(%rip), %rsi # 0x3edd3
leaq 0x10(%rsp), %rdx
movq %r13, %rdi
callq 0x234d7
leaq 0x10(%rsp), %rdi
callq 0x149d2
movq (%r13), %rbp
movq %r12, 0x18(%rsp)
incq (%r12)
leaq 0x10cfe(%rip), %rbx # 0x3eddf
movq %rbp, %rdi
movq %rbx, %rsi
callq 0xb1e0
testq %rax, %rax
je 0x2e0f8
movq %rax, 0x8(%rsp)
jmp 0x2e106
callq 0xb780
movq %r12, 0x8(%rsp)
incq (%r12)
movq 0x8(%rsp), %r15
leaq 0x10(%rsp), %rsi
movq $0x0, (%rsi)
leaq 0x30(%rsp), %rdi
callq 0x18208
leaq 0x30(%rsp), %rsi
movq (%rsi), %rax
leaq 0x1a72(%rip), %rcx # 0x2fba2
movq %rcx, 0x30(%rax)
movq %rbx, (%rax)
orb $0x10, 0x59(%rax)
movq %rbp, 0x70(%rax)
movq %r15, 0x78(%rax)
leaq 0x11293(%rip), %rdx # 0x3f3dd
leaq 0x2491f(%rip), %rcx # 0x52a70
leaq 0x10(%rsp), %rdi
movl $0x1, %r8d
callq 0x1824e
leaq 0x30(%rsp), %rdi
callq 0x19c8a
leaq 0x8(%rsp), %rdi
callq 0x149d2
leaq 0x18(%rsp), %rdi
callq 0x149d2
leaq 0x10c59(%rip), %rsi # 0x3eddf
leaq 0x10(%rsp), %rdx
movq %r13, %rdi
callq 0x234d7
leaq 0x10(%rsp), %rdi
callq 0x149d2
movq (%r13), %rbp
movq %r12, 0x18(%rsp)
incq (%r12)
leaq 0x10c36(%rip), %rbx # 0x3ede7
movq %rbp, %rdi
movq %rbx, %rsi
callq 0xb1e0
testq %rax, %rax
je 0x2e1c8
movq %rax, 0x8(%rsp)
jmp 0x2e1d6
callq 0xb780
movq %r12, 0x8(%rsp)
incq (%r12)
movq 0x8(%rsp), %r15
leaq 0x10(%rsp), %rsi
movq $0x0, (%rsi)
leaq 0x30(%rsp), %rdi
callq 0x18208
leaq 0x30(%rsp), %rsi
movq (%rsi), %rax
leaq 0x1ac6(%rip), %rcx # 0x2fcc6
movq %rcx, 0x30(%rax)
movq %rbx, (%rax)
orb $0x10, 0x59(%rax)
movq %rbp, 0x70(%rax)
movq %r15, 0x78(%rax)
leaq 0x111ce(%rip), %rdx # 0x3f3e8
leaq 0x24867(%rip), %rcx # 0x52a88
leaq 0x10(%rsp), %rdi
movl $0x1, %r8d
callq 0x1824e
leaq 0x30(%rsp), %rdi
callq 0x19c8a
leaq 0x8(%rsp), %rdi
callq 0x149d2
leaq 0x18(%rsp), %rdi
callq 0x149d2
leaq 0x10b91(%rip), %rsi # 0x3ede7
leaq 0x10(%rsp), %rdx
movq %r13, %rdi
callq 0x234d7
leaq 0x10(%rsp), %rdi
callq 0x149d2
leaq 0x20(%rsp), %rdi
callq 0x149d2
callq 0x3102f
callq 0x310d9
leaq 0x78(%rsp), %rdi
leaq 0xf8fc(%rip), %rax # 0x3db89
movq %rax, -0x18(%rdi)
movq $0x0, -0x10(%rdi)
movq $0x4, -0x8(%rdi)
leaq 0x88(%rsp), %rax
movq %rax, (%rdi)
movl $0x1, %esi
movl $0x66, %edx
callq 0xb8f0
leaq 0x98(%rsp), %rdi
callq 0x30dfa
leaq 0xa0(%rsp), %r14
leaq 0x10c0c(%rip), %rax # 0x3eee3
movq %rax, (%r14)
movl $0x4, %eax
movq %rax, 0x8(%r14)
movq %rax, 0x10(%r14)
leaq 0xb8(%rsp), %rdi
leaq 0xc8(%rsp), %rax
movq %rax, (%rdi)
movl $0x1, %esi
movl $0x66, %edx
callq 0xb8f0
leaq 0xd8(%rsp), %rdi
callq 0x30dfa
leaq 0xe0(%rsp), %r14
leaq 0xee3f(%rip), %r15 # 0x3d164
movq %r15, (%r14)
movq $0x8, 0x8(%r14)
movq $0x4, 0x10(%r14)
leaq 0xf8(%rsp), %rdi
leaq 0x108(%rsp), %rax
movq %rax, -0x10(%rax)
movl $0x1, %esi
movl $0x66, %edx
callq 0xb8f0
leaq 0x118(%rsp), %rbp
movq %rbp, %rdi
callq 0x30dfa
leaq 0x40(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x30(%rsp), %r13
movl $0x3, %edx
movq %r13, %rcx
callq 0x30e4c
movaps 0x40(%rsp), %xmm0
leaq 0x140(%rsp), %rdi
movaps %xmm0, (%rdi)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movq $0x0, 0x50(%rsp)
callq 0x31184
leaq 0x140(%rsp), %rdi
callq 0x30e94
leaq 0x40(%rsp), %rdi
callq 0x30e94
movq $-0xc0, %rbx
movq %rbp, %rdi
callq 0x149d2
movq -0x20(%rbp), %rdi
leaq -0x10(%rbp), %rax
cmpq %rdi, %rax
je 0x2e3f4
movq (%rax), %rsi
incq %rsi
callq 0xb800
addq $-0x40, %rbp
addq $0x40, %rbx
jne 0x2e3d4
movq 0x58(%rsp), %rax
movq (%rax), %rsi
leaq 0x109e3(%rip), %rdx # 0x3edf0
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x311e4
leaq 0x60(%rsp), %r14
leaq 0xf763(%rip), %rax # 0x3db89
movq %rax, (%r14)
movb $0x2, %al
movb %al, 0x8(%r14)
leaq 0x40(%rsp), %r9
leaq 0x10aa8(%rip), %rcx # 0x3eee3
movq %rcx, (%r9)
movb %al, 0x8(%r9)
movq %r15, 0x30(%rsp)
movb %al, 0x38(%rsp)
movq %r13, (%rsp)
leaq 0xda1f(%rip), %rsi # 0x3be75
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %r8
callq 0x38a4e
movq 0x28(%rsp), %rbx
movq %r12, 0x20(%rsp)
incq (%r12)
leaq 0xd9f5(%rip), %r15 # 0x3be75
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb1e0
testq %rax, %rax
je 0x2e497
movq %rax, 0x18(%rsp)
jmp 0x2e4a5
callq 0xb780
movq %r12, 0x18(%rsp)
incq (%r12)
movq 0x18(%rsp), %r13
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x18208
leaq 0x10(%rsp), %rsi
movq (%rsi), %rax
leaq 0x190f(%rip), %rcx # 0x2fdde
movq %rcx, 0x30(%rax)
movq %r15, (%rax)
movq %rbx, 0x70(%rax)
movq %r13, 0x78(%rax)
orb $0x12, 0x59(%rax)
leaq 0x10f0a(%rip), %rdx # 0x3f3f3
leaq 0x245b0(%rip), %rcx # 0x52aa0
leaq 0x8(%rsp), %rdi
movl $0x2, %r8d
callq 0x1824e
leaq 0x10(%rsp), %rdi
callq 0x19c8a
leaq 0x18(%rsp), %rdi
callq 0x149d2
leaq 0x20(%rsp), %rdi
callq 0x149d2
leaq 0xd950(%rip), %rsi # 0x3be75
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x234d7
leaq 0x8(%rsp), %rdi
callq 0x149d2
movq 0x28(%rsp), %rbx
movq %r12, 0x20(%rsp)
incq (%r12)
leaq 0xd922(%rip), %r15 # 0x3be75
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb1e0
testq %rax, %rax
je 0x2e56a
movq %rax, 0x18(%rsp)
jmp 0x2e578
callq 0xb780
movq %r12, 0x18(%rsp)
incq (%r12)
movq 0x18(%rsp), %r13
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x18208
leaq 0x10(%rsp), %rsi
movq (%rsi), %rax
leaq 0x1ad8(%rip), %rcx # 0x3007a
movq %rcx, 0x30(%rax)
movq %r15, (%rax)
movq %rbx, 0x70(%rax)
movq %r13, 0x78(%rax)
orb $0x12, 0x59(%rax)
leaq 0x10e4a(%rip), %rdx # 0x3f406
leaq 0x244f5(%rip), %rcx # 0x52ab8
leaq 0x8(%rsp), %rdi
movl $0x2, %r8d
callq 0x1824e
leaq 0x10(%rsp), %rdi
callq 0x19c8a
leaq 0x18(%rsp), %rdi
callq 0x149d2
leaq 0x20(%rsp), %rdi
callq 0x149d2
leaq 0xd87d(%rip), %rsi # 0x3be75
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x234d7
leaq 0x8(%rsp), %rdi
callq 0x149d2
leaq 0xf571(%rip), %rsi # 0x3db89
leaq 0x28(%rsp), %rdi
xorl %edx, %edx
callq 0x3128e
leaq 0x108b8(%rip), %rsi # 0x3eee3
movl $0x4, %edx
movq %rax, %rdi
callq 0x3128e
leaq 0xeb25(%rip), %rsi # 0x3d164
movl $0x8, %edx
movq %rax, %rdi
callq 0x3128e
movq %rax, %rbp
movq (%rax), %rbx
movq %r12, 0x20(%rsp)
incq (%r12)
leaq 0x10771(%rip), %r15 # 0x3edd3
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb1e0
testq %rax, %rax
je 0x2e679
movq %rax, 0x18(%rsp)
jmp 0x2e687
callq 0xb780
movq %r12, 0x18(%rsp)
incq (%r12)
movq 0x18(%rsp), %r13
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x18208
leaq 0x10(%rsp), %rsi
movq (%rsi), %rax
leaq 0x1c65(%rip), %rcx # 0x30316
movq %rcx, 0x30(%rax)
movq %r15, (%rax)
orb $0x10, 0x59(%rax)
movq %rbx, 0x70(%rax)
movq %r13, 0x78(%rax)
leaq 0x10d4e(%rip), %rdx # 0x3f419
leaq 0x243fe(%rip), %rcx # 0x52ad0
leaq 0x8(%rsp), %rdi
movl $0x2, %r8d
callq 0x1824e
leaq 0x10(%rsp), %rdi
callq 0x19c8a
leaq 0x18(%rsp), %rdi
callq 0x149d2
leaq 0x20(%rsp), %rdi
callq 0x149d2
leaq 0x106cc(%rip), %rsi # 0x3edd3
leaq 0x8(%rsp), %rdx
movq %rbp, %rdi
callq 0x234d7
leaq 0x8(%rsp), %rdi
callq 0x149d2
movq (%rbp), %rbx
movq %r12, 0x20(%rsp)
incq (%r12)
leaq 0x106ad(%rip), %r15 # 0x3eddf
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb1e0
testq %rax, %rax
je 0x2e749
movq %rax, 0x18(%rsp)
jmp 0x2e757
callq 0xb780
movq %r12, 0x18(%rsp)
incq (%r12)
movq 0x18(%rsp), %r13
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x18208
leaq 0x10(%rsp), %rsi
movq (%rsi), %rax
leaq 0x1c4d(%rip), %rcx # 0x303ce
movq %rcx, 0x30(%rax)
movq %r15, (%rax)
orb $0x10, 0x59(%rax)
movq %rbx, 0x70(%rax)
movq %r13, 0x78(%rax)
leaq 0x10c94(%rip), %rdx # 0x3f42f
leaq 0x2433e(%rip), %rcx # 0x52ae0
leaq 0x8(%rsp), %rdi
movl $0x1, %r8d
callq 0x1824e
leaq 0x10(%rsp), %rdi
callq 0x19c8a
leaq 0x18(%rsp), %rdi
callq 0x149d2
leaq 0x20(%rsp), %rdi
callq 0x149d2
leaq 0x10608(%rip), %rsi # 0x3eddf
leaq 0x8(%rsp), %rdx
movq %rbp, %rdi
callq 0x234d7
leaq 0x8(%rsp), %rdi
callq 0x149d2
movq (%rbp), %rbx
movq %r12, 0x20(%rsp)
incq (%r12)
leaq 0x105e5(%rip), %r15 # 0x3ede7
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb1e0
testq %rax, %rax
je 0x2e819
movq %rax, 0x18(%rsp)
jmp 0x2e827
callq 0xb780
movq %r12, 0x18(%rsp)
incq (%r12)
movq 0x18(%rsp), %r13
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x18208
leaq 0x10(%rsp), %rsi
movq (%rsi), %rax
leaq 0x1c49(%rip), %rcx # 0x3049a
movq %rcx, 0x30(%rax)
movq %r15, (%rax)
orb $0x10, 0x59(%rax)
movq %rbx, 0x70(%rax)
movq %r13, 0x78(%rax)
leaq 0x10bcf(%rip), %rdx # 0x3f43a
leaq 0x24286(%rip), %rcx # 0x52af8
leaq 0x8(%rsp), %rdi
movl $0x1, %r8d
callq 0x1824e
leaq 0x10(%rsp), %rdi
callq 0x19c8a
leaq 0x18(%rsp), %rdi
callq 0x149d2
leaq 0x20(%rsp), %rdi
callq 0x149d2
leaq 0x10540(%rip), %rsi # 0x3ede7
leaq 0x8(%rsp), %rdx
movq %rbp, %rdi
callq 0x234d7
leaq 0xf2ce(%rip), %r15 # 0x3db89
leaq 0x10621(%rip), %r13 # 0x3eee3
leaq 0x8(%rsp), %rdi
callq 0x149d2
leaq 0x28(%rsp), %rdi
callq 0x149d2
callq 0x31351
callq 0x313fb
leaq 0x78(%rsp), %rdi
movq %r15, -0x18(%rdi)
movq $0x0, -0x10(%rdi)
movq $0x4, -0x8(%rdi)
leaq 0x88(%rsp), %rax
movq %rax, (%rdi)
movl $0x1, %esi
movl $0x69, %edx
callq 0xb8f0
leaq 0x98(%rsp), %rdi
callq 0x31506
leaq 0xa0(%rsp), %r14
movq %r13, (%r14)
movl $0x4, %eax
movq %rax, 0x8(%r14)
movq %rax, 0x10(%r14)
leaq 0xb8(%rsp), %rdi
leaq 0xc8(%rsp), %rax
movq %rax, (%rdi)
movl $0x1, %esi
movl $0x69, %edx
callq 0xb8f0
leaq 0xd8(%rsp), %rdi
callq 0x31506
leaq 0xe0(%rsp), %r14
leaq 0xe7ee(%rip), %rax # 0x3d164
movq %rax, (%r14)
movq $0x8, 0x8(%r14)
movq $0x4, 0x10(%r14)
leaq 0xf8(%rsp), %rdi
leaq 0x108(%rsp), %rax
movq %rax, (%rdi)
movl $0x1, %esi
movl $0x69, %edx
callq 0xb8f0
leaq 0x118(%rsp), %rbp
movq %rbp, %rdi
callq 0x31506
leaq 0x40(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x30(%rsp), %r14
movl $0x3, %edx
movq %r14, %rcx
callq 0x30e4c
movaps 0x40(%rsp), %xmm0
leaq 0x120(%rsp), %rdi
movaps %xmm0, (%rdi)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movq $0x0, 0x50(%rsp)
callq 0x314a6
leaq 0x120(%rsp), %rdi
callq 0x30e94
leaq 0x40(%rsp), %rdi
callq 0x30e94
movq $-0xc0, %rbx
movq %rbp, %rdi
callq 0x149d2
movq -0x20(%rbp), %rdi
leaq -0x10(%rbp), %rax
cmpq %rdi, %rax
je 0x2ea44
movq (%rax), %rsi
incq %rsi
callq 0xb800
addq $-0x40, %rbp
addq $0x40, %rbx
jne 0x2ea24
movq 0x58(%rsp), %rax
movq (%rax), %rsi
leaq 0x10399(%rip), %rdx # 0x3edf6
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x31530
leaq 0x60(%rsp), %r8
movq %r15, (%r8)
movb $0x2, %al
movb %al, 0x8(%r8)
leaq 0x40(%rsp), %r9
movq %r13, (%r9)
movb %al, 0x8(%r9)
leaq 0xe6d9(%rip), %rcx # 0x3d164
movq %rcx, 0x30(%rsp)
movb %al, 0x38(%rsp)
movq %r14, (%rsp)
leaq 0xd3d6(%rip), %rsi # 0x3be75
leaq 0x10(%rsp), %rdx
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
callq 0x39ae0
movq 0x28(%rsp), %rbx
movq %r12, 0x20(%rsp)
incq (%r12)
leaq 0xd3af(%rip), %r14 # 0x3be75
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb1e0
testq %rax, %rax
je 0x2eadd
movq %rax, 0x18(%rsp)
jmp 0x2eaeb
callq 0xb780
movq %r12, 0x18(%rsp)
incq (%r12)
movq 0x18(%rsp), %r15
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x18208
leaq 0x10(%rsp), %rsi
movq (%rsi), %rax
leaq 0x1aa1(%rip), %rcx # 0x305b6
movq %rcx, 0x30(%rax)
movq %r14, (%rax)
movq %rbx, 0x70(%rax)
movq %r15, 0x78(%rax)
orb $0x12, 0x59(%rax)
leaq 0x10916(%rip), %rdx # 0x3f445
leaq 0x23fda(%rip), %rcx # 0x52b10
leaq 0x8(%rsp), %rdi
movl $0x2, %r8d
callq 0x1824e
leaq 0x10(%rsp), %rdi
callq 0x19c8a
leaq 0x18(%rsp), %rdi
callq 0x149d2
leaq 0x20(%rsp), %rdi
callq 0x149d2
leaq 0xd30a(%rip), %rsi # 0x3be75
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x234d7
leaq 0x8(%rsp), %rdi
callq 0x149d2
movq 0x28(%rsp), %rbx
movq %r12, 0x20(%rsp)
incq (%r12)
leaq 0xd2dc(%rip), %r14 # 0x3be75
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb1e0
testq %rax, %rax
je 0x2ebb0
movq %rax, 0x18(%rsp)
jmp 0x2ebbe
callq 0xb780
movq %r12, 0x18(%rsp)
incq (%r12)
movq 0x18(%rsp), %r15
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x18208
leaq 0x10(%rsp), %rsi
movq (%rsi), %rax
leaq 0x1c44(%rip), %rcx # 0x3082c
movq %rcx, 0x30(%rax)
movq %r14, (%rax)
movq %rbx, 0x70(%rax)
movq %r15, 0x78(%rax)
orb $0x12, 0x59(%rax)
leaq 0x10856(%rip), %rdx # 0x3f458
leaq 0x23f1f(%rip), %rcx # 0x52b28
leaq 0x8(%rsp), %rdi
movl $0x2, %r8d
callq 0x1824e
leaq 0x10(%rsp), %rdi
callq 0x19c8a
leaq 0x18(%rsp), %rdi
callq 0x149d2
leaq 0x20(%rsp), %rdi
callq 0x149d2
leaq 0xd237(%rip), %rsi # 0x3be75
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x234d7
leaq 0x8(%rsp), %rdi
callq 0x149d2
leaq 0xef2b(%rip), %rsi # 0x3db89
leaq 0x28(%rsp), %rdi
xorl %edx, %edx
callq 0x315da
leaq 0x10272(%rip), %rsi # 0x3eee3
movl $0x4, %edx
movq %rax, %rdi
callq 0x315da
leaq 0xe4df(%rip), %rsi # 0x3d164
movl $0x8, %edx
movq %rax, %rdi
callq 0x315da
movq %rax, %rbx
movq (%rax), %r14
movq %r12, 0x20(%rsp)
incq (%r12)
leaq 0x1012b(%rip), %r15 # 0x3edd3
movq %r14, %rdi
movq %r15, %rsi
callq 0xb1e0
testq %rax, %rax
je 0x2ecbf
movq %rax, 0x18(%rsp)
jmp 0x2eccd
callq 0xb780
movq %r12, 0x18(%rsp)
incq (%r12)
movq 0x18(%rsp), %r13
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x18208
leaq 0x10(%rsp), %rsi
movq (%rsi), %rax
leaq 0x1dab(%rip), %rcx # 0x30aa2
movq %rcx, 0x30(%rax)
movq %r15, (%rax)
orb $0x10, 0x59(%rax)
movq %r14, 0x70(%rax)
movq %r13, 0x78(%rax)
leaq 0x1075a(%rip), %rdx # 0x3f46b
leaq 0x23e28(%rip), %rcx # 0x52b40
leaq 0x8(%rsp), %rdi
movl $0x2, %r8d
callq 0x1824e
leaq 0x10(%rsp), %rdi
callq 0x19c8a
leaq 0x18(%rsp), %rdi
callq 0x149d2
leaq 0x20(%rsp), %rdi
callq 0x149d2
leaq 0x10086(%rip), %rsi # 0x3edd3
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x234d7
leaq 0x8(%rsp), %rdi
callq 0x149d2
movq (%rbx), %r14
movq %r12, 0x20(%rsp)
incq (%r12)
leaq 0x10068(%rip), %r15 # 0x3eddf
movq %r14, %rdi
movq %r15, %rsi
callq 0xb1e0
testq %rax, %rax
je 0x2ed8e
movq %rax, 0x18(%rsp)
jmp 0x2ed9c
callq 0xb780
movq %r12, 0x18(%rsp)
incq (%r12)
movq 0x18(%rsp), %r13
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x18208
leaq 0x10(%rsp), %rsi
movq (%rsi), %rax
leaq 0x1d90(%rip), %rcx # 0x30b56
movq %rcx, 0x30(%rax)
movq %r15, (%rax)
orb $0x10, 0x59(%rax)
movq %r14, 0x70(%rax)
movq %r13, 0x78(%rax)
leaq 0x1069f(%rip), %rdx # 0x3f47f
leaq 0x23d69(%rip), %rcx # 0x52b50
leaq 0x8(%rsp), %rdi
movl $0x1, %r8d
callq 0x1824e
leaq 0x10(%rsp), %rdi
callq 0x19c8a
leaq 0x18(%rsp), %rdi
callq 0x149d2
leaq 0x20(%rsp), %rdi
callq 0x149d2
leaq 0xffc3(%rip), %rsi # 0x3eddf
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x234d7
leaq 0x8(%rsp), %rdi
callq 0x149d2
movq (%rbx), %r14
movq %r12, 0x20(%rsp)
incq (%r12)
leaq 0xffa1(%rip), %r15 # 0x3ede7
movq %r14, %rdi
movq %r15, %rsi
callq 0xb1e0
testq %rax, %rax
je 0x2ee5d
movq %rax, 0x18(%rsp)
jmp 0x2ee6b
callq 0xb780
movq %r12, 0x18(%rsp)
incq (%r12)
movq 0x18(%rsp), %r12
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x18208
leaq 0x10(%rsp), %rsi
movq (%rsi), %rax
leaq 0x1de9(%rip), %rcx # 0x30c7e
movq %rcx, 0x30(%rax)
movq %r15, (%rax)
orb $0x10, 0x59(%rax)
movq %r14, 0x70(%rax)
movq %r12, 0x78(%rax)
leaq 0x105db(%rip), %rdx # 0x3f48a
leaq 0x23cb2(%rip), %rcx # 0x52b68
leaq 0x8(%rsp), %rdi
movl $0x1, %r8d
callq 0x1824e
leaq 0x10(%rsp), %rdi
callq 0x19c8a
leaq 0x18(%rsp), %rdi
callq 0x149d2
leaq 0x20(%rsp), %rdi
callq 0x149d2
leaq 0xfefc(%rip), %rsi # 0x3ede7
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x234d7
leaq 0x8(%rsp), %rdi
callq 0x149d2
leaq 0x28(%rsp), %rdi
callq 0x149d2
callq 0x3169d
callq 0x31747
addq $0x178, %rsp # imm = 0x178
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2f04f
jmp 0x2f05c
jmp 0x2f06b
jmp 0x2f04f
jmp 0x2f05c
jmp 0x2f06b
jmp 0x2f04f
jmp 0x2f05c
jmp 0x2f06b
jmp 0x2f04f
jmp 0x2f05c
jmp 0x2f06b
jmp 0x2f04f
jmp 0x2f05c
jmp 0x2f06b
jmp 0x2f2c6
movq %rax, %rbx
leaq 0x120(%rsp), %rdi
callq 0x30e94
leaq 0x40(%rsp), %rdi
callq 0x30e94
jmp 0x2ef97
movq %rax, %rbx
movl $0x80, %r14d
leaq (%rsp,%r14), %rdi
addq $0x60, %rdi
callq 0x30e24
addq $-0x40, %r14
cmpq $-0x40, %r14
jne 0x2ef9d
jmp 0x2f277
movq %rax, %rbx
movq 0xf8(%rsp), %rdi
leaq 0x108(%rsp), %rax
cmpq %rax, %rdi
je 0x2f2a9
movq 0x108(%rsp), %rsi
jmp 0x2f02a
movq %rax, %rbx
movq 0xb8(%rsp), %rdi
leaq 0xc8(%rsp), %rax
cmpq %rax, %rdi
je 0x2f2a9
movq 0xc8(%rsp), %rsi
jmp 0x2f02a
movq %rax, %rbx
leaq 0x60(%rsp), %r14
movq 0x18(%r14), %rdi
leaq 0x88(%rsp), %rax
cmpq %rax, %rdi
je 0x2f2a9
movq 0x88(%rsp), %rsi
incq %rsi
callq 0xb800
jmp 0x2f2a9
jmp 0x2f04f
jmp 0x2f05c
jmp 0x2f06b
jmp 0x2f04f
jmp 0x2f05c
jmp 0x2f06b
jmp 0x2f04f
jmp 0x2f05c
jmp 0x2f06b
jmp 0x2f04f
jmp 0x2f05c
jmp 0x2f06b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x2f24c
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x19c8a
jmp 0x2f06e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x149d2
leaq 0x18(%rsp), %rdi
callq 0x149d2
jmp 0x2f247
jmp 0x2f2c6
movq %rax, %rbx
leaq 0x140(%rsp), %rdi
callq 0x30e94
leaq 0x40(%rsp), %rdi
callq 0x30e94
jmp 0x2f0ab
movq %rax, %rbx
movl $0x80, %r14d
leaq (%rsp,%r14), %rdi
addq $0x60, %rdi
callq 0x30e24
addq $-0x40, %r14
cmpq $-0x40, %r14
jne 0x2f0b1
jmp 0x2f277
movq %rax, %rbx
movq 0xf8(%rsp), %rdi
leaq 0x108(%rsp), %rax
cmpq %rax, %rdi
je 0x2f2ce
movq 0x108(%rsp), %rsi
jmp 0x2f13e
movq %rax, %rbx
movq 0xb8(%rsp), %rdi
leaq 0xc8(%rsp), %rax
cmpq %rax, %rdi
je 0x2f2ce
movq 0xc8(%rsp), %rsi
jmp 0x2f13e
movq %rax, %rbx
leaq 0x60(%rsp), %r14
movq 0x18(%r14), %rdi
leaq 0x88(%rsp), %rax
cmpq %rax, %rdi
je 0x2f2ce
movq 0x88(%rsp), %rsi
incq %rsi
callq 0xb800
jmp 0x2f2ce
jmp 0x2f163
jmp 0x2f170
jmp 0x2f17f
jmp 0x2f163
jmp 0x2f170
jmp 0x2f17f
jmp 0x2f163
jmp 0x2f170
jmp 0x2f17f
jmp 0x2f163
jmp 0x2f170
jmp 0x2f17f
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x2f268
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x19c8a
jmp 0x2f182
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x149d2
leaq 0x8(%rsp), %rdi
callq 0x149d2
jmp 0x2f263
jmp 0x2f27f
movq %rax, %rbx
leaq 0x160(%rsp), %rdi
callq 0x30e94
leaq 0x40(%rsp), %rdi
callq 0x30e94
jmp 0x2f1bf
movq %rax, %rbx
movl $0x40, %r14d
leaq (%rsp,%r14), %rdi
addq $0x60, %rdi
callq 0x30e24
addq $-0x40, %r14
cmpq $-0x40, %r14
jne 0x2f1c5
jmp 0x2f277
movq %rax, %rbx
movq 0xb8(%rsp), %rdi
leaq 0xc8(%rsp), %rax
cmpq %rax, %rdi
je 0x2f287
movq 0xc8(%rsp), %rsi
jmp 0x2f228
movq %rax, %rbx
leaq 0x60(%rsp), %r14
movq 0x18(%r14), %rdi
leaq 0x88(%rsp), %rax
cmpq %rax, %rdi
je 0x2f287
movq 0x88(%rsp), %rsi
incq %rsi
callq 0xb800
jmp 0x2f287
jmp 0x2f244
jmp 0x2f244
jmp 0x2f244
jmp 0x2f244
jmp 0x2f244
jmp 0x2f244
jmp 0x2f244
jmp 0x2f244
jmp 0x2f244
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x149d2
leaq 0x28(%rsp), %rdi
jmp 0x2f272
jmp 0x2f260
jmp 0x2f260
jmp 0x2f260
jmp 0x2f260
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x149d2
leaq 0x20(%rsp), %rdi
callq 0x149d2
movq %rbx, %rdi
callq 0xbe20
movq %rax, %rbx
jmp 0x2f26d
movq %rax, %rbx
leaq 0x60(%rsp), %r15
cmpq %r14, %r15
je 0x2f277
addq $-0x40, %r14
movq %r14, %rdi
callq 0x30e24
cmpq %r15, %r14
jne 0x2f291
jmp 0x2f277
jmp 0x2f2c6
movq %rax, %rbx
leaq 0x60(%rsp), %r15
cmpq %r14, %r15
je 0x2f277
addq $-0x40, %r14
movq %r14, %rdi
callq 0x30e24
cmpq %r15, %r14
jne 0x2f2b3
jmp 0x2f277
movq %rax, %rbx
jmp 0x2f251
movq %rax, %rbx
leaq 0x60(%rsp), %r15
cmpq %r14, %r15
je 0x2f277
addq $-0x40, %r14
movq %r14, %rdi
callq 0x30e24
cmpq %r15, %r14
jne 0x2f2d8
jmp 0x2f277
|
/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), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x2f48d
movq (%rbx), %rsi
incq %rsi
callq 0xb800
movq %r14, %rdi
callq 0xbe20
|
/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), %rsi
incq %rsi
callq 0xb800
movq %r14, %rdi
callq 0xbe20
nop
|
/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 0x2faee
movq (%r15), %rsi
incq %rsi
callq 0xb800
movq %r14, %rdi
callq 0xbe20
|
/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 0x305ae
movq (%r15), %rsi
incq %rsi
callq 0xb800
movq %r14, %rdi
callq 0xbe20
|
/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)
callq 0x149d2
movq %r14, %rdi
callq 0x149d2
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/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 api;
#define DECL_NPY_API(Func) api.Func##_ = (decltype(api.Func##_)) api_ptr[API_##Func];
DECL_NPY_API(PyArray_GetNDArrayCFeatureVersion);
if (api.PyArray_GetNDArrayCFeatureVersion_() < 0x7)
pybind11_fail("pybind11 numpy support requires numpy >= 1.7.0");
DECL_NPY_API(PyArray_Type);
DECL_NPY_API(PyVoidArrType_Type);
DECL_NPY_API(PyArrayDescr_Type);
DECL_NPY_API(PyArray_DescrFromType);
DECL_NPY_API(PyArray_DescrFromScalar);
DECL_NPY_API(PyArray_FromAny);
DECL_NPY_API(PyArray_Resize);
DECL_NPY_API(PyArray_CopyInto);
DECL_NPY_API(PyArray_NewCopy);
DECL_NPY_API(PyArray_NewFromDescr);
DECL_NPY_API(PyArray_DescrNewFromType);
DECL_NPY_API(PyArray_DescrConverter);
DECL_NPY_API(PyArray_EquivTypes);
DECL_NPY_API(PyArray_GetArrayParamsFromObject);
DECL_NPY_API(PyArray_Squeeze);
DECL_NPY_API(PyArray_SetBaseObject);
#undef DECL_NPY_API
return api;
}
|
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
callq 0x1663c
movq (%rax), %rdi
xorl %esi, %esi
callq 0xba10
movq %rax, %r15
movq 0x698(%rax), %rax
movq %rax, (%rbx)
callq *%rax
cmpl $0x6, %eax
jbe 0x33ad2
movq 0x10(%r15), %rax
movq %rax, 0x30(%rbx)
movq 0x138(%r15), %rax
movq %rax, 0x38(%rbx)
movq 0x18(%r15), %rax
movq %rax, 0x40(%rbx)
movq 0x168(%r15), %rax
movq %rax, 0x8(%rbx)
movq 0x1c8(%r15), %rax
movq %rax, 0x48(%rbx)
movq 0x228(%r15), %rax
movq %rax, 0x50(%rbx)
movq 0x280(%r15), %rax
movq %rax, 0x80(%rbx)
movq 0x290(%r15), %rax
movq %rax, 0x20(%rbx)
movq 0x2a8(%r15), %rax
movq %rax, 0x28(%rbx)
movq 0x2f0(%r15), %rax
movq %rax, 0x10(%rbx)
movq 0x300(%r15), %rax
movq %rax, 0x18(%rbx)
movq 0x570(%r15), %rax
movq %rax, 0x58(%rbx)
movq 0x5b0(%r15), %rax
movq %rax, 0x60(%rbx)
movq 0x8b0(%r15), %rax
movq %rax, 0x68(%rbx)
movq 0x440(%r15), %rax
movq %rax, 0x70(%rbx)
movq 0x8d0(%r15), %rax
movq %rax, 0x78(%rbx)
movq %r14, %rdi
callq 0x149d2
leaq 0x8(%rsp), %rdi
callq 0x149d2
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0xb417(%rip), %rdi # 0x3eef0
callq 0x14b04
movq %rax, %rbx
movq %r14, %rdi
callq 0x149d2
leaq 0x8(%rsp), %rdi
callq 0x149d2
movq %rbx, %rdi
callq 0xbe20
nop
|
/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)...).call(derived().ptr());
}
|
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
popq %r14
retq
leaq 0x6c27(%rip), %rdi # 0x3b8ca
callq 0x14b04
movq %rax, %rbx
movq %rsp, %rdi
callq 0x149d2
movq %rbx, %rdi
callq 0xbe20
nop
|
/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
popq %rbx
popq %r14
retq
nop
|
/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, %rdi
callq 0xbe20
nop
|
/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, %rdi
callq 0xbe20
|
/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();
}
init_holder(inst, v_h, (const holder_type *) holder_ptr, v_h.value_ptr<type>());
}
|
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 0x1c8f8
movq (%r15), %rcx
movb 0x30(%rcx), %al
testb $0x2, %al
jne 0x36dd2
movq 0x18(%rcx), %rax
movq 0x18(%rsp), %rcx
movb (%rax,%rcx), %al
andb $0x2, %al
jmp 0x36dd7
shrb $0x3, %al
andb $0x1, %al
testb %al, %al
jne 0x36e51
movq 0x20(%rsp), %r15
movq 0x28(%rsp), %rax
movq (%rax), %r12
leaq 0x8(%rsp), %r13
movq %r12, (%r13)
leaq 0x30(%rsp), %rbp
movq %r14, (%rbp)
callq 0x14436
leaq 0x70(%rax), %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %rbp, %rcx
callq 0x20dd8
testb $0x2, 0x90(%r15)
jne 0x36e2f
leaq -0x16080(%rip), %rcx # 0x20da1
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1f0a7
movq 0x10(%rsp), %rax
movb 0x30(%rax), %cl
testb $0x2, %cl
jne 0x36e4b
movq 0x18(%rax), %rax
movq 0x18(%rsp), %rcx
orb $0x2, (%rax,%rcx)
jmp 0x36e51
orb $0x8, %cl
movb %cl, 0x30(%rax)
leaq 0x10(%rsp), %rsi
movq 0x18(%rsi), %rax
movq (%rax), %rcx
movq %r14, %rdi
movq %rbx, %rdx
callq 0x36f2e
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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.
// If we don't, the Python API will exit with an exception, and pybind11 will
// throw error_already_set from the C++ destructor which is forbidden and triggers
// std::terminate().
error_scope scope;
if (v_h.holder_constructed()) {
v_h.holder<holder_type>().~holder_type();
v_h.set_holder_constructed(false);
}
else {
detail::call_operator_delete(v_h.value_ptr<type>(),
v_h.type->type_size,
v_h.type->type_align
);
}
v_h.value_ptr() = nullptr;
}
|
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, %al
jne 0x36ed2
movq (%r14), %rdi
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
cmpq $0x11, %rdx
jb 0x36f06
callq 0xb110
jmp 0x36f13
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x36ee5
movl $0x8, %esi
callq 0xb800
movq $0x0, 0x8(%r14)
movq (%rbx), %rax
movb 0x30(%rax), %cl
testb $0x2, %cl
jne 0x36f0d
movq 0x18(%rax), %rax
movq 0x8(%rbx), %rcx
andb $-0x2, (%rax,%rcx)
jmp 0x36f13
callq 0xb800
jmp 0x36f13
andb $-0x5, %cl
movb %cl, 0x30(%rax)
movq 0x18(%rbx), %rax
movq $0x0, (%rax)
movq %rsp, %rdi
callq 0x1661e
addq $0x18, %rsp
popq %rbx
popq %r14
retq
|
/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])...})
if (!r)
return false;
#endif
return true;
}
|
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 %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x24c96
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/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_function_record(fget), rec_fset = get_function_record(fset);
auto *rec_active = rec_fget;
if (rec_fget) {
char *doc_prev = rec_fget->doc; /* 'extra' field may include a property-specific documentation string */
detail::process_attributes<Extra...>::init(extra..., rec_fget);
if (rec_fget->doc && rec_fget->doc != doc_prev) {
free(doc_prev);
rec_fget->doc = strdup(rec_fget->doc);
}
}
if (rec_fset) {
char *doc_prev = rec_fset->doc;
detail::process_attributes<Extra...>::init(extra..., rec_fset);
if (rec_fset->doc && rec_fset->doc != doc_prev) {
free(doc_prev);
rec_fset->doc = strdup(rec_fset->doc);
}
if (! rec_active) rec_active = rec_fset;
}
def_property_static_impl(name, fget, fset, rec_active);
return *this;
}
|
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
movq %rcx, 0x70(%r13)
movb (%rbp), %cl
movb %cl, 0x58(%r13)
testq %rax, %rax
je 0x3788e
orb $0x10, 0x59(%rax)
testq %r13, %r13
movq (%r14), %rcx
movq %rcx, 0x70(%rax)
movb (%rbp), %cl
movb %cl, 0x58(%rax)
cmoveq %rax, %r13
movq (%r12), %rdx
movq (%r15), %rcx
movq %rbx, %rdi
movq (%rsp), %rsi
movq %r13, %r8
callq 0x37940
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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)...).call(derived().ptr());
}
|
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), %rdx
movq %rbx, %rdi
movq %rsp, %rsi
callq 0x15392
movq %rsp, %rdi
callq 0x149d2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3d5b(%rip), %rdi # 0x3b8ca
callq 0x14b04
movq %rax, %rbx
movq %rsp, %rdi
callq 0x149d2
movq %rbx, %rdi
callq 0xbe20
|
/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])...})
if (!r)
return false;
#endif
return true;
}
|
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 %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x37e90
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/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[i]) {
#if defined(NDEBUG)
throw cast_error("make_tuple(): unable to convert arguments to Python object (compile in debug mode for details)");
#else
std::array<std::string, size> argtypes { {type_id<Args>()...} };
throw cast_error("make_tuple(): unable to convert argument of type '" +
argtypes[i] + "' to Python object");
#endif
}
}
tuple result(size);
int counter = 0;
for (auto &arg_value : args)
PyTuple_SET_ITEM(result.ptr(), counter++, arg_value.release().ptr());
return result;
}
|
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, %r12d
cmpq $0x0, (%rcx)
je 0x381db
addq $-0x20, %r12
addq $0x8, %rcx
cmpq $-0x20, %r12
je 0x3815d
movl $0x2, %esi
movq %rbx, %rdi
callq 0x1563c
xorl %eax, %eax
movq (%rsp,%rax), %rcx
movq $0x0, (%rsp,%rax)
movq (%rbx), %rdx
movq 0x8(%rdx), %rsi
testb $0x4, 0xab(%rsi)
je 0x38250
movq %rcx, 0x18(%rdx,%rax)
addq $0x8, %rax
cmpq $0x10, %rax
jne 0x38180
movl $0x8, %r14d
leaq (%rsp,%r14), %rdi
callq 0x149d2
addq $-0x8, %r14
cmpq $-0x8, %r14
jne 0x381b5
movq %rbx, %rax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x50(%rsp), %r14
movq %r14, %r15
movq %r14, %rdi
callq 0x2fc69
leaq 0x70(%rsp), %r15
movq %r15, %rdi
callq 0x2fc69
movl $0x10, %edi
callq 0xb310
movq %rax, %r14
leaq 0x50(%rsp), %rdx
subq %r12, %rdx
leaq 0x36f5(%rip), %rsi # 0x3b909
leaq 0x30(%rsp), %rdi
callq 0xb700
leaq 0x3717(%rip), %rsi # 0x3b93c
leaq 0x30(%rsp), %rdi
callq 0xbf80
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x3826f
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x3827c
leaq 0x36f8(%rip), %rdi # 0x3b94f
leaq 0x370d(%rip), %rsi # 0x3b96b
leaq 0x6ed8(%rip), %rcx # 0x3f13d
movl $0x3d9, %edx # imm = 0x3D9
callq 0xb470
movq %rdx, 0x10(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x20(%rsp)
movq 0x8(%rax), %rdx
leaq 0x10(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %r14, %rdi
callq 0xb980
leaq 0x19f7e(%rip), %rax # 0x52228
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0x19f0a(%rip), %rsi # 0x521c0
movq 0x1ac7b(%rip), %rdx # 0x52f38
movq %r14, %rdi
callq 0xbdc0
movq %rax, %rbx
jmp 0x38386
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x382ef
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xb800
jmp 0x382ef
movq %rax, %rbx
movb $0x1, %bpl
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x38334
movq 0x40(%rsp), %rsi
incq %rsi
callq 0xb800
jmp 0x38334
movq %rax, %rbx
cmpq %r14, %r12
je 0x3839f
movq %rsp, %r15
addq $-0x8, %r14
movq %r14, %rdi
callq 0x149d2
cmpq %r15, %r14
jne 0x3831b
jmp 0x3839f
movq %rax, %rbx
movb $0x1, %bpl
testb %bpl, %bpl
je 0x38341
movq %r14, %rdi
callq 0xb510
leaq 0x80(%rsp), %r14
xorl %r15d, %r15d
movq 0x70(%rsp,%r15), %rdi
leaq (%r14,%r15), %rax
cmpq %rdi, %rax
je 0x38365
movq (%rax), %rsi
incq %rsi
callq 0xb800
addq $-0x20, %r15
cmpq $-0x40, %r15
jne 0x3834c
jmp 0x38386
movq %rax, %rbx
cmpq %r15, %r14
je 0x38386
leaq 0x50(%rsp), %rsi
movq %r15, %rdi
callq 0xcc6c
movl $0x8, %r14d
leaq (%rsp,%r14), %rdi
callq 0x149d2
addq $-0x8, %r14
cmpq $-0x8, %r14
jne 0x3838c
movq %rbx, %rdi
callq 0xbe20
nop
|
/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(%rip), %rsi # 0x52338
movl $0x1, %edx
callq 0x32142
movq (%rax), %rax
movq %rax, 0x1b3d2(%rip) # 0x53bf8
leaq 0x1b3d3(%rip), %rdi # 0x53c00
callq 0xb450
jmp 0x387dd
movq %rax, %rbx
leaq 0x1b3c2(%rip), %rdi # 0x53c00
callq 0xb440
movq %rbx, %rdi
callq 0xbe20
nop
|
/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.
// If we don't, the Python API will exit with an exception, and pybind11 will
// throw error_already_set from the C++ destructor which is forbidden and triggers
// std::terminate().
error_scope scope;
if (v_h.holder_constructed()) {
v_h.holder<holder_type>().~holder_type();
v_h.set_holder_constructed(false);
}
else {
detail::call_operator_delete(v_h.value_ptr<type>(),
v_h.type->type_size,
v_h.type->type_align
);
}
v_h.value_ptr() = nullptr;
}
|
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, %al
jne 0x389a8
movq (%r14), %rdi
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
cmpq $0x11, %rdx
jb 0x389dc
callq 0xb110
jmp 0x389e9
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x389bb
movl $0xc, %esi
callq 0xb800
movq $0x0, 0x8(%r14)
movq (%rbx), %rax
movb 0x30(%rax), %cl
testb $0x2, %cl
jne 0x389e3
movq 0x18(%rax), %rax
movq 0x8(%rbx), %rcx
andb $-0x2, (%rax,%rcx)
jmp 0x389e9
callq 0xb800
jmp 0x389e9
andb $-0x5, %cl
movb %cl, 0x30(%rax)
movq 0x18(%rbx), %rax
movq $0x0, (%rax)
movq %rsp, %rdi
callq 0x1661e
addq $0x18, %rsp
popq %rbx
popq %r14
retq
|
/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>());
v_h.set_holder_constructed();
} else if (inst->owned || detail::always_construct_holder<holder_type>::value) {
new (std::addressof(v_h.holder<holder_type>())) holder_type(v_h.value_ptr<type>());
v_h.set_holder_constructed();
}
}
|
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), %rcx
orb $0x1, (%rax,%rcx)
retq
orb $0x4, %cl
movb %cl, 0x30(%rax)
retq
nop
|
/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::detail::value_and_holder&, float, float, float), void, pybind11::detail::value_and_holder&, float, float, float, pybind11::name, pybind11::is_method, pybind11::sibling, pybind11::detail::is_new_style_constructor, pybind11::arg, pybind11::arg, pybind11::arg>(pybind11::class_<sdf_tools::real3>&&, void (*)(pybind11::detail::value_and_holder&, float, float, float), pybind11::name const&, pybind11::is_method const&, pybind11::sibling const&, pybind11::detail::is_new_style_constructor const&, pybind11::arg const&, pybind11::arg const&, pybind11::arg const&)
|
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 in case of an exception.
auto unique_rec = make_function_record();
auto rec = unique_rec.get();
/* Store the capture object directly in the function record if there is enough space */
if (sizeof(capture) <= sizeof(rec->data)) {
/* Without these pragmas, GCC warns that there might not be
enough space to use the placement new operator. However, the
'if' statement above ensures that this is the case. */
#if defined(__GNUG__) && __GNUC__ >= 6 && !defined(__clang__) && !defined(__INTEL_COMPILER)
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wplacement-new"
#endif
new ((capture *) &rec->data) capture { std::forward<Func>(f) };
#if defined(__GNUG__) && __GNUC__ >= 6 && !defined(__clang__) && !defined(__INTEL_COMPILER)
# pragma GCC diagnostic pop
#endif
if (!std::is_trivially_destructible<Func>::value)
rec->free_data = [](function_record *r) { ((capture *) &r->data)->~capture(); };
} else {
rec->data[0] = new capture { std::forward<Func>(f) };
rec->free_data = [](function_record *r) { delete ((capture *) r->data[0]); };
}
/* Type casters for the function arguments and return value */
using cast_in = argument_loader<Args...>;
using cast_out = make_caster<
conditional_t<std::is_void<Return>::value, void_type, Return>
>;
static_assert(expected_num_args<Extra...>(sizeof...(Args), cast_in::has_args, cast_in::has_kwargs),
"The number of argument annotations does not match the number of function arguments");
/* Dispatch code which converts function arguments and performs the actual function call */
rec->impl = [](function_call &call) -> handle {
cast_in args_converter;
/* Try to cast the function arguments into the C++ domain */
if (!args_converter.load_args(call))
return PYBIND11_TRY_NEXT_OVERLOAD;
/* Invoke call policy pre-call hook */
process_attributes<Extra...>::precall(call);
/* Get a pointer to the capture object */
auto data = (sizeof(capture) <= sizeof(call.func.data)
? &call.func.data : call.func.data[0]);
auto *cap = const_cast<capture *>(reinterpret_cast<const capture *>(data));
/* Override policy for rvalues -- usually to enforce rvp::move on an rvalue */
return_value_policy policy = return_value_policy_override<Return>::policy(call.func.policy);
/* Function scope guard -- defaults to the compile-to-nothing `void_type` */
using Guard = extract_guard_t<Extra...>;
/* Perform the function call */
handle result = cast_out::cast(
std::move(args_converter).template call<Return, Guard>(cap->f), policy, call.parent);
/* Invoke call policy post-call hook */
process_attributes<Extra...>::postcall(call, result);
return result;
};
/* Process any user-provided function attributes */
process_attributes<Extra...>::init(extra..., rec);
{
constexpr bool has_kw_only_args = any_of<std::is_same<kw_only, Extra>...>::value,
has_pos_only_args = any_of<std::is_same<pos_only, Extra>...>::value,
has_args = any_of<std::is_same<args, Args>...>::value,
has_arg_annotations = any_of<is_keyword<Extra>...>::value;
static_assert(has_arg_annotations || !has_kw_only_args, "py::kw_only requires the use of argument annotations");
static_assert(has_arg_annotations || !has_pos_only_args, "py::pos_only requires the use of argument annotations (for docstrings and aligning the annotations to the argument)");
static_assert(!(has_args && has_kw_only_args), "py::kw_only cannot be combined with a py::args argument");
}
/* Generate a readable signature describing the function's arguments and return value types */
static constexpr auto signature = _("(") + cast_in::arg_names + _(") -> ") + cast_out::name;
PYBIND11_DESCR_CONSTEXPR auto types = decltype(signature)::types();
/* Register the function with Python from generic (non-templated) code */
// Pass on the ownership over the `unique_rec` to `initialize_generic`. `rec` stays valid.
initialize_generic(std::move(unique_rec), signature.text, types.data(), sizeof...(Args));
if (cast_in::has_args) rec->has_args = true;
if (cast_in::has_kwargs) rec->has_kwargs = true;
/* Stash some additional information used by an important optimization in 'functional.h' */
using FunctionType = Return (*)(Args...);
constexpr bool is_function_ptr =
std::is_convertible<Func, FunctionType>::value &&
sizeof(capture) == sizeof(void *);
if (is_function_ptr) {
rec->is_stateless = true;
rec->data[1] = const_cast<void *>(reinterpret_cast<const void *>(&typeid(FunctionType)));
}
}
|
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
movq %r15, %rsi
movq %r14, %rdx
movq 0x40(%rsp), %rcx
movq %rbp, %r8
movq 0x50(%rsp), %r9
pushq %rax
pushq 0x60(%rsp)
callq 0x38c4a
addq $0x10, %rsp
leaq 0x6900(%rip), %rdx # 0x3f508
leaq 0x1a009(%rip), %rcx # 0x52c18
movq %rsp, %rsi
movl $0x4, %r8d
movq %rbx, %rdi
callq 0x1824e
movq %rsp, %rdi
callq 0x19c8a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x19c8a
movq %rbx, %rdi
callq 0xbe20
|
/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])...})
if (!r)
return false;
#endif
return true;
}
|
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 %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x24c96
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/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)
jne 0x3914e
movq 0x18(%rbx), %rax
jmp 0x39150
xorl %r14d, %r14d
jmp 0x39167
xorl %eax, %eax
movq %rax, (%rsp)
testq %rax, %rax
je 0x3915c
incq (%rax)
movq %rsp, %rdi
callq 0x1c89e
movq %rax, %r14
testq %rbx, %rbx
je 0x39174
movq %rsp, %rdi
callq 0x149d2
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x149d2
movq %rbx, %rdi
callq 0xbe20
|
/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])...})
if (!r)
return false;
#endif
return true;
}
|
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 %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x37e90
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/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 0x149d2
movq %rbx, %rdi
callq 0x149d2
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0x149d2
jmp 0x39251
movq %rax, %r14
movq %rbx, %rdi
callq 0x149d2
movq %r14, %rdi
callq 0xbe20
nop
|
/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)...).call(derived().ptr());
}
|
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), %rdx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x15392
leaq 0x8(%rsp), %rdi
callq 0x149d2
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x25f6(%rip), %rdi # 0x3b8ca
callq 0x14b04
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x149d2
movq %rbx, %rdi
callq 0xbe20
|
/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_ptr(), descr.ptr())) {
value = ((PyVoidScalarObject_Proxy *) obj)->obval;
return true;
}
}
return false;
}
|
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), %r15
callq 0x39864
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq *%r15
testb %al, %al
je 0x39833
movq 0x18(%r14), %rax
movq %rax, (%rbx)
movb $0x1, %bl
jmp 0x39835
xorl %ebx, %ebx
leaq 0x8(%rsp), %rdi
callq 0x149d2
jmp 0x39843
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x149d2
movq %rbx, %rdi
callq 0xbe20
|
/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();
}
init_holder(inst, v_h, (const holder_type *) holder_ptr, v_h.value_ptr<type>());
}
|
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 0x1c8f8
movq (%r15), %rcx
movb 0x30(%rcx), %al
testb $0x2, %al
jne 0x3993a
movq 0x18(%rcx), %rax
movq 0x18(%rsp), %rcx
movb (%rax,%rcx), %al
andb $0x2, %al
jmp 0x3993f
shrb $0x3, %al
andb $0x1, %al
testb %al, %al
jne 0x399b9
movq 0x20(%rsp), %r15
movq 0x28(%rsp), %rax
movq (%rax), %r12
leaq 0x8(%rsp), %r13
movq %r12, (%r13)
leaq 0x30(%rsp), %rbp
movq %r14, (%rbp)
callq 0x14436
leaq 0x70(%rax), %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %rbp, %rcx
callq 0x20dd8
testb $0x2, 0x90(%r15)
jne 0x39997
leaq -0x18be8(%rip), %rcx # 0x20da1
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1f0a7
movq 0x10(%rsp), %rax
movb 0x30(%rax), %cl
testb $0x2, %cl
jne 0x399b3
movq 0x18(%rax), %rax
movq 0x18(%rsp), %rcx
orb $0x2, (%rax,%rcx)
jmp 0x399b9
orb $0x8, %cl
movb %cl, 0x30(%rax)
leaq 0x10(%rsp), %rsi
movq 0x18(%rsi), %rax
movq (%rax), %rcx
movq %r14, %rdi
movq %rbx, %rdx
callq 0x39a96
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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 const&)::'lambda'(pybind11::detail::value_and_holder&, int, int, int), pybind11::detail::is_new_style_constructor, pybind11::arg, pybind11::arg, pybind11::arg>(char const*, pybind11::class_<sdf_tools::int3>&&, pybind11::arg const&, pybind11::arg const&, pybind11::arg const&)
|
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)
callq 0xb1e0
testq %rax, %rax
je 0x39b2e
movq %rax, (%rsp)
jmp 0x39b3a
callq 0xb780
movq %r15, (%rsp)
incq (%r15)
movq 0x70(%rsp), %rax
movq (%rsp), %rcx
leaq 0x30(%rsp), %r8
movq %rcx, (%r8)
subq $0x8, %rsp
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rdx
leaq 0x28(%rsp), %rcx
movq %rbp, %rsi
movq %r13, %r9
pushq %rax
pushq %r12
pushq 0x30(%rsp)
callq 0x39bde
addq $0x20, %rsp
movq %rsp, %rdi
callq 0x149d2
leaq 0x10(%rsp), %rdi
callq 0x149d2
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x234d7
leaq 0x8(%rsp), %rdi
callq 0x149d2
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x39bd1
movq %rax, %rbx
movq %rsp, %rdi
callq 0x149d2
jmp 0x39bcc
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x149d2
movq %rbx, %rdi
callq 0xbe20
|
/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])...})
if (!r)
return false;
#endif
return true;
}
|
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(%r14), %rcx
movq 0x10(%rax), %rsi
movl (%rcx), %edx
andl $0x4, %edx
shrl $0x2, %edx
callq 0x24d68
testb %al, %al
je 0x39dcb
movq 0x8(%r14), %rax
movq 0x20(%r14), %rcx
movq 0x18(%rax), %rsi
movl (%rcx), %edx
andl $0x8, %edx
shrl $0x3, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x24d68
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/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_method const&)
|
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 in case of an exception.
auto unique_rec = make_function_record();
auto rec = unique_rec.get();
/* Store the capture object directly in the function record if there is enough space */
if (sizeof(capture) <= sizeof(rec->data)) {
/* Without these pragmas, GCC warns that there might not be
enough space to use the placement new operator. However, the
'if' statement above ensures that this is the case. */
#if defined(__GNUG__) && __GNUC__ >= 6 && !defined(__clang__) && !defined(__INTEL_COMPILER)
# pragma GCC diagnostic push
# pragma GCC diagnostic ignored "-Wplacement-new"
#endif
new ((capture *) &rec->data) capture { std::forward<Func>(f) };
#if defined(__GNUG__) && __GNUC__ >= 6 && !defined(__clang__) && !defined(__INTEL_COMPILER)
# pragma GCC diagnostic pop
#endif
if (!std::is_trivially_destructible<Func>::value)
rec->free_data = [](function_record *r) { ((capture *) &r->data)->~capture(); };
} else {
rec->data[0] = new capture { std::forward<Func>(f) };
rec->free_data = [](function_record *r) { delete ((capture *) r->data[0]); };
}
/* Type casters for the function arguments and return value */
using cast_in = argument_loader<Args...>;
using cast_out = make_caster<
conditional_t<std::is_void<Return>::value, void_type, Return>
>;
static_assert(expected_num_args<Extra...>(sizeof...(Args), cast_in::has_args, cast_in::has_kwargs),
"The number of argument annotations does not match the number of function arguments");
/* Dispatch code which converts function arguments and performs the actual function call */
rec->impl = [](function_call &call) -> handle {
cast_in args_converter;
/* Try to cast the function arguments into the C++ domain */
if (!args_converter.load_args(call))
return PYBIND11_TRY_NEXT_OVERLOAD;
/* Invoke call policy pre-call hook */
process_attributes<Extra...>::precall(call);
/* Get a pointer to the capture object */
auto data = (sizeof(capture) <= sizeof(call.func.data)
? &call.func.data : call.func.data[0]);
auto *cap = const_cast<capture *>(reinterpret_cast<const capture *>(data));
/* Override policy for rvalues -- usually to enforce rvp::move on an rvalue */
return_value_policy policy = return_value_policy_override<Return>::policy(call.func.policy);
/* Function scope guard -- defaults to the compile-to-nothing `void_type` */
using Guard = extract_guard_t<Extra...>;
/* Perform the function call */
handle result = cast_out::cast(
std::move(args_converter).template call<Return, Guard>(cap->f), policy, call.parent);
/* Invoke call policy post-call hook */
process_attributes<Extra...>::postcall(call, result);
return result;
};
/* Process any user-provided function attributes */
process_attributes<Extra...>::init(extra..., rec);
{
constexpr bool has_kw_only_args = any_of<std::is_same<kw_only, Extra>...>::value,
has_pos_only_args = any_of<std::is_same<pos_only, Extra>...>::value,
has_args = any_of<std::is_same<args, Args>...>::value,
has_arg_annotations = any_of<is_keyword<Extra>...>::value;
static_assert(has_arg_annotations || !has_kw_only_args, "py::kw_only requires the use of argument annotations");
static_assert(has_arg_annotations || !has_pos_only_args, "py::pos_only requires the use of argument annotations (for docstrings and aligning the annotations to the argument)");
static_assert(!(has_args && has_kw_only_args), "py::kw_only cannot be combined with a py::args argument");
}
/* Generate a readable signature describing the function's arguments and return value types */
static constexpr auto signature = _("(") + cast_in::arg_names + _(") -> ") + cast_out::name;
PYBIND11_DESCR_CONSTEXPR auto types = decltype(signature)::types();
/* Register the function with Python from generic (non-templated) code */
// Pass on the ownership over the `unique_rec` to `initialize_generic`. `rec` stays valid.
initialize_generic(std::move(unique_rec), signature.text, types.data(), sizeof...(Args));
if (cast_in::has_args) rec->has_args = true;
if (cast_in::has_kwargs) rec->has_kwargs = true;
/* Stash some additional information used by an important optimization in 'functional.h' */
using FunctionType = Return (*)(Args...);
constexpr bool is_function_ptr =
std::is_convertible<Func, FunctionType>::value &&
sizeof(capture) == sizeof(void *);
if (is_function_ptr) {
rec->is_stateless = true;
rec->data[1] = const_cast<void *>(reinterpret_cast<const void *>(&typeid(FunctionType)));
}
}
|
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), %rcx
movq %rcx, 0x70(%rax)
leaq 0x56f5(%rip), %rdx # 0x3f57a
leaq 0x18dcc(%rip), %rcx # 0x52c58
movl $0x1, %r8d
movq %r15, %rdi
movq %r12, %rsi
callq 0x1824e
movq %rsp, %rdi
callq 0x19c8a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x19c8a
movq %rbx, %rdi
callq 0xbe20
|
/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)
jne 0x3a168
movq 0x18(%rbx), %rax
jmp 0x3a16a
xorl %r14d, %r14d
jmp 0x3a181
xorl %eax, %eax
movq %rax, (%rsp)
testq %rax, %rax
je 0x3a176
incq (%rax)
movq %rsp, %rdi
callq 0x1c89e
movq %rax, %r14
testq %rbx, %rbx
je 0x3a18e
movq %rsp, %rdi
callq 0x149d2
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x149d2
movq %rbx, %rdi
callq 0xbe20
|
/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 0x149d2
movq %rbx, %rdi
callq 0x149d2
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0x149d2
jmp 0x3a26b
movq %rax, %r14
movq %rbx, %rdi
callq 0x149d2
movq %r14, %rdi
callq 0xbe20
nop
|
/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)...).call(derived().ptr());
}
|
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), %rdx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x15392
leaq 0x8(%rsp), %rdi
callq 0x149d2
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x15dc(%rip), %rdi # 0x3b8ca
callq 0x14b04
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x149d2
movq %rbx, %rdi
callq 0xbe20
|
/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[i]) {
#if defined(NDEBUG)
throw cast_error("make_tuple(): unable to convert arguments to Python object (compile in debug mode for details)");
#else
std::array<std::string, size> argtypes { {type_id<Args>()...} };
throw cast_error("make_tuple(): unable to convert argument of type '" +
argtypes[i] + "' to Python object");
#endif
}
}
tuple result(size);
int counter = 0;
for (auto &arg_value : args)
PyTuple_SET_ITEM(result.ptr(), counter++, arg_value.release().ptr());
return result;
}
|
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)
movslq (%r15), %rdi
callq 0xb0b0
movq %rsp, %rcx
movq %rax, 0x10(%rcx)
xorl %r12d, %r12d
cmpq $0x0, (%rcx)
je 0x3a3dd
addq $-0x20, %r12
addq $0x8, %rcx
cmpq $-0x60, %r12
jne 0x3a35d
movl $0x3, %esi
movq %rbx, %rdi
callq 0x1563c
xorl %eax, %eax
movq (%rsp,%rax), %rcx
movq $0x0, (%rsp,%rax)
movq (%rbx), %rdx
movq 0x8(%rdx), %rsi
testb $0x4, 0xab(%rsi)
je 0x3a462
movq %rcx, 0x18(%rdx,%rax)
addq $0x8, %rax
cmpq $0x18, %rax
jne 0x3a380
movl $0x10, %r14d
leaq (%rsp,%r14), %rdi
callq 0x149d2
addq $-0x8, %r14
cmpq $-0x8, %r14
jne 0x3a3b5
movq %rbx, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x58(%rsp), %r14
movq %r14, %r15
movq %r14, %rdi
callq 0x30c21
leaq 0x78(%rsp), %r15
movq %r15, %rdi
callq 0x30c21
leaq 0x98(%rsp), %r15
movq %r15, %rdi
callq 0x30c21
movl $0x10, %edi
callq 0xb310
movq %rax, %r14
leaq 0x58(%rsp), %rdx
subq %r12, %rdx
leaq 0x14e3(%rip), %rsi # 0x3b909
leaq 0x38(%rsp), %rdi
callq 0xb700
leaq 0x1505(%rip), %rsi # 0x3b93c
leaq 0x38(%rsp), %rdi
callq 0xbf80
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x3a481
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x3a48e
leaq 0x14e6(%rip), %rdi # 0x3b94f
leaq 0x14fb(%rip), %rsi # 0x3b96b
leaq 0x4e50(%rip), %rcx # 0x3f2c7
movl $0x3d9, %edx # imm = 0x3D9
callq 0xb470
movq %rdx, 0x18(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x28(%rsp)
movq 0x8(%rax), %rdx
leaq 0x18(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %r14, %rdi
callq 0xb980
leaq 0x17d6c(%rip), %rax # 0x52228
movq %rax, (%r14)
xorl %ebp, %ebp
leaq 0x17cf8(%rip), %rsi # 0x521c0
movq 0x18a69(%rip), %rdx # 0x52f38
movq %r14, %rdi
callq 0xbdc0
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x3a4f9
movq 0x28(%rsp), %rsi
incq %rsi
callq 0xb800
jmp 0x3a4f9
movq %rax, %rbx
movb $0x1, %bpl
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3a521
movq 0x48(%rsp), %rsi
incq %rsi
callq 0xb800
jmp 0x3a521
movq %rax, %rbx
jmp 0x3a594
movq %rax, %rbx
movb $0x1, %bpl
testb %bpl, %bpl
je 0x3a52e
movq %r14, %rdi
callq 0xb510
leaq 0xa8(%rsp), %r14
xorl %r15d, %r15d
movq 0x98(%rsp,%r15), %rdi
leaq (%r14,%r15), %rax
cmpq %rdi, %rax
je 0x3a555
movq (%rax), %rsi
incq %rsi
callq 0xb800
addq $-0x20, %r15
cmpq $-0x60, %r15
jne 0x3a539
jmp 0x3a594
movq %rax, %rbx
cmpq %r14, %r13
je 0x3a5ad
movq %rsp, %r15
addq $-0x8, %r14
movq %r14, %rdi
callq 0x149d2
cmpq %r15, %r14
jne 0x3a56c
jmp 0x3a5ad
movq %rax, %rbx
cmpq %r15, %r14
je 0x3a594
leaq 0x58(%rsp), %rsi
movq %r15, %rdi
callq 0xcd4b
movl $0x10, %r14d
leaq (%rsp,%r14), %rdi
callq 0x149d2
addq $-0x8, %r14
cmpq $-0x8, %r14
jne 0x3a59a
movq %rbx, %rdi
callq 0xbe20
nop
|
/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>(
32, 32, 32, "data/Bucky.raw", SDT_UINT8);
// Next, combine this data with a basis function in a si_function
si_function<
cartesian_cubic<float>, // specify the lattice (and its data type)
tp_linear, // specify the basis function
3> bucky(cc); // specify the dimension, and call this si_function bucky (fed with the cc lattice)
// by default, an si_fuction has no scaling set, it'll exend to the maximum
// boundary of the lattice, 32 x 32 x 32 in this case
vector scale(3);
// Scaling is in the form f(s*x, s*y, s*z), so we specify 32-1,32-1,32-1 as scale
scale << 31.,31.,31.;
bucky.set_scale(scale);
// Now we can just use the marching cubes algorithm to march over the data
vector origin(3), extent(3);
// Setup the volume over which MC will run
origin << 0,0,0;
extent << 1,1,1;
mc.march_function(
&bucky,
127.0,
0.05,
origin,
extent,
true
);
// Write the output as a ply file
mc.write_surface("bucky.ply");
}
|
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), %rdx
leaq 0x23b73(%rip), %rsi # 0x5c090
leaq -0x42a8(%rbp), %rdi
callq 0x38230
jmp 0x3852b
movl $0x0, -0x42c0(%rbp)
movb $0x0, -0x42c1(%rbp)
leaq -0x427c(%rbp), %rdi
leaq -0x4280(%rbp), %rsi
leaq -0x4284(%rbp), %rdx
leaq -0x42a8(%rbp), %rcx
leaq -0x42c0(%rbp), %r8
leaq -0x42c1(%rbp), %r9
callq 0x38c40
movq %rax, -0x4480(%rbp)
jmp 0x38574
leaq -0x42a8(%rbp), %rdi
callq 0x38100
leaq -0x42a9(%rbp), %rdi
callq 0x381b0
movq -0x4480(%rbp), %rax
movq %rax, -0x4278(%rbp)
movq -0x4278(%rbp), %rsi
leaq -0x4328(%rbp), %rdi
callq 0x395a0
jmp 0x385af
movl $0x3, -0x433c(%rbp)
leaq -0x4338(%rbp), %rdi
leaq -0x433c(%rbp), %rsi
callq 0x395d0
jmp 0x385ce
movabsq $0x403f000000000000, %rax # imm = 0x403F000000000000
movq %rax, -0x4368(%rbp)
leaq -0x4360(%rbp), %rdi
leaq -0x4338(%rbp), %rsi
leaq -0x4368(%rbp), %rdx
callq 0x39630
jmp 0x385fb
movabsq $0x403f000000000000, %rax # imm = 0x403F000000000000
movq %rax, -0x4370(%rbp)
leaq -0x4360(%rbp), %rdi
leaq -0x4370(%rbp), %rsi
callq 0x39670
movq %rax, -0x4488(%rbp)
jmp 0x38628
movq -0x4488(%rbp), %rdi
movabsq $0x403f000000000000, %rax # imm = 0x403F000000000000
movq %rax, -0x4378(%rbp)
leaq -0x4378(%rbp), %rsi
callq 0x39670
jmp 0x3864e
leaq -0x4360(%rbp), %rdi
callq 0x397e0
leaq -0x4328(%rbp), %rdi
leaq -0x4338(%rbp), %rsi
callq 0x39810
jmp 0x3866f
movl $0x3, -0x438c(%rbp)
leaq -0x4388(%rbp), %rdi
leaq -0x438c(%rbp), %rsi
callq 0x395d0
jmp 0x3868e
movl $0x3, -0x43a4(%rbp)
leaq -0x43a0(%rbp), %rdi
leaq -0x43a4(%rbp), %rsi
callq 0x395d0
jmp 0x386ad
movq $0x0, -0x43d0(%rbp)
leaq -0x43c8(%rbp), %rdi
leaq -0x4388(%rbp), %rsi
leaq -0x43d0(%rbp), %rdx
callq 0x39630
jmp 0x386d4
movq $0x0, -0x43d8(%rbp)
leaq -0x43c8(%rbp), %rdi
leaq -0x43d8(%rbp), %rsi
callq 0x39670
movq %rax, -0x4490(%rbp)
jmp 0x386fb
movq -0x4490(%rbp), %rdi
movq $0x0, -0x43e0(%rbp)
leaq -0x43e0(%rbp), %rsi
callq 0x39670
jmp 0x3871b
leaq -0x43c8(%rbp), %rdi
callq 0x397e0
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, -0x4408(%rbp)
leaq -0x4400(%rbp), %rdi
leaq -0x43a0(%rbp), %rsi
leaq -0x4408(%rbp), %rdx
callq 0x39630
jmp 0x38754
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, -0x4410(%rbp)
leaq -0x4400(%rbp), %rdi
leaq -0x4410(%rbp), %rsi
callq 0x39670
movq %rax, -0x4498(%rbp)
jmp 0x38781
movq -0x4498(%rbp), %rdi
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, -0x4418(%rbp)
leaq -0x4418(%rbp), %rsi
callq 0x39670
jmp 0x387a7
leaq -0x4400(%rbp), %rdi
callq 0x397e0
movabsq $0x405fc00000000000, %rax # imm = 0x405FC00000000000
movq %rax, -0x4420(%rbp)
movabsq $0x3fa999999999999a, %rax # imm = 0x3FA999999999999A
movq %rax, -0x4428(%rbp)
leaq -0x4438(%rbp), %rdi
leaq -0x4388(%rbp), %rsi
callq 0x3c9f0
jmp 0x387ea
leaq -0x4448(%rbp), %rdi
leaq -0x43a0(%rbp), %rsi
callq 0x3c9f0
jmp 0x387ff
movq %rsp, %rax
movq $0x0, 0x18(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x8(%rax)
movl $0x1, (%rax)
leaq -0x4270(%rbp), %rdi
leaq -0x4328(%rbp), %rsi
leaq -0x4420(%rbp), %rdx
leaq -0x4428(%rbp), %rcx
leaq -0x4438(%rbp), %r8
leaq -0x4448(%rbp), %r9
callq 0x39860
jmp 0x38851
leaq -0x4448(%rbp), %rdi
callq 0x3ca20
leaq -0x4438(%rbp), %rdi
callq 0x3ca20
leaq -0x4469(%rbp), %rdi
movq %rdi, -0x44a0(%rbp)
callq 0x382f0
movq -0x44a0(%rbp), %rdx
leaq 0x23815(%rip), %rsi # 0x5c09f
leaq -0x4468(%rbp), %rdi
callq 0x38230
jmp 0x38898
leaq -0x4270(%rbp), %rdi
leaq -0x4468(%rbp), %rsi
callq 0x3ca40
jmp 0x388ad
leaq -0x4468(%rbp), %rdi
callq 0x38100
leaq -0x4469(%rbp), %rdi
callq 0x381b0
leaq -0x43a0(%rbp), %rdi
callq 0x3ca20
leaq -0x4388(%rbp), %rdi
callq 0x3ca20
leaq -0x4338(%rbp), %rdi
callq 0x3ca20
leaq -0x4328(%rbp), %rdi
callq 0x3ca70
leaq -0x4270(%rbp), %rdi
callq 0x3cac0
xorl %eax, %eax
addq $0x44c0, %rsp # imm = 0x44C0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x42b8(%rbp)
movl %eax, -0x42bc(%rbp)
jmp 0x3893e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x42b8(%rbp)
movl %eax, -0x42bc(%rbp)
leaq -0x42a8(%rbp), %rdi
callq 0x38100
leaq -0x42a9(%rbp), %rdi
callq 0x381b0
jmp 0x38ad6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x42b8(%rbp)
movl %eax, -0x42bc(%rbp)
jmp 0x38ad6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x42b8(%rbp)
movl %eax, -0x42bc(%rbp)
jmp 0x38aca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x42b8(%rbp)
movl %eax, -0x42bc(%rbp)
jmp 0x38abe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x42b8(%rbp)
movl %eax, -0x42bc(%rbp)
leaq -0x4360(%rbp), %rdi
callq 0x397e0
jmp 0x38abe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x42b8(%rbp)
movl %eax, -0x42bc(%rbp)
jmp 0x38ab2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x42b8(%rbp)
movl %eax, -0x42bc(%rbp)
jmp 0x38aa6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x42b8(%rbp)
movl %eax, -0x42bc(%rbp)
leaq -0x43c8(%rbp), %rdi
callq 0x397e0
jmp 0x38aa6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x42b8(%rbp)
movl %eax, -0x42bc(%rbp)
leaq -0x4400(%rbp), %rdi
callq 0x397e0
jmp 0x38aa6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x42b8(%rbp)
movl %eax, -0x42bc(%rbp)
jmp 0x38a5a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x42b8(%rbp)
movl %eax, -0x42bc(%rbp)
leaq -0x4448(%rbp), %rdi
callq 0x3ca20
leaq -0x4438(%rbp), %rdi
callq 0x3ca20
jmp 0x38aa6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x42b8(%rbp)
movl %eax, -0x42bc(%rbp)
jmp 0x38a9a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x42b8(%rbp)
movl %eax, -0x42bc(%rbp)
leaq -0x4468(%rbp), %rdi
callq 0x38100
leaq -0x4469(%rbp), %rdi
callq 0x381b0
leaq -0x43a0(%rbp), %rdi
callq 0x3ca20
leaq -0x4388(%rbp), %rdi
callq 0x3ca20
leaq -0x4338(%rbp), %rdi
callq 0x3ca20
leaq -0x4328(%rbp), %rdi
callq 0x3ca70
leaq -0x4270(%rbp), %rdi
callq 0x3cac0
movq -0x42b8(%rbp), %rdi
callq 0x382e0
nop
|
/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
#define INDEX(i,j,k) i + rx * ( j + ry*k )
// Open the file
ifstream fp(file.c_str(), ios::in | ios::binary | ios::ate);
streampos size;
if (!fp.good() || !fp.is_open()) return nullptr;
size = fp.tellg();
fp.seekg(0, ios::beg);
// Allocate and Read
char *buffer = new char[size];
fp.read(buffer, size);
// Allocate the array
cartesian_cubic<O> *lattice = new cartesian_cubic<O>(rx-1, ry-1, rz-1);
switch (type) {
case SDT_UINT8:
{
unsigned char *l_buff = (unsigned char *)buffer;
#pragma omp parallel for
for(int i = 0; i < rx; i++)
for(int j = 0; j < ry; j++)
for(int k = 0; k < rz; k++)
(*lattice)(i,j,k) = (O)l_buff[INDEX(i,j,k)];
break;
}
case SDT_UINT16:
{
unsigned short *l_buff = (unsigned short *)buffer;
#pragma omp parallel for
for(int i = 0; i < rx; i++)
for(int j = 0; j < ry; j++)
for(int k = 0; k < rz; k++) {
uint16_t data = l_buff[INDEX(i,j,k)];
(*lattice)(i,j,k) = (O)(swap_endian ? SWAP_16(data) : data);
}
break;
}
case SDT_UINT32:
{
unsigned int *l_buff = (unsigned int *)buffer;
#pragma omp parallel for
for(int i = 0; i < rx; i++)
for(int j = 0; j < ry; j++)
for(int k = 0; k < rz; k++) {
uint32_t data = l_buff[INDEX(i,j,k)];
(*lattice)(i,j,k) = (O)(swap_endian ? SWAP_32(data) : data);
}
break;
}
case SDT_FLOAT:
{
float *l_buff = (float *)buffer;
#pragma omp parallel for
for(int i = 0; i < rx; i++)
for(int j = 0; j < ry; j++)
for(int k = 0; k < rz; k++)
(*lattice)(i,j,k) = (O)l_buff[INDEX(i,j,k)];
break;
}
case SDT_DOUBLE:
{
double *l_buff = (double *)buffer;
#pragma omp parallel for
for(int i = 0; i < rx; i++)
for(int j = 0; j < ry; j++)
for(int k = 0; k < rz; k++)
(*lattice)(i,j,k) = (O)l_buff[INDEX(i,j,k)];
break;
}
default:
throw "Unknown datatype passed to sisl::io::read_raw_file()!";
}
delete[] buffer;
#undef INDEX
return lattice;
}
|
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 %eax, %edi
movl $0x2, %esi
callq 0x46fc0
movq -0x300(%rbp), %rsi
movl %eax, %edx
leaq -0x240(%rbp), %rdi
callq 0x38300
leaq -0x250(%rbp), %rdi
callq 0x47950
jmp 0x38cb1
movq -0x240(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x240(%rbp,%rax), %rdi
callq 0x382b0
movb %al, -0x301(%rbp)
jmp 0x38cd1
movb -0x301(%rbp), %al
testb $0x1, %al
jne 0x38cdd
jmp 0x38cfd
leaq -0x240(%rbp), %rdi
callq 0x38280
movb %al, -0x302(%rbp)
jmp 0x38cf1
movb -0x302(%rbp), %al
testb $0x1, %al
jne 0x38d2b
jmp 0x38cfd
movq $0x0, -0x8(%rbp)
movl $0x1, -0x260(%rbp)
jmp 0x39562
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x258(%rbp)
movl %eax, -0x25c(%rbp)
jmp 0x3957b
leaq -0x240(%rbp), %rdi
callq 0x382d0
movq %rdx, -0x318(%rbp)
movq %rax, -0x310(%rbp)
jmp 0x38d47
movq -0x318(%rbp), %rax
movq -0x310(%rbp), %rcx
movq %rcx, -0x270(%rbp)
movq %rax, -0x268(%rbp)
movups -0x270(%rbp), %xmm0
movaps %xmm0, -0x250(%rbp)
xorl %edx, %edx
movl %edx, %esi
leaq -0x240(%rbp), %rdi
callq 0x38220
jmp 0x38d83
leaq -0x250(%rbp), %rdi
callq 0x47980
movq %rax, -0x320(%rbp)
jmp 0x38d98
movq -0x320(%rbp), %rdi
testq %rdi, %rdi
movq $-0x1, %rax
cmovsq %rax, %rdi
callq 0x38030
movq %rax, -0x328(%rbp)
jmp 0x38dbb
movq -0x328(%rbp), %rax
movq %rax, -0x278(%rbp)
movq -0x278(%rbp), %rax
movq %rax, -0x338(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x47980
movq %rax, -0x330(%rbp)
jmp 0x38dec
movq -0x330(%rbp), %rdx
movq -0x338(%rbp), %rsi
leaq -0x240(%rbp), %rdi
callq 0x381e0
jmp 0x38e08
movl $0x68, %edi
callq 0x38180
movq %rax, -0x340(%rbp)
jmp 0x38e1b
movq -0x340(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
decl %esi
movq -0x18(%rbp), %rax
movl (%rax), %edx
decl %edx
movq -0x20(%rbp), %rax
movl (%rax), %ecx
decl %ecx
callq 0x479a0
jmp 0x38e41
movq -0x340(%rbp), %rax
movq %rax, -0x280(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x348(%rbp)
subq $0x4, %rax
ja 0x39504
movq -0x348(%rbp), %rax
leaq 0x231bc(%rip), %rcx # 0x5c030
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x340(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x258(%rbp)
movl %eax, -0x25c(%rbp)
callq 0x38160
jmp 0x3957b
movq -0x278(%rbp), %rax
movq %rax, -0x288(%rbp)
movl $0x0, -0x28c(%rbp)
movl -0x28c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x38fbc
movl $0x0, -0x290(%rbp)
movl -0x290(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x38fa6
movl $0x0, -0x294(%rbp)
movl -0x294(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x38f90
movq -0x288(%rbp), %rax
movl -0x28c(%rbp), %esi
movq -0x10(%rbp), %rcx
movl (%rcx), %r8d
movl -0x290(%rbp), %edx
movq -0x18(%rbp), %rcx
movl (%rcx), %r9d
movl -0x294(%rbp), %ecx
imull %ecx, %r9d
movl %edx, %edi
addl %r9d, %edi
imull %edi, %r8d
movl %esi, %edi
addl %r8d, %edi
movslq %edi, %rdi
movzbl (%rax,%rdi), %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, -0x354(%rbp)
movq -0x280(%rbp), %rdi
movq (%rdi), %rax
movq (%rax), %r8
xorl %eax, %eax
callq *%r8
movq %rax, -0x350(%rbp)
jmp 0x38f69
movq -0x350(%rbp), %rax
movss -0x354(%rbp), %xmm0
movss %xmm0, (%rax)
movl -0x294(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x294(%rbp)
jmp 0x38ef0
jmp 0x38f92
movl -0x290(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x290(%rbp)
jmp 0x38ed4
jmp 0x38fa8
movl -0x28c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28c(%rbp)
jmp 0x38eb8
jmp 0x3952d
movq -0x278(%rbp), %rax
movq %rax, -0x2a0(%rbp)
movl $0x0, -0x2a4(%rbp)
movl -0x2a4(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x3912f
movl $0x0, -0x2a8(%rbp)
movl -0x2a8(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x39119
movl $0x0, -0x2ac(%rbp)
movl -0x2ac(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x39103
movq -0x2a0(%rbp), %rax
movl -0x2a4(%rbp), %ecx
movq -0x10(%rbp), %rdx
movl (%rdx), %edx
movl -0x2a8(%rbp), %esi
movq -0x18(%rbp), %rdi
movl (%rdi), %edi
imull -0x2ac(%rbp), %edi
addl %edi, %esi
imull %esi, %edx
addl %edx, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %ax
movw %ax, -0x2ae(%rbp)
movq -0x38(%rbp), %rax
testb $0x1, (%rax)
je 0x39090
movzwl -0x2ae(%rbp), %eax
andl $0xff00, %eax # imm = 0xFF00
sarl $0x8, %eax
movzwl -0x2ae(%rbp), %ecx
andl $0xff, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movl %eax, -0x358(%rbp)
jmp 0x3909d
movzwl -0x2ae(%rbp), %eax
movl %eax, -0x358(%rbp)
movl -0x358(%rbp), %eax
cvtsi2ss %eax, %xmm0
movss %xmm0, -0x364(%rbp)
movq -0x280(%rbp), %rdi
movl -0x2a4(%rbp), %esi
movl -0x2a8(%rbp), %edx
movl -0x2ac(%rbp), %ecx
movq (%rdi), %rax
movq (%rax), %r8
xorl %eax, %eax
callq *%r8
movq %rax, -0x360(%rbp)
jmp 0x390dc
movq -0x360(%rbp), %rax
movss -0x364(%rbp), %xmm0
movss %xmm0, (%rax)
movl -0x2ac(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2ac(%rbp)
jmp 0x39011
jmp 0x39105
movl -0x2a8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2a8(%rbp)
jmp 0x38ff5
jmp 0x3911b
movl -0x2a4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2a4(%rbp)
jmp 0x38fd9
jmp 0x3952d
movq -0x278(%rbp), %rax
movq %rax, -0x2b8(%rbp)
movl $0x0, -0x2bc(%rbp)
movl -0x2bc(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x392c2
movl $0x0, -0x2c0(%rbp)
movl -0x2c0(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x392ac
movl $0x0, -0x2c4(%rbp)
movl -0x2c4(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x39296
movq -0x2b8(%rbp), %rax
movl -0x2bc(%rbp), %ecx
movq -0x10(%rbp), %rdx
movl (%rdx), %edx
movl -0x2c0(%rbp), %esi
movq -0x18(%rbp), %rdi
movl (%rdi), %edi
imull -0x2c4(%rbp), %edi
addl %edi, %esi
imull %esi, %edx
addl %edx, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x2c8(%rbp)
movq -0x38(%rbp), %rax
testb $0x1, (%rax)
je 0x39221
movl -0x2c8(%rbp), %eax
shrl $0x18, %eax
andl $0xff, %eax
movl -0x2c8(%rbp), %ecx
shll $0x8, %ecx
andl $0xff0000, %ecx # imm = 0xFF0000
orl %ecx, %eax
movl -0x2c8(%rbp), %ecx
shrl $0x8, %ecx
andl $0xff00, %ecx # imm = 0xFF00
orl %ecx, %eax
movl -0x2c8(%rbp), %ecx
shll $0x18, %ecx
andl $0xff000000, %ecx # imm = 0xFF000000
orl %ecx, %eax
movl %eax, -0x368(%rbp)
jmp 0x3922d
movl -0x2c8(%rbp), %eax
movl %eax, -0x368(%rbp)
movl -0x368(%rbp), %eax
movl %eax, %eax
cvtsi2ss %rax, %xmm0
movss %xmm0, -0x374(%rbp)
movq -0x280(%rbp), %rdi
movl -0x2bc(%rbp), %esi
movl -0x2c0(%rbp), %edx
movl -0x2c4(%rbp), %ecx
movq (%rdi), %rax
movq (%rax), %r8
xorl %eax, %eax
callq *%r8
movq %rax, -0x370(%rbp)
jmp 0x3926f
movq -0x370(%rbp), %rax
movss -0x374(%rbp), %xmm0
movss %xmm0, (%rax)
movl -0x2c4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c4(%rbp)
jmp 0x39184
jmp 0x39298
movl -0x2c0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c0(%rbp)
jmp 0x39168
jmp 0x392ae
movl -0x2bc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2bc(%rbp)
jmp 0x3914c
jmp 0x3952d
movq -0x278(%rbp), %rax
movq %rax, -0x2d0(%rbp)
movl $0x0, -0x2d4(%rbp)
movl -0x2d4(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x393e0
movl $0x0, -0x2d8(%rbp)
movl -0x2d8(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x393ca
movl $0x0, -0x2dc(%rbp)
movl -0x2dc(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x393b4
movq -0x2d0(%rbp), %rax
movl -0x2d4(%rbp), %esi
movq -0x10(%rbp), %rcx
movl (%rcx), %r8d
movl -0x2d8(%rbp), %edx
movq -0x18(%rbp), %rcx
movl (%rcx), %r9d
movl -0x2dc(%rbp), %ecx
imull %ecx, %r9d
movl %edx, %edi
addl %r9d, %edi
imull %edi, %r8d
movl %esi, %edi
addl %r8d, %edi
movslq %edi, %rdi
movss (%rax,%rdi,4), %xmm0
movss %xmm0, -0x384(%rbp)
movq -0x280(%rbp), %rdi
movq (%rdi), %rax
movq (%rax), %r8
xorl %eax, %eax
callq *%r8
movq %rax, -0x380(%rbp)
jmp 0x3938d
movq -0x380(%rbp), %rax
movss -0x384(%rbp), %xmm0
movss %xmm0, (%rax)
movl -0x2dc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2dc(%rbp)
jmp 0x39317
jmp 0x393b6
movl -0x2d8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2d8(%rbp)
jmp 0x392fb
jmp 0x393cc
movl -0x2d4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2d4(%rbp)
jmp 0x392df
jmp 0x3952d
movq -0x278(%rbp), %rax
movq %rax, -0x2e8(%rbp)
movl $0x0, -0x2ec(%rbp)
movl -0x2ec(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x39502
movl $0x0, -0x2f0(%rbp)
movl -0x2f0(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x394ec
movl $0x0, -0x2f4(%rbp)
movl -0x2f4(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x394d6
movq -0x2e8(%rbp), %rax
movl -0x2ec(%rbp), %esi
movq -0x10(%rbp), %rcx
movl (%rcx), %r8d
movl -0x2f0(%rbp), %edx
movq -0x18(%rbp), %rcx
movl (%rcx), %r9d
movl -0x2f4(%rbp), %ecx
imull %ecx, %r9d
movl %edx, %edi
addl %r9d, %edi
imull %edi, %r8d
movl %esi, %edi
addl %r8d, %edi
movslq %edi, %rdi
movsd (%rax,%rdi,8), %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x394(%rbp)
movq -0x280(%rbp), %rdi
movq (%rdi), %rax
movq (%rax), %r8
xorl %eax, %eax
callq *%r8
movq %rax, -0x390(%rbp)
jmp 0x394af
movq -0x390(%rbp), %rax
movss -0x394(%rbp), %xmm0
movss %xmm0, (%rax)
movl -0x2f4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2f4(%rbp)
jmp 0x39435
jmp 0x394d8
movl -0x2f0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2f0(%rbp)
jmp 0x39419
jmp 0x394ee
movl -0x2ec(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2ec(%rbp)
jmp 0x393fd
jmp 0x3952d
movl $0x8, %edi
callq 0x380d0
movq %rax, %rdi
leaq 0x25408(%rip), %rax # 0x5e920
movq %rax, (%rdi)
movq 0x3ea8e(%rip), %rsi # 0x77fb0
xorl %eax, %eax
movl %eax, %edx
callq 0x382c0
jmp 0x39593
movq -0x278(%rbp), %rax
movq %rax, -0x3a0(%rbp)
cmpq $0x0, %rax
je 0x3954d
movq -0x3a0(%rbp), %rdi
callq 0x381f0
movq -0x280(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x260(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x38060
movq -0x8(%rbp), %rax
addq $0x3a0, %rsp # imm = 0x3A0
popq %rbp
retq
leaq -0x240(%rbp), %rdi
callq 0x38060
movq -0x258(%rbp), %rdi
callq 0x382e0
nopw %cs:(%rax,%rax)
nopl (%rax)
|
/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 &isoValue,
const double &ss,
sisl::function *f,
bool approximate_gradient = false) {
#pragma omp critical(cache_vertex)
{
if(vMap->find(vIndex) == vMap->end()) {
double interpolate = (isoValue -iVal1)/(iVal2-iVal1);
if(fabs(iVal2-iVal1) < 0.0001)
interpolate = 0.5;
sisl::vector vnew = v1.p*(1.-interpolate) + v2.p*(interpolate);
sisl::vector na(3);// = f->grad(vnew);
vMap->insert(
{
vIndex,
sisl::vertex3(vnew, na)
});
}
}
}
|
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 $0x1, %al
movb %al, -0x31(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3edc0
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3edf0
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3ed90
testb $0x1, %al
jne 0x3ceaf
jmp 0x3d0e3
movq 0x18(%rbp), %rax
movsd (%rax), %xmm0
movq -0x30(%rbp), %rax
subsd (%rax), %xmm0
movq 0x10(%rbp), %rax
movsd (%rax), %xmm1
movq -0x30(%rbp), %rax
subsd (%rax), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x50(%rbp)
movq 0x10(%rbp), %rax
movsd (%rax), %xmm1
movq -0x30(%rbp), %rax
subsd (%rax), %xmm1
movaps 0x1f191(%rip), %xmm0 # 0x5c080
pand %xmm0, %xmm1
movsd 0x1f10d(%rip), %xmm0 # 0x5c008
ucomisd %xmm1, %xmm0
jbe 0x3cf0e
movsd 0x1f10f(%rip), %xmm0 # 0x5c018
movsd %xmm0, -0x50(%rbp)
movq -0x20(%rbp), %rsi
movsd -0x50(%rbp), %xmm1
movsd 0x1f101(%rip), %xmm0 # 0x5c020
subsd %xmm1, %xmm0
movsd %xmm0, -0xf0(%rbp)
leaq -0xe8(%rbp), %rdi
movq %rdi, -0x1b0(%rbp)
leaq -0xf0(%rbp), %rdx
callq 0x3ee20
movq -0x28(%rbp), %rsi
leaq -0x118(%rbp), %rdi
movq %rdi, -0x1a8(%rbp)
leaq -0x50(%rbp), %rdx
callq 0x3ee20
movq -0x1b0(%rbp), %rsi
movq -0x1a8(%rbp), %rdx
leaq -0xc0(%rbp), %rdi
movq %rdi, -0x1a0(%rbp)
callq 0x3eed0
movq -0x1a0(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x3ef40
movl $0x3, -0x12c(%rbp)
leaq -0x128(%rbp), %rdi
leaq -0x12c(%rbp), %rsi
callq 0x395d0
jmp 0x3cfb0
movq -0x10(%rbp), %rax
movq %rax, -0x1c0(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x1b8(%rbp)
leaq -0x188(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x128(%rbp), %rdx
callq 0x3efc0
jmp 0x3cfdf
movq -0x1b8(%rbp), %rsi
leaq -0x168(%rbp), %rdi
leaq -0x188(%rbp), %rdx
callq 0x3f020
jmp 0x3cffb
movq -0x1c0(%rbp), %rdi
leaq -0x168(%rbp), %rsi
callq 0x3ef80
movb %dl, -0x1c9(%rbp)
movq %rax, -0x1c8(%rbp)
jmp 0x3d01d
movb -0x1c9(%rbp), %al
movq -0x1c8(%rbp), %rcx
movq %rcx, -0x198(%rbp)
movb %al, -0x190(%rbp)
leaq -0x168(%rbp), %rdi
callq 0x3f060
leaq -0x188(%rbp), %rdi
callq 0x3d280
leaq -0x128(%rbp), %rdi
callq 0x3ca20
leaq -0x60(%rbp), %rdi
callq 0x3ca20
jmp 0x3d0e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x138(%rbp)
movl %eax, -0x13c(%rbp)
jmp 0x3d0d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x138(%rbp)
movl %eax, -0x13c(%rbp)
jmp 0x3d0cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x138(%rbp)
movl %eax, -0x13c(%rbp)
jmp 0x3d0c0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x138(%rbp)
movl %eax, -0x13c(%rbp)
leaq -0x168(%rbp), %rdi
callq 0x3f060
leaq -0x188(%rbp), %rdi
callq 0x3d280
leaq -0x128(%rbp), %rdi
callq 0x3ca20
leaq -0x60(%rbp), %rdi
callq 0x3ca20
jmp 0x3d0ec
addq $0x1d0, %rsp # imm = 0x1D0
popq %rbp
retq
movq -0x138(%rbp), %rdi
callq 0x382e0
nopl (%rax,%rax)
|
/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(%rbp), %rsi
callq 0x395d0
movq -0x98(%rbp), %rdi
addq $0x10, %rdi
movq %rdi, -0x90(%rbp)
movl $0x3, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x395d0
jmp 0x3d170
movq -0xa0(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x68(%rbp), %rdi
callq 0x39630
jmp 0x3d186
movq -0x18(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x39670
movq %rax, -0xa8(%rbp)
jmp 0x3d19c
movq -0xa8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x39670
jmp 0x3d1ae
leaq -0x68(%rbp), %rdi
callq 0x397e0
movq -0xa0(%rbp), %rsi
addq $0x10, %rsi
movq -0x28(%rbp), %rdx
leaq -0x88(%rbp), %rdi
callq 0x39630
jmp 0x3d1d4
movq -0x30(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x39670
movq %rax, -0xb0(%rbp)
jmp 0x3d1ed
movq -0xb0(%rbp), %rdi
movq 0x10(%rbp), %rsi
callq 0x39670
jmp 0x3d1ff
leaq -0x88(%rbp), %rdi
callq 0x397e0
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x3d26b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x3d25f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x397e0
jmp 0x3d25f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x397e0
movq -0x90(%rbp), %rdi
callq 0x3ca20
movq -0x98(%rbp), %rdi
callq 0x3ca20
movq -0x40(%rbp), %rdi
callq 0x382e0
|
/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;
faceMap[vIndex] = plyfile.add_vertex(v);
}
for(auto itr = faces.begin(); itr != faces.end(); ++itr) {
std::tuple<int, int, int> t = *itr;
int i1 = faceMap[std::get<0>(t)];
int i2 = faceMap[std::get<1>(t)];
int i3 = faceMap[std::get<2>(t)];
plyfile.add_triangle(i1,i2,i3);
}
}
|
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 -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x41c60
testb $0x1, %al
jne 0x3d37b
jmp 0x3d433
leaq -0x50(%rbp), %rdi
callq 0x41c90
movq %rax, %rsi
addq $0x8, %rsi
leaq -0x78(%rbp), %rdi
callq 0x41020
jmp 0x3d396
leaq -0x50(%rbp), %rdi
callq 0x41c90
movq -0xc0(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x88(%rbp)
addq $0x8, %rdi
leaq -0x78(%rbp), %rsi
callq 0x41cb0
movl %eax, -0xc4(%rbp)
jmp 0x3d3c3
leaq -0x48(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x41d00
movq %rax, -0xd0(%rbp)
jmp 0x3d3dc
movq -0xd0(%rbp), %rax
movl -0xc4(%rbp), %ecx
movl %ecx, (%rax)
leaq -0x78(%rbp), %rdi
callq 0x3d280
leaq -0x50(%rbp), %rdi
callq 0x41de0
jmp 0x3d358
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x3d567
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x3d280
jmp 0x3d567
movq -0x18(%rbp), %rdi
callq 0x41e10
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rdi
callq 0x41e80
movq %rax, -0x98(%rbp)
leaq -0x90(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x41e40
testb $0x1, %al
jne 0x3d46f
jmp 0x3d555
leaq -0x90(%rbp), %rdi
callq 0x41eb0
movl 0x8(%rax), %ecx
movl %ecx, -0xa0(%rbp)
movq (%rax), %rax
movq %rax, -0xa8(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x41ed0
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
callq 0x41d00
movq %rax, -0xd8(%rbp)
jmp 0x3d4af
movq -0xd8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xac(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x41ef0
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
callq 0x41d00
movq %rax, -0xe0(%rbp)
jmp 0x3d4df
movq -0xe0(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xb0(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x41f10
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
callq 0x41d00
movq %rax, -0xe8(%rbp)
jmp 0x3d50f
movq -0xc0(%rbp), %rdi
movq -0xe8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xb4(%rbp)
addq $0x8, %rdi
movl -0xac(%rbp), %esi
movl -0xb0(%rbp), %edx
movl -0xb4(%rbp), %ecx
callq 0x41f30
jmp 0x3d542
jmp 0x3d544
leaq -0x90(%rbp), %rdi
callq 0x41fa0
jmp 0x3d443
leaq -0x48(%rbp), %rdi
callq 0x41fc0
addq $0xf0, %rsp
popq %rbp
retq
leaq -0x48(%rbp), %rdi
callq 0x41fc0
movq -0x80(%rbp), %rdi
callq 0x382e0
nopl (%rax)
|
/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)
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x47000
movsd (%rax), %xmm0
callq 0x380c0
cvttsd2si %xmm0, %eax
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0x2, %esi
callq 0x47000
movsd (%rax), %xmm0
callq 0x380c0
movq -0x68(%rbp), %rdi
cvttsd2si %xmm0, %eax
movl %eax, -0x24(%rbp)
movb $0x0, -0x25(%rbp)
movl $0x3, -0x2c(%rbp)
leaq -0x2c(%rbp), %rsi
callq 0x49b20
movq -0x68(%rbp), %rsi
leaq -0x50(%rbp), %rdi
leaq -0x1c(%rbp), %rdx
callq 0x49b80
jmp 0x48a26
leaq -0x50(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x49bc0
movq %rax, -0x78(%rbp)
jmp 0x48a39
movq -0x78(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x49bc0
jmp 0x48a48
leaq -0x50(%rbp), %rdi
callq 0x49d30
movb $0x1, -0x25(%rbp)
testb $0x1, -0x25(%rbp)
jne 0x48a8b
jmp 0x48a82
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x48a98
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x49d30
jmp 0x48a98
movq -0x68(%rbp), %rdi
callq 0x49d60
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x49d60
movq -0x58(%rbp), %rdi
callq 0x382e0
nopw (%rax,%rax)
|
/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++) {
lattice_site site(3);
site << i, j, k;
func(site);
}
}
}
}
|
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(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0xc(%rcx), %eax
ja 0x48c71
movl $0x0, -0x20(%rbp)
movq -0x70(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x10(%rcx), %eax
ja 0x48c61
movl $0x3, -0x34(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x78(%rbp)
leaq -0x34(%rbp), %rsi
callq 0x49b20
movq -0x78(%rbp), %rsi
leaq -0x58(%rbp), %rdi
leaq -0x18(%rbp), %rdx
callq 0x49b80
jmp 0x48be2
leaq -0x58(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x49bc0
movq %rax, -0x80(%rbp)
jmp 0x48bf5
movq -0x80(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x49bc0
jmp 0x48c04
leaq -0x58(%rbp), %rdi
callq 0x49d30
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4a220
jmp 0x48c1c
leaq -0x30(%rbp), %rdi
callq 0x49d60
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x48ba7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x48c56
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x49d30
leaq -0x30(%rbp), %rdi
callq 0x49d60
jmp 0x48c8a
jmp 0x48c63
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x48b90
jmp 0x48c73
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x48b79
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x382e0
nopw %cs:(%rax,%rax)
nopl (%rax)
|
/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;
m_Extension = e;
}
else
throw "Not implemented";
}
|
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), %ecx
movl %ecx, 0x60(%rax)
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x64(%rax)
jmp 0x48e9d
movl $0x8, %edi
callq 0x380d0
movq %rax, %rdi
leaq 0x15d7b(%rip), %rax # 0x5ec05
movq %rax, (%rdi)
movq 0x2f11c(%rip), %rsi # 0x77fb0
xorl %eax, %eax
movl %eax, %edx
callq 0x382c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
|
/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 %eax, -0x3c(%rbp)
cmpl $0x28, %eax
ja 0x48f3a
movq -0x48(%rbp), %rcx
movl -0x3c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x58(%rbp)
jmp 0x48f51
movq -0x48(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x68(%rbp)
movl (%rax), %eax
movl %eax, -0x5c(%rbp)
cmpl $0x28, %eax
ja 0x48f85
movq -0x68(%rbp), %rcx
movl -0x5c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x70(%rbp)
jmp 0x48f9c
movq -0x68(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x70(%rbp)
movq -0x50(%rbp), %rdi
movq -0x70(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, 0x30(%rdi)
movl -0x24(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x38(%rbp)
leaq -0x30(%rbp), %rsi
leaq -0x34(%rbp), %rdx
leaq -0x38(%rbp), %rcx
callq 0x49370
xorb $-0x1, %al
testb $0x1, %al
jne 0x48fdc
jmp 0x48fea
movq -0x50(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x8(%rbp)
jmp 0x49006
movq -0x50(%rbp), %rdi
addq $0x38, %rdi
movl -0x24(%rbp), %esi
movl -0x28(%rbp), %edx
movl -0x2c(%rbp), %ecx
movb $0x0, %al
callq 0x49400
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
|
/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 _array(_x, _y, _z);
}
|
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 %eax, -0x48(%rbp)
cmpl $0x28, %eax
ja 0x4906d
movq -0x50(%rbp), %rcx
movl -0x48(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x60(%rbp)
jmp 0x49084
movq -0x50(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x70(%rbp)
movl (%rax), %eax
movl %eax, -0x64(%rbp)
cmpl $0x28, %eax
ja 0x490b8
movq -0x70(%rbp), %rcx
movl -0x64(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x78(%rbp)
jmp 0x490cf
movq -0x70(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x78(%rbp)
movq -0x58(%rbp), %rdi
movq -0x78(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq %rdi, %rax
addq $0x30, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
xorps %xmm0, %xmm0
movss %xmm0, (%rax)
movl -0x24(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x44(%rbp)
leaq -0x3c(%rbp), %rsi
leaq -0x40(%rbp), %rdx
leaq -0x44(%rbp), %rcx
callq 0x49370
xorb $-0x1, %al
testb $0x1, %al
jne 0x4911d
jmp 0x4912b
movq -0x58(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x8(%rbp)
jmp 0x49147
movq -0x58(%rbp), %rdi
addq $0x38, %rdi
movl -0x24(%rbp), %esi
movl -0x28(%rbp), %edx
movl -0x2c(%rbp), %ecx
movb $0x0, %al
callq 0x495e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
|
/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];
}
stream.write((const char *)&sig, sizeof(unsigned int));
stream.write((const char *)&_dims[0], N*sizeof(unsigned int));
stream.write((const char *)_array, size*sizeof(T));
return true;
}
|
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 = 0x53534C41
movl $0x1, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x3, -0x24(%rbp)
jge 0x4a2eb
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl 0x8(%rax,%rcx,4), %eax
imull -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4a2c7
movq -0x18(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
movl $0x4, %edx
callq 0x38200
movq -0x30(%rbp), %rsi
movq -0x18(%rbp), %rdi
addq $0x8, %rsi
movl $0xc, %edx
callq 0x38200
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rdi
movq (%rax), %rsi
movl -0x20(%rbp), %eax
movl %eax, %edx
shlq $0x2, %rdx
callq 0x38200
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
/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)
movq %rcx, -0xf8(%rbp)
movq %rdx, -0x100(%rbp)
movq %rsi, -0x108(%rbp)
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x130(%rbp)
movl $0x3, -0x44(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x128(%rbp)
leaq -0x44(%rbp), %rsi
callq 0x395d0
movq -0x128(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x120(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x3cce0
movq %rax, -0x118(%rbp)
jmp 0x4a642
movq -0x118(%rbp), %rax
movsd -0x120(%rbp), %xmm0
movsd %xmm0, (%rax)
leaq -0x30(%rbp), %rax
leaq -0x110(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x40, 0x4(%rax)
movl $0x8, (%rax)
movl $0x1, -0x58(%rbp)
cmpl $0x3, -0x58(%rbp)
jae 0x4a75b
leaq -0x30(%rbp), %rax
movq %rax, -0x148(%rbp)
addq $0x4, %rax
movq %rax, -0x140(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x134(%rbp)
cmpl $0xa0, %eax
ja 0x4a6f3
movq -0x140(%rbp), %rcx
movl -0x134(%rbp), %edx
movq -0x148(%rbp), %rsi
movslq %edx, %rax
addq 0x10(%rsi), %rax
addl $0x10, %edx
movl %edx, (%rcx)
movq %rax, -0x150(%rbp)
jmp 0x4a710
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3ca20
jmp 0x4a793
movq -0x148(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x150(%rbp)
movq -0x150(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x160(%rbp)
movl -0x58(%rbp), %eax
movl %eax, %esi
leaq -0x40(%rbp), %rdi
callq 0x3cce0
movq %rax, -0x158(%rbp)
jmp 0x4a73a
movq -0x158(%rbp), %rax
movsd -0x160(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0x4a680
movq -0x130(%rbp), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
leaq -0x40(%rbp), %rsi
callq *%rax
movsd %xmm0, -0x168(%rbp)
jmp 0x4a779
leaq -0x40(%rbp), %rdi
callq 0x3ca20
movsd -0x168(%rbp), %xmm0
addq $0x170, %rsp # imm = 0x170
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x382e0
nopl (%rax)
|
/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*)_lattice,
component);
return BF::template convolution_sum_deriv_h<N, L, BF>(
_mSpaceTransform*p,
(const L*)_lattice,
component,
_dBasisScale);
}
if(!_d[component]) return 0;
if(!_bForceScale)
return BF::template convolution_sum<N, L, BF>(
_mSpaceTransform*p,
(const L*)_d[component]);
return BF::template convolution_sum_h<N, L, BF>(
_mSpaceTransform*p,
(const L*)_d[component],
_dBasisScale);
}
|
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)
jne 0x4ae24
movq -0xb8(%rbp), %rdi
addq $0x38, %rdi
movq -0x20(%rbp), %rsi
callq 0x4c490
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x4c4e0
movq -0xb8(%rbp), %rax
movq -0xc8(%rbp), %rdi
movq 0x8(%rax), %rsi
leaq -0x14(%rbp), %rdx
callq 0x58010
movsd %xmm0, -0xc0(%rbp)
jmp 0x4adef
movsd -0xc0(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3ca20
jmp 0x4b012
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3ca20
jmp 0x4b020
movq -0xb8(%rbp), %rdi
addq $0x38, %rdi
movq -0x20(%rbp), %rsi
callq 0x4c490
movq %rax, -0x70(%rbp)
movq %rdx, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
leaq -0x70(%rbp), %rsi
callq 0x4c4e0
movq -0xb8(%rbp), %rcx
movq -0xd8(%rbp), %rdi
movq 0x8(%rcx), %rsi
addq $0x30, %rcx
leaq -0x14(%rbp), %rdx
callq 0x58040
movsd %xmm0, -0xd0(%rbp)
jmp 0x4ae7d
movsd -0xd0(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3ca20
jmp 0x4b012
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3ca20
jmp 0x4b020
movq -0xb8(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq $0x0, 0x10(%rax,%rcx,8)
jne 0x4aed2
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x4b012
movq -0xb8(%rbp), %rax
testb $0x1, 0x29(%rax)
jne 0x4af77
movq -0xb8(%rbp), %rdi
addq $0x38, %rdi
movq -0x20(%rbp), %rsi
callq 0x4c490
movq %rax, -0x90(%rbp)
movq %rdx, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
leaq -0x90(%rbp), %rsi
callq 0x4c4e0
movq -0xb8(%rbp), %rax
movq -0xe8(%rbp), %rdi
movslq -0x14(%rbp), %rcx
movq 0x10(%rax,%rcx,8), %rsi
callq 0x4c460
movsd %xmm0, -0xe0(%rbp)
jmp 0x4af42
movsd -0xe0(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x3ca20
jmp 0x4b012
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x3ca20
jmp 0x4b020
movq -0xb8(%rbp), %rdi
addq $0x38, %rdi
movq -0x20(%rbp), %rsi
callq 0x4c490
movq %rax, -0xb0(%rbp)
movq %rdx, -0xa8(%rbp)
leaq -0xa0(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
leaq -0xb0(%rbp), %rsi
callq 0x4c4e0
movq -0xb8(%rbp), %rdx
movq -0xf8(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq 0x10(%rdx,%rax,8), %rsi
addq $0x30, %rdx
callq 0x4c520
movsd %xmm0, -0xf0(%rbp)
jmp 0x4afdd
movsd -0xf0(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x3ca20
jmp 0x4b012
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x3ca20
jmp 0x4b020
movsd -0x8(%rbp), %xmm0
addq $0x100, %rsp # imm = 0x100
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x382e0
nopl (%rax)
|
/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)
movaps %xmm7, -0x70(%rbp)
movq %r9, -0xe8(%rbp)
movq %r8, -0xf0(%rbp)
movq %rcx, -0xf8(%rbp)
movq %rdx, -0x100(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x130(%rbp)
movl $0x3, -0x44(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x128(%rbp)
leaq -0x44(%rbp), %rsi
callq 0x395d0
movq -0x128(%rbp), %rdi
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x120(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x3cce0
movq %rax, -0x118(%rbp)
jmp 0x4b0f0
movq -0x118(%rbp), %rax
movsd -0x120(%rbp), %xmm0
movsd %xmm0, (%rax)
leaq -0x30(%rbp), %rax
leaq -0x110(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x40, 0x4(%rax)
movl $0x10, (%rax)
movl $0x1, -0x58(%rbp)
cmpl $0x3, -0x58(%rbp)
jae 0x4b209
leaq -0x30(%rbp), %rax
movq %rax, -0x158(%rbp)
addq $0x4, %rax
movq %rax, -0x150(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x144(%rbp)
cmpl $0xa0, %eax
ja 0x4b1a1
movq -0x150(%rbp), %rcx
movl -0x144(%rbp), %edx
movq -0x158(%rbp), %rsi
movslq %edx, %rax
addq 0x10(%rsi), %rax
addl $0x10, %edx
movl %edx, (%rcx)
movq %rax, -0x160(%rbp)
jmp 0x4b1be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3ca20
jmp 0x4b23f
movq -0x158(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x160(%rbp)
movq -0x160(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x170(%rbp)
movl -0x58(%rbp), %eax
movl %eax, %esi
leaq -0x40(%rbp), %rdi
callq 0x3cce0
movq %rax, -0x168(%rbp)
jmp 0x4b1e8
movq -0x168(%rbp), %rax
movsd -0x170(%rbp), %xmm0
movsd %xmm0, (%rax)
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0x4b12e
movq -0x130(%rbp), %rsi
movq -0x140(%rbp), %rdi
movq (%rsi), %rax
movq 0x48(%rax), %rax
leaq -0x40(%rbp), %rdx
callq *%rax
jmp 0x4b226
leaq -0x40(%rbp), %rdi
callq 0x3ca20
movq -0x138(%rbp), %rax
addq $0x170, %rsp # imm = 0x170
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x382e0
nopl (%rax,%rax)
|
/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;
for(lattice_site s : sites) {
if(!lattice->is_lattice_site(c+s)) continue;
if(!lattice->is_filled(c+s)) continue;
double w = BF::template dphi<N>(p - (c+s).cast<double>(), component);
if(w == 0.) continue;
value += w * (double)(*lattice)(c + s);
}
return value;
}
|
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(%rbp), %rsi
movq (%rsi), %rax
movq 0x50(%rax), %rax
leaq -0x60(%rbp), %rdi
callq *%rax
jmp 0x580ca
xorps %xmm0, %xmm0
movsd %xmm0, -0x68(%rbp)
leaq -0x30(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
callq 0x528e0
movq %rax, -0x78(%rbp)
movq -0x70(%rbp), %rdi
callq 0x52910
movq %rax, -0x80(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x52940
testb $0x1, %al
jne 0x5810a
jmp 0x58499
leaq -0x78(%rbp), %rdi
callq 0x52980
movq %rax, %rsi
leaq -0x90(%rbp), %rdi
callq 0x529a0
jmp 0x58124
movq -0x10(%rbp), %rax
movq %rax, -0x1a8(%rbp)
leaq -0xb8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0x529d0
jmp 0x58148
leaq -0xa0(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x52a40
jmp 0x5815d
movq -0x1a8(%rbp), %rdi
movq (%rdi), %rax
movq 0x88(%rax), %rax
leaq -0xa0(%rbp), %rsi
callq *%rax
movb %al, -0x1a9(%rbp)
jmp 0x5817f
movb -0x1a9(%rbp), %al
xorb $-0x1, %al
movb %al, -0x1aa(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x49d60
movb -0x1aa(%rbp), %al
testb $0x1, %al
jne 0x581a5
jmp 0x58215
movl $0x3, -0xbc(%rbp)
jmp 0x58449
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x584ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x584e5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x584dc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x5848b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x49d60
jmp 0x5848b
movq -0x10(%rbp), %rax
movq %rax, -0x1b8(%rbp)
leaq -0xe8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0x529d0
jmp 0x58239
leaq -0xd0(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
callq 0x52a40
jmp 0x5824e
movq -0x1b8(%rbp), %rdi
movq (%rdi), %rax
movq 0xa0(%rax), %rax
leaq -0xd0(%rbp), %rsi
callq *%rax
movb %al, -0x1b9(%rbp)
jmp 0x58270
movb -0x1b9(%rbp), %al
xorb $-0x1, %al
movb %al, -0x1ba(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x49d60
movb -0x1ba(%rbp), %al
testb $0x1, %al
jne 0x58296
jmp 0x582c2
movl $0x3, -0xbc(%rbp)
jmp 0x58449
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x49d60
jmp 0x5848b
movq -0x8(%rbp), %rax
movq %rax, -0x1c8(%rbp)
leaq -0x178(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0x529d0
jmp 0x582e6
leaq -0x160(%rbp), %rdi
leaq -0x178(%rbp), %rsi
callq 0x52b10
jmp 0x582fb
movq -0x1c8(%rbp), %rsi
leaq -0x138(%rbp), %rdi
leaq -0x160(%rbp), %rdx
callq 0x52aa0
jmp 0x58317
leaq -0x100(%rbp), %rdi
leaq -0x138(%rbp), %rsi
callq 0x52b60
jmp 0x5832c
movq -0x18(%rbp), %rsi
leaq -0x100(%rbp), %rdi
callq 0x58500
movsd %xmm0, -0x1d0(%rbp)
jmp 0x58346
leaq -0x100(%rbp), %rdi
callq 0x3ca20
movsd -0x1d0(%rbp), %xmm0
movsd %xmm0, -0xf0(%rbp)
movsd -0xf0(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x583a1
jp 0x583a1
movl $0x3, -0xbc(%rbp)
jmp 0x58449
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x100(%rbp), %rdi
callq 0x3ca20
jmp 0x5848b
movsd -0xf0(%rbp), %xmm0
movsd %xmm0, -0x1e0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1d8(%rbp)
leaq -0x1a0(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0x529d0
jmp 0x583d5
leaq -0x188(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0x52a40
jmp 0x583ea
movq -0x1d8(%rbp), %rdi
movq (%rdi), %rax
movq 0x28(%rax), %rax
leaq -0x188(%rbp), %rsi
callq *%rax
movq %rax, -0x1e8(%rbp)
jmp 0x5840a
movsd -0x1e0(%rbp), %xmm0
movq -0x1e8(%rbp), %rax
movss (%rax), %xmm1
cvtss2sd %xmm1, %xmm2
movsd -0x68(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x68(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x49d60
movl $0x0, -0xbc(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x49d60
movl -0xbc(%rbp), %eax
testl %eax, %eax
je 0x58463
jmp 0x58461
jmp 0x58465
jmp 0x58465
leaq -0x78(%rbp), %rdi
callq 0x52ba0
jmp 0x580f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x49d60
leaq -0x90(%rbp), %rdi
callq 0x49d60
jmp 0x584dc
movsd -0x68(%rbp), %xmm0
movsd %xmm0, -0x1f0(%rbp)
movl $0x1, -0xbc(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x49d60
leaq -0x40(%rbp), %rdi
callq 0x49d60
leaq -0x30(%rbp), %rdi
callq 0x52bc0
movsd -0x1f0(%rbp), %xmm0
addq $0x1f0, %rsp # imm = 0x1F0
popq %rbp
retq
leaq -0x60(%rbp), %rdi
callq 0x49d60
leaq -0x40(%rbp), %rdi
callq 0x49d60
leaq -0x30(%rbp), %rdi
callq 0x52bc0
movq -0x48(%rbp), %rdi
callq 0x382e0
|
/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), %xmm0
jbe 0x585dc
movsd 0x3a4b(%rip), %xmm0 # 0x5c020
movsd %xmm0, -0x8(%rbp)
jmp 0x585f3
movsd 0x3a44(%rip), %xmm0 # 0x5c028
movsd %xmm0, -0x8(%rbp)
jmp 0x585f3
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
popq %rbp
retq
nopw (%rax,%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();
for(lattice_site s : sites) {
if(!lattice->is_lattice_site(c+s)) continue;
if(!lattice->is_filled(c+s)) continue;
for(int j = 0; j < N; j++) {
double w = BF::template dphi<N>(p - (c+s).cast<double>(), j);
if(w == 0.) continue;
value[j] += w * (double)(*lattice)(c + s);
}
}
return value;
}
|
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), %rax
leaq -0x40(%rbp), %rdi
callq *%rax
jmp 0x58c28
movq -0x18(%rbp), %rsi
movq (%rsi), %rax
movq 0x50(%rax), %rax
leaq -0x60(%rbp), %rdi
callq *%rax
jmp 0x58c3b
movq -0x1b8(%rbp), %rdi
movb $0x0, -0x61(%rbp)
movl $0x3, -0x68(%rbp)
leaq -0x68(%rbp), %rsi
callq 0x395d0
jmp 0x58c58
movq -0x1b8(%rbp), %rdi
callq 0x4d850
jmp 0x58c66
leaq -0x30(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
callq 0x528e0
movq %rax, -0x78(%rbp)
movq -0x70(%rbp), %rdi
callq 0x52910
movq %rax, -0x80(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x52940
testb $0x1, %al
jne 0x58c9e
jmp 0x59098
leaq -0x78(%rbp), %rdi
callq 0x52980
movq %rax, %rsi
leaq -0x90(%rbp), %rdi
callq 0x529a0
jmp 0x58cb8
movq -0x18(%rbp), %rax
movq %rax, -0x1c0(%rbp)
leaq -0xb8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0x529d0
jmp 0x58cdc
leaq -0xa0(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x52a40
jmp 0x58cf1
movq -0x1c0(%rbp), %rdi
movq (%rdi), %rax
movq 0x88(%rax), %rax
leaq -0xa0(%rbp), %rsi
callq *%rax
movb %al, -0x1c1(%rbp)
jmp 0x58d13
movb -0x1c1(%rbp), %al
xorb $-0x1, %al
movb %al, -0x1c2(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x49d60
movb -0x1c2(%rbp), %al
testb $0x1, %al
jne 0x58d3c
jmp 0x58dbd
movl $0x3, -0xbc(%rbp)
jmp 0x59060
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x59101
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x590f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x590ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x590e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x5908a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x49d60
jmp 0x5908a
movq -0x18(%rbp), %rax
movq %rax, -0x1d0(%rbp)
leaq -0xe8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0x529d0
jmp 0x58de1
leaq -0xd0(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
callq 0x52a40
jmp 0x58df6
movq -0x1d0(%rbp), %rdi
movq (%rdi), %rax
movq 0xa0(%rax), %rax
leaq -0xd0(%rbp), %rsi
callq *%rax
movb %al, -0x1d1(%rbp)
jmp 0x58e18
movb -0x1d1(%rbp), %al
xorb $-0x1, %al
movb %al, -0x1d2(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x49d60
movb -0x1d2(%rbp), %al
testb $0x1, %al
jne 0x58e3e
jmp 0x58e6a
movl $0x3, -0xbc(%rbp)
jmp 0x59060
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x49d60
jmp 0x5908a
movl $0x0, -0xec(%rbp)
cmpl $0x3, -0xec(%rbp)
jge 0x59056
movq -0x10(%rbp), %rax
movq %rax, -0x1e0(%rbp)
leaq -0x180(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0x529d0
jmp 0x58ea5
leaq -0x168(%rbp), %rdi
leaq -0x180(%rbp), %rsi
callq 0x52b10
jmp 0x58eba
movq -0x1e0(%rbp), %rsi
leaq -0x140(%rbp), %rdi
leaq -0x168(%rbp), %rdx
callq 0x52aa0
jmp 0x58ed6
leaq -0x108(%rbp), %rdi
leaq -0x140(%rbp), %rsi
callq 0x52b60
jmp 0x58eeb
leaq -0x108(%rbp), %rdi
leaq -0xec(%rbp), %rsi
callq 0x58500
movsd %xmm0, -0x1e8(%rbp)
jmp 0x58f08
leaq -0x108(%rbp), %rdi
callq 0x3ca20
movsd -0x1e8(%rbp), %xmm0
movsd %xmm0, -0xf8(%rbp)
movsd -0xf8(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x58f59
jp 0x58f59
jmp 0x59028
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x108(%rbp), %rdi
callq 0x3ca20
jmp 0x5908a
movsd -0xf8(%rbp), %xmm0
movsd %xmm0, -0x1f8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x1f0(%rbp)
leaq -0x1a8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0x529d0
jmp 0x58f8d
leaq -0x190(%rbp), %rdi
leaq -0x1a8(%rbp), %rsi
callq 0x52a40
jmp 0x58fa2
movq -0x1f0(%rbp), %rdi
movq (%rdi), %rax
movq 0x28(%rax), %rax
leaq -0x190(%rbp), %rsi
callq *%rax
movq %rax, -0x200(%rbp)
jmp 0x58fc2
movq -0x1b8(%rbp), %rdi
movq -0x200(%rbp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x210(%rbp)
movslq -0xec(%rbp), %rsi
callq 0x3cce0
movq %rax, -0x208(%rbp)
jmp 0x58ff5
movq -0x208(%rbp), %rax
movsd -0x210(%rbp), %xmm2
movsd -0x1f8(%rbp), %xmm0
movsd (%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax)
leaq -0x190(%rbp), %rdi
callq 0x49d60
movl -0xec(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xec(%rbp)
jmp 0x58e74
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x49d60
jmp 0x5908a
movl $0x0, -0xbc(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x49d60
movl -0xbc(%rbp), %eax
testl %eax, %eax
je 0x5907a
jmp 0x59078
jmp 0x5907c
jmp 0x5907c
leaq -0x78(%rbp), %rdi
callq 0x52ba0
jmp 0x58c88
leaq -0x90(%rbp), %rdi
callq 0x49d60
jmp 0x590e3
movb $0x1, -0x61(%rbp)
movl $0x1, -0xbc(%rbp)
testb $0x1, -0x61(%rbp)
jne 0x590b8
movq -0x1b8(%rbp), %rdi
callq 0x3ca20
leaq -0x60(%rbp), %rdi
callq 0x49d60
leaq -0x40(%rbp), %rdi
callq 0x49d60
leaq -0x30(%rbp), %rdi
callq 0x52bc0
movq -0x1b0(%rbp), %rax
addq $0x210, %rsp # imm = 0x210
popq %rbp
retq
movq -0x1b8(%rbp), %rdi
callq 0x3ca20
leaq -0x60(%rbp), %rdi
callq 0x49d60
leaq -0x40(%rbp), %rdi
callq 0x49d60
leaq -0x30(%rbp), %rdi
callq 0x52bc0
movq -0x48(%rbp), %rdi
callq 0x382e0
nopw %cs:(%rax,%rax)
nopl (%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);
value.setZero();
for(lattice_site s : sites) {
if(!lattice->is_lattice_site(c+s)) continue;
if(!lattice->is_filled(c+s)) continue;
for(int j = 0; j < N; j++) {
double w = BF::template dphi<N>(h, p - (c+s).cast<double>(), j);
if(w == 0.) continue;
value[j] += w * (*lattice)(c + s);
}
}
return value;
}
|
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), %rax
movq 0x70(%rax), %rax
leaq -0x48(%rbp), %rdi
callq *%rax
jmp 0x5916c
movq -0x18(%rbp), %rsi
movq (%rsi), %rax
movq 0x50(%rax), %rax
leaq -0x68(%rbp), %rdi
callq *%rax
jmp 0x5917f
movq -0x1c0(%rbp), %rdi
movb $0x0, -0x69(%rbp)
movl $0x3, -0x70(%rbp)
leaq -0x70(%rbp), %rsi
callq 0x395d0
jmp 0x5919c
movq -0x1c0(%rbp), %rdi
callq 0x4d850
jmp 0x591aa
leaq -0x38(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
callq 0x528e0
movq %rax, -0x80(%rbp)
movq -0x78(%rbp), %rdi
callq 0x52910
movq %rax, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x52940
testb $0x1, %al
jne 0x591e8
jmp 0x595f4
leaq -0x80(%rbp), %rdi
callq 0x52980
movq %rax, %rsi
leaq -0x98(%rbp), %rdi
callq 0x529a0
jmp 0x59202
movq -0x18(%rbp), %rax
movq %rax, -0x1c8(%rbp)
leaq -0xc0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x98(%rbp), %rdx
callq 0x529d0
jmp 0x59226
leaq -0xa8(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x52a40
jmp 0x5923b
movq -0x1c8(%rbp), %rdi
movq (%rdi), %rax
movq 0x88(%rax), %rax
leaq -0xa8(%rbp), %rsi
callq *%rax
movb %al, -0x1c9(%rbp)
jmp 0x5925d
movb -0x1c9(%rbp), %al
xorb $-0x1, %al
movb %al, -0x1ca(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x49d60
movb -0x1ca(%rbp), %al
testb $0x1, %al
jne 0x59286
jmp 0x59307
movl $0x3, -0xc4(%rbp)
jmp 0x595bc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x5965d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x59654
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x5964b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x5963f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x595e6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x49d60
jmp 0x595e6
movq -0x18(%rbp), %rax
movq %rax, -0x1d8(%rbp)
leaq -0xf0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x98(%rbp), %rdx
callq 0x529d0
jmp 0x5932b
leaq -0xd8(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x52a40
jmp 0x59340
movq -0x1d8(%rbp), %rdi
movq (%rdi), %rax
movq 0xa0(%rax), %rax
leaq -0xd8(%rbp), %rsi
callq *%rax
movb %al, -0x1d9(%rbp)
jmp 0x59362
movb -0x1d9(%rbp), %al
xorb $-0x1, %al
movb %al, -0x1da(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x49d60
movb -0x1da(%rbp), %al
testb $0x1, %al
jne 0x59388
jmp 0x593b4
movl $0x3, -0xc4(%rbp)
jmp 0x595bc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x49d60
jmp 0x595e6
movl $0x0, -0xf4(%rbp)
cmpl $0x3, -0xf4(%rbp)
jge 0x595b2
movq -0x20(%rbp), %rax
movq %rax, -0x1f0(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1e8(%rbp)
leaq -0x188(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x98(%rbp), %rdx
callq 0x529d0
jmp 0x593fa
leaq -0x170(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x52b10
jmp 0x5940f
movq -0x1e8(%rbp), %rsi
leaq -0x148(%rbp), %rdi
leaq -0x170(%rbp), %rdx
callq 0x52aa0
jmp 0x5942b
leaq -0x110(%rbp), %rdi
leaq -0x148(%rbp), %rsi
callq 0x52b60
jmp 0x59440
movq -0x1f0(%rbp), %rdi
leaq -0x110(%rbp), %rsi
leaq -0xf4(%rbp), %rdx
callq 0x58aa0
movsd %xmm0, -0x1f8(%rbp)
jmp 0x59464
leaq -0x110(%rbp), %rdi
callq 0x3ca20
movsd -0x1f8(%rbp), %xmm0
movsd %xmm0, -0x100(%rbp)
movsd -0x100(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x594b5
jp 0x594b5
jmp 0x59584
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x110(%rbp), %rdi
callq 0x3ca20
jmp 0x595e6
movsd -0x100(%rbp), %xmm0
movsd %xmm0, -0x208(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x200(%rbp)
leaq -0x1b0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x98(%rbp), %rdx
callq 0x529d0
jmp 0x594e9
leaq -0x198(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
callq 0x52a40
jmp 0x594fe
movq -0x200(%rbp), %rdi
movq (%rdi), %rax
movq 0x28(%rax), %rax
leaq -0x198(%rbp), %rsi
callq *%rax
movq %rax, -0x210(%rbp)
jmp 0x5951e
movq -0x1c0(%rbp), %rdi
movq -0x210(%rbp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x220(%rbp)
movslq -0xf4(%rbp), %rsi
callq 0x3cce0
movq %rax, -0x218(%rbp)
jmp 0x59551
movq -0x218(%rbp), %rax
movsd -0x220(%rbp), %xmm2
movsd -0x208(%rbp), %xmm0
movsd (%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax)
leaq -0x198(%rbp), %rdi
callq 0x49d60
movl -0xf4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xf4(%rbp)
jmp 0x593be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x49d60
jmp 0x595e6
movl $0x0, -0xc4(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x49d60
movl -0xc4(%rbp), %eax
testl %eax, %eax
je 0x595d6
jmp 0x595d4
jmp 0x595d8
jmp 0x595d8
leaq -0x80(%rbp), %rdi
callq 0x52ba0
jmp 0x591cf
leaq -0x98(%rbp), %rdi
callq 0x49d60
jmp 0x5963f
movb $0x1, -0x69(%rbp)
movl $0x1, -0xc4(%rbp)
testb $0x1, -0x69(%rbp)
jne 0x59614
movq -0x1c0(%rbp), %rdi
callq 0x3ca20
leaq -0x68(%rbp), %rdi
callq 0x49d60
leaq -0x48(%rbp), %rdi
callq 0x49d60
leaq -0x38(%rbp), %rdi
callq 0x52bc0
movq -0x1b8(%rbp), %rax
addq $0x220, %rsp # imm = 0x220
popq %rbp
retq
movq -0x1c0(%rbp), %rdi
callq 0x3ca20
leaq -0x68(%rbp), %rdi
callq 0x49d60
leaq -0x48(%rbp), %rdi
callq 0x49d60
leaq -0x38(%rbp), %rdi
callq 0x52bc0
movq -0x50(%rbp), %rdi
callq 0x382e0
nop
|
/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.setZero();
for(lattice_site s : sites) {
if(!base->is_lattice_site(c+s)) continue;
double w = BF::template phi<N>(p - (c+s).cast<double>());
if(w == 0.) continue;
for(int j = 0; j < N; j++) {
if(lattices[j] == nullptr) continue;
if(!lattices[j]->is_filled(c+s)) continue;
value[j] += w * (double)(*lattices[j])(c + s);
}
}
return value;
}
|
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), %rax
movq 0x70(%rax), %rax
leaq -0x48(%rbp), %rdi
callq *%rax
jmp 0x596bc
movq -0x18(%rbp), %rsi
movq (%rsi), %rax
movq 0x50(%rax), %rax
leaq -0x68(%rbp), %rdi
callq *%rax
jmp 0x596cf
movq -0x1c0(%rbp), %rdi
movb $0x0, -0x69(%rbp)
movl $0x3, -0x70(%rbp)
leaq -0x70(%rbp), %rsi
callq 0x395d0
jmp 0x596ec
movq -0x1c0(%rbp), %rdi
callq 0x4d850
jmp 0x596fa
leaq -0x38(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
callq 0x528e0
movq %rax, -0x80(%rbp)
movq -0x78(%rbp), %rdi
callq 0x52910
movq %rax, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x52940
testb $0x1, %al
jne 0x59738
jmp 0x59b58
leaq -0x80(%rbp), %rdi
callq 0x52980
movq %rax, %rsi
leaq -0x98(%rbp), %rdi
callq 0x529a0
jmp 0x59752
movq -0x18(%rbp), %rax
movq %rax, -0x1c8(%rbp)
leaq -0xc0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x98(%rbp), %rdx
callq 0x529d0
jmp 0x59776
leaq -0xa8(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x52a40
jmp 0x5978b
movq -0x1c8(%rbp), %rdi
movq (%rdi), %rax
movq 0x88(%rax), %rax
leaq -0xa8(%rbp), %rsi
callq *%rax
movb %al, -0x1c9(%rbp)
jmp 0x597ad
movb -0x1c9(%rbp), %al
xorb $-0x1, %al
movb %al, -0x1ca(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x49d60
movb -0x1ca(%rbp), %al
testb $0x1, %al
jne 0x597d6
jmp 0x59857
movl $0x3, -0xc4(%rbp)
jmp 0x59b20
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x59bc1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x59bb8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x59baf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x59ba3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x59b4a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x49d60
jmp 0x59b4a
movq -0x10(%rbp), %rax
movq %rax, -0x1d8(%rbp)
leaq -0x158(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x98(%rbp), %rdx
callq 0x529d0
jmp 0x5987b
leaq -0x140(%rbp), %rdi
leaq -0x158(%rbp), %rsi
callq 0x52b10
jmp 0x59890
movq -0x1d8(%rbp), %rsi
leaq -0x118(%rbp), %rdi
leaq -0x140(%rbp), %rdx
callq 0x52aa0
jmp 0x598ac
leaq -0xe0(%rbp), %rdi
leaq -0x118(%rbp), %rsi
callq 0x52b60
jmp 0x598c1
leaq -0xe0(%rbp), %rdi
callq 0x57010
movsd %xmm0, -0x1e0(%rbp)
jmp 0x598d7
leaq -0xe0(%rbp), %rdi
callq 0x3ca20
movsd -0x1e0(%rbp), %xmm0
movsd %xmm0, -0xd0(%rbp)
movsd -0xd0(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x59932
jp 0x59932
movl $0x3, -0xc4(%rbp)
jmp 0x59b20
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x3ca20
jmp 0x59b4a
movl $0x0, -0x15c(%rbp)
cmpl $0x3, -0x15c(%rbp)
jge 0x59b16
movq -0x20(%rbp), %rax
movslq -0x15c(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x59960
jmp 0x59ae8
movq -0x20(%rbp), %rax
movslq -0x15c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x1e8(%rbp)
leaq -0x188(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x98(%rbp), %rdx
callq 0x529d0
jmp 0x5998f
leaq -0x170(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x52a40
jmp 0x599a4
movq -0x1e8(%rbp), %rdi
movq (%rdi), %rax
movq 0xa0(%rax), %rax
leaq -0x170(%rbp), %rsi
callq *%rax
movb %al, -0x1e9(%rbp)
jmp 0x599c6
movb -0x1e9(%rbp), %al
xorb $-0x1, %al
movb %al, -0x1ea(%rbp)
leaq -0x170(%rbp), %rdi
callq 0x49d60
movb -0x1ea(%rbp), %al
testb $0x1, %al
jne 0x599ec
jmp 0x59a0e
jmp 0x59ae8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x170(%rbp), %rdi
callq 0x49d60
jmp 0x59b4a
movsd -0xd0(%rbp), %xmm0
movsd %xmm0, -0x200(%rbp)
movq -0x20(%rbp), %rax
movslq -0x15c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x1f8(%rbp)
leaq -0x1b0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x98(%rbp), %rdx
callq 0x529d0
jmp 0x59a4d
leaq -0x198(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
callq 0x52a40
jmp 0x59a62
movq -0x1f8(%rbp), %rdi
movq (%rdi), %rax
movq 0x28(%rax), %rax
leaq -0x198(%rbp), %rsi
callq *%rax
movq %rax, -0x208(%rbp)
jmp 0x59a82
movq -0x1c0(%rbp), %rdi
movq -0x208(%rbp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x218(%rbp)
movslq -0x15c(%rbp), %rsi
callq 0x3cce0
movq %rax, -0x210(%rbp)
jmp 0x59ab5
movq -0x210(%rbp), %rax
movsd -0x218(%rbp), %xmm2
movsd -0x200(%rbp), %xmm0
movsd (%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax)
leaq -0x198(%rbp), %rdi
callq 0x49d60
movl -0x15c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x15c(%rbp)
jmp 0x5993c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x49d60
jmp 0x59b4a
movl $0x0, -0xc4(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x49d60
movl -0xc4(%rbp), %eax
testl %eax, %eax
je 0x59b3a
jmp 0x59b38
jmp 0x59b3c
jmp 0x59b3c
leaq -0x80(%rbp), %rdi
callq 0x52ba0
jmp 0x5971f
leaq -0x98(%rbp), %rdi
callq 0x49d60
jmp 0x59ba3
movb $0x1, -0x69(%rbp)
movl $0x1, -0xc4(%rbp)
testb $0x1, -0x69(%rbp)
jne 0x59b78
movq -0x1c0(%rbp), %rdi
callq 0x3ca20
leaq -0x68(%rbp), %rdi
callq 0x49d60
leaq -0x48(%rbp), %rdi
callq 0x49d60
leaq -0x38(%rbp), %rdi
callq 0x52bc0
movq -0x1b8(%rbp), %rax
addq $0x220, %rsp # imm = 0x220
popq %rbp
retq
movq -0x1c0(%rbp), %rdi
callq 0x3ca20
leaq -0x68(%rbp), %rdi
callq 0x49d60
leaq -0x48(%rbp), %rdi
callq 0x49d60
leaq -0x38(%rbp), %rdi
callq 0x52bc0
movq -0x50(%rbp), %rdi
callq 0x382e0
nopw %cs:(%rax,%rax)
nopl (%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*, 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);
value.setZero();
for(lattice_site s : sites) {
if(!base->is_lattice_site(c+s)) continue;
double w = BF::template phi<N>(h, p - (c+s).cast<double>());
if(w == 0.) continue;
for(int j = 0; j < N; j++) {
if(lattices[j] == nullptr) continue;
if(!lattices[j]->is_filled(c+s)) continue;
value[j] += w * (double)(*lattices[j])(c + s);
}
}
return value;
}
|
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(%rbp), %rdx
movq (%rsi), %rax
movq 0x70(%rax), %rax
leaq -0x50(%rbp), %rdi
callq *%rax
jmp 0x59c30
movq -0x18(%rbp), %rsi
movq (%rsi), %rax
movq 0x50(%rax), %rax
leaq -0x70(%rbp), %rdi
callq *%rax
jmp 0x59c43
movq -0x1c8(%rbp), %rdi
movb $0x0, -0x71(%rbp)
movl $0x3, -0x78(%rbp)
leaq -0x78(%rbp), %rsi
callq 0x395d0
jmp 0x59c60
movq -0x1c8(%rbp), %rdi
callq 0x4d850
jmp 0x59c6e
leaq -0x40(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rdi
callq 0x528e0
movq %rax, -0x88(%rbp)
movq -0x80(%rbp), %rdi
callq 0x52910
movq %rax, -0x90(%rbp)
leaq -0x88(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x52940
testb $0x1, %al
jne 0x59cb2
jmp 0x5a0ea
leaq -0x88(%rbp), %rdi
callq 0x52980
movq %rax, %rsi
leaq -0xa0(%rbp), %rdi
callq 0x529a0
jmp 0x59ccf
movq -0x18(%rbp), %rax
movq %rax, -0x1d0(%rbp)
leaq -0xc8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
callq 0x529d0
jmp 0x59cf3
leaq -0xb0(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x52a40
jmp 0x59d08
movq -0x1d0(%rbp), %rdi
movq (%rdi), %rax
movq 0x88(%rax), %rax
leaq -0xb0(%rbp), %rsi
callq *%rax
movb %al, -0x1d1(%rbp)
jmp 0x59d2a
movb -0x1d1(%rbp), %al
xorb $-0x1, %al
movb %al, -0x1d2(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x49d60
movb -0x1d2(%rbp), %al
testb $0x1, %al
jne 0x59d53
jmp 0x59dd4
movl $0x3, -0xcc(%rbp)
jmp 0x5a0af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x5a153
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x5a14a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x5a141
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x5a135
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x5a0dc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x49d60
jmp 0x5a0dc
movq -0x28(%rbp), %rax
movq %rax, -0x1e8(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1e0(%rbp)
leaq -0x160(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
callq 0x529d0
jmp 0x59e03
leaq -0x148(%rbp), %rdi
leaq -0x160(%rbp), %rsi
callq 0x52b10
jmp 0x59e18
movq -0x1e0(%rbp), %rsi
leaq -0x120(%rbp), %rdi
leaq -0x148(%rbp), %rdx
callq 0x52aa0
jmp 0x59e34
leaq -0xe8(%rbp), %rdi
leaq -0x120(%rbp), %rsi
callq 0x52b60
jmp 0x59e49
movq -0x1e8(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
callq 0x52a80
movsd %xmm0, -0x1f0(%rbp)
jmp 0x59e66
leaq -0xe8(%rbp), %rdi
callq 0x3ca20
movsd -0x1f0(%rbp), %xmm0
movsd %xmm0, -0xd8(%rbp)
movsd -0xd8(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x59ec1
jp 0x59ec1
movl $0x3, -0xcc(%rbp)
jmp 0x5a0af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x3ca20
jmp 0x5a0dc
movl $0x0, -0x164(%rbp)
cmpl $0x3, -0x164(%rbp)
jge 0x5a0a5
movq -0x20(%rbp), %rax
movslq -0x164(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x59eef
jmp 0x5a077
movq -0x20(%rbp), %rax
movslq -0x164(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x1f8(%rbp)
leaq -0x190(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
callq 0x529d0
jmp 0x59f1e
leaq -0x178(%rbp), %rdi
leaq -0x190(%rbp), %rsi
callq 0x52a40
jmp 0x59f33
movq -0x1f8(%rbp), %rdi
movq (%rdi), %rax
movq 0xa0(%rax), %rax
leaq -0x178(%rbp), %rsi
callq *%rax
movb %al, -0x1f9(%rbp)
jmp 0x59f55
movb -0x1f9(%rbp), %al
xorb $-0x1, %al
movb %al, -0x1fa(%rbp)
leaq -0x178(%rbp), %rdi
callq 0x49d60
movb -0x1fa(%rbp), %al
testb $0x1, %al
jne 0x59f7b
jmp 0x59f9d
jmp 0x5a077
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x178(%rbp), %rdi
callq 0x49d60
jmp 0x5a0dc
movsd -0xd8(%rbp), %xmm0
movsd %xmm0, -0x210(%rbp)
movq -0x20(%rbp), %rax
movslq -0x164(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x208(%rbp)
leaq -0x1b8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
callq 0x529d0
jmp 0x59fdc
leaq -0x1a0(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x52a40
jmp 0x59ff1
movq -0x208(%rbp), %rdi
movq (%rdi), %rax
movq 0x28(%rax), %rax
leaq -0x1a0(%rbp), %rsi
callq *%rax
movq %rax, -0x218(%rbp)
jmp 0x5a011
movq -0x1c8(%rbp), %rdi
movq -0x218(%rbp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x228(%rbp)
movslq -0x164(%rbp), %rsi
callq 0x3cce0
movq %rax, -0x220(%rbp)
jmp 0x5a044
movq -0x220(%rbp), %rax
movsd -0x228(%rbp), %xmm2
movsd -0x210(%rbp), %xmm0
movsd (%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, (%rax)
leaq -0x1a0(%rbp), %rdi
callq 0x49d60
movl -0x164(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x164(%rbp)
jmp 0x59ecb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x49d60
jmp 0x5a0dc
movl $0x0, -0xcc(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x49d60
movl -0xcc(%rbp), %eax
testl %eax, %eax
je 0x5a0c9
jmp 0x5a0c7
jmp 0x5a0cb
jmp 0x5a0cb
leaq -0x88(%rbp), %rdi
callq 0x52ba0
jmp 0x59c96
leaq -0xa0(%rbp), %rdi
callq 0x49d60
jmp 0x5a135
movb $0x1, -0x71(%rbp)
movl $0x1, -0xcc(%rbp)
testb $0x1, -0x71(%rbp)
jne 0x5a10a
movq -0x1c8(%rbp), %rdi
callq 0x3ca20
leaq -0x70(%rbp), %rdi
callq 0x49d60
leaq -0x50(%rbp), %rdi
callq 0x49d60
leaq -0x40(%rbp), %rdi
callq 0x52bc0
movq -0x1c0(%rbp), %rax
addq $0x230, %rsp # imm = 0x230
popq %rbp
retq
movq -0x1c8(%rbp), %rdi
callq 0x3ca20
leaq -0x70(%rbp), %rdi
callq 0x49d60
leaq -0x50(%rbp), %rdi
callq 0x49d60
leaq -0x40(%rbp), %rdi
callq 0x52bc0
movq -0x58(%rbp), %rdi
callq 0x382e0
nopw %cs:(%rax,%rax)
nop
|
/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;
if(extensions == NULL || ext == NULL) {
return 0;
}
while(1) {
loc = strstr(extensions, ext);
if(loc == NULL) {
return 0;
}
terminator = loc + strlen(ext);
if((loc == extensions || *(loc - 1) == ' ') &&
(*terminator == ' ' || *terminator == '\0')) {
return 1;
}
extensions = terminator;
}
} else {
unsigned int index;
for(index = 0; index < num_exts_i; index++) {
const char *e = exts_i[index];
if(strcmp(e, ext) == 0) {
return 1;
}
}
}
return 0;
}
|
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, %r12
movq %rbx, %rdi
callq 0x14230
movq %rax, %r15
movq %r14, %rax
leaq (%r12,%r15), %r14
cmpq %rax, %r12
je 0x1c59b
cmpb $0x20, -0x1(%r12)
jne 0x1c5a3
movzbl (%r14), %eax
testb $-0x21, %al
je 0x1c60f
movq %r14, %rdi
movq %rbx, %rsi
callq 0x140d0
movq %rax, %r12
testq %rax, %rax
jne 0x1c587
jmp 0x1c604
movl %edx, %ebp
testl %edx, %edx
setne %r14b
je 0x1c600
movq %rcx, %r15
movq (%rcx), %rdi
movq %rbx, %rsi
callq 0x146b0
testl %eax, %eax
je 0x1c600
movl %ebp, %r14d
movl $0x1, %ecx
movq %rcx, %r12
cmpq %rcx, %r14
je 0x1c5f9
movq (%r15,%r12,8), %rdi
movq %rbx, %rsi
callq 0x146b0
leaq 0x1(%r12), %rcx
testl %eax, %eax
jne 0x1c5dc
cmpq %r14, %r12
setb %r14b
movzbl %r14b, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %ebp
jmp 0x1c604
nop
|
/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;
}
}
if (ctxconfig->source != GLFW_NATIVE_CONTEXT_API &&
ctxconfig->source != GLFW_EGL_CONTEXT_API &&
ctxconfig->source != GLFW_OSMESA_CONTEXT_API)
{
_glfwInputError(GLFW_INVALID_ENUM,
"Invalid context creation API 0x%08X",
ctxconfig->source);
return GLFW_FALSE;
}
if (ctxconfig->client != GLFW_NO_API &&
ctxconfig->client != GLFW_OPENGL_API &&
ctxconfig->client != GLFW_OPENGL_ES_API)
{
_glfwInputError(GLFW_INVALID_ENUM,
"Invalid client API 0x%08X",
ctxconfig->client);
return GLFW_FALSE;
}
if (ctxconfig->client == GLFW_OPENGL_API)
{
if ((ctxconfig->major < 1 || ctxconfig->minor < 0) ||
(ctxconfig->major == 1 && ctxconfig->minor > 5) ||
(ctxconfig->major == 2 && ctxconfig->minor > 1) ||
(ctxconfig->major == 3 && ctxconfig->minor > 3))
{
// OpenGL 1.0 is the smallest valid version
// OpenGL 1.x series ended with version 1.5
// OpenGL 2.x series ended with version 2.1
// OpenGL 3.x series ended with version 3.3
// For now, let everything else through
_glfwInputError(GLFW_INVALID_VALUE,
"Invalid OpenGL version %i.%i",
ctxconfig->major, ctxconfig->minor);
return GLFW_FALSE;
}
if (ctxconfig->profile)
{
if (ctxconfig->profile != GLFW_OPENGL_CORE_PROFILE &&
ctxconfig->profile != GLFW_OPENGL_COMPAT_PROFILE)
{
_glfwInputError(GLFW_INVALID_ENUM,
"Invalid OpenGL profile 0x%08X",
ctxconfig->profile);
return GLFW_FALSE;
}
if (ctxconfig->major <= 2 ||
(ctxconfig->major == 3 && ctxconfig->minor < 2))
{
// Desktop OpenGL context profiles are only defined for version 3.2
// and above
_glfwInputError(GLFW_INVALID_VALUE,
"Context profiles are only defined for OpenGL version 3.2 and above");
return GLFW_FALSE;
}
}
if (ctxconfig->forward && ctxconfig->major <= 2)
{
// Forward-compatible contexts are only defined for OpenGL version 3.0 and above
_glfwInputError(GLFW_INVALID_VALUE,
"Forward-compatibility is only defined for OpenGL version 3.0 and above");
return GLFW_FALSE;
}
}
else if (ctxconfig->client == GLFW_OPENGL_ES_API)
{
if (ctxconfig->major < 1 || ctxconfig->minor < 0 ||
(ctxconfig->major == 1 && ctxconfig->minor > 1) ||
(ctxconfig->major == 2 && ctxconfig->minor > 0))
{
// OpenGL ES 1.0 is the smallest valid version
// OpenGL ES 1.x series ended with version 1.1
// OpenGL ES 2.x series ended with version 2.0
// For now, let everything else through
_glfwInputError(GLFW_INVALID_VALUE,
"Invalid OpenGL ES version %i.%i",
ctxconfig->major, ctxconfig->minor);
return GLFW_FALSE;
}
}
if (ctxconfig->robustness)
{
if (ctxconfig->robustness != GLFW_NO_RESET_NOTIFICATION &&
ctxconfig->robustness != GLFW_LOSE_CONTEXT_ON_RESET)
{
_glfwInputError(GLFW_INVALID_ENUM,
"Invalid context robustness mode 0x%08X",
ctxconfig->robustness);
return GLFW_FALSE;
}
}
if (ctxconfig->release)
{
if (ctxconfig->release != GLFW_RELEASE_BEHAVIOR_NONE &&
ctxconfig->release != GLFW_RELEASE_BEHAVIOR_FLUSH)
{
_glfwInputError(GLFW_INVALID_ENUM,
"Invalid context release behavior 0x%08X",
ctxconfig->release);
return GLFW_FALSE;
}
}
return GLFW_TRUE;
}
|
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 # imm = 0x30002
jne 0x1c724
movl 0x8(%rdi), %edx
testl %edx, %edx
jle 0x1c68f
movl 0xc(%rdi), %eax
testl %eax, %eax
js 0x1c68f
cmpl $0x1, %edx
sete %cl
cmpl $0x2, %eax
setge %sil
testb %sil, %cl
jne 0x1c68f
cmpl $0x2, %edx
setne %cl
testl %eax, %eax
sete %al
orb %cl, %al
jne 0x1c782
movl 0xc(%rdi), %ecx
leaq 0x14bd7(%rip), %rsi # 0x31270
jmp 0x1c712
xorl %ebx, %ebx
movl $0x1000a, %edi # imm = 0x1000A
xorl %esi, %esi
xorl %eax, %eax
callq 0x1d1a1
jmp 0x1c720
leaq 0x14ab9(%rip), %rsi # 0x3116d
xorl %ebx, %ebx
movl $0x10003, %edi # imm = 0x10003
xorl %eax, %eax
callq 0x1d1a1
jmp 0x1c720
movl 0x8(%rdi), %edx
testl %edx, %edx
jle 0x1c708
movl 0xc(%rdi), %ecx
testl %ecx, %ecx
js 0x1c708
cmpl $0x1, %edx
sete %al
cmpl $0x6, %ecx
setge %sil
testb %sil, %al
jne 0x1c708
cmpl $0x2, %edx
sete %al
cmpl $0x2, %ecx
setge %sil
testb %sil, %al
jne 0x1c708
cmpl $0x3, %edx
setne %al
cmpl $0x4, %ecx
setl %sil
orb %al, %sil
jne 0x1c734
movl 0xc(%rdi), %ecx
leaq 0x14a99(%rip), %rsi # 0x311ab
xorl %ebx, %ebx
movl $0x10004, %edi # imm = 0x10004
xorl %eax, %eax
callq 0x1d1a1
movl %ebx, %eax
popq %rbx
retq
leaq 0x14a66(%rip), %rsi # 0x31191
xorl %ebx, %ebx
movl $0x10003, %edi # imm = 0x10003
jmp 0x1c6bb
movl 0x1c(%rdi), %eax
leal -0x32001(%rax), %esi
cmpl $0x2, %esi
jae 0x1c760
cmpl $0x3, %edx
sete %al
cmpl $0x2, %ecx
setl %cl
cmpl $0x3, %edx
jl 0x1c757
andb %cl, %al
je 0x1c764
leaq 0x14a88(%rip), %rsi # 0x311e6
jmp 0x1c776
testl %eax, %eax
jne 0x1c7cb
cmpl $0x2, %edx
jg 0x1c782
cmpl $0x0, 0x10(%rdi)
je 0x1c782
leaq 0x14ab3(%rip), %rsi # 0x31229
xorl %ebx, %ebx
movl $0x10004, %edi # imm = 0x10004
jmp 0x1c6a4
movl 0x20(%rdi), %edx
leal -0x31001(%rdx), %eax
cmpl $0x2, %eax
jb 0x1c794
testl %edx, %edx
jne 0x1c7bf
movl 0x24(%rdi), %edx
movl $0x1, %ebx
leal -0x35001(%rdx), %eax
cmpl $0x2, %eax
jb 0x1c720
testl %edx, %edx
je 0x1c720
leaq 0x14afd(%rip), %rsi # 0x312b7
jmp 0x1c6b4
leaq 0x14aca(%rip), %rsi # 0x31290
jmp 0x1c6b4
leaq 0x149f6(%rip), %rsi # 0x311c8
xorl %ebx, %ebx
movl $0x10003, %edi # imm = 0x10003
movl %eax, %edx
jmp 0x1c6bb
|
/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
};
window->context.source = ctxconfig->source;
window->context.client = GLFW_OPENGL_API;
previous = _glfwPlatformGetTls(&_glfw.contextSlot);
glfwMakeContextCurrent((GLFWwindow*) window);
window->context.GetIntegerv = (PFNGLGETINTEGERVPROC)
window->context.getProcAddress("glGetIntegerv");
window->context.GetString = (PFNGLGETSTRINGPROC)
window->context.getProcAddress("glGetString");
if (!window->context.GetIntegerv || !window->context.GetString)
{
_glfwInputError(GLFW_PLATFORM_ERROR, "Entry point retrieval is broken");
glfwMakeContextCurrent((GLFWwindow*) previous);
return GLFW_FALSE;
}
version = (const char*) window->context.GetString(GL_VERSION);
if (!version)
{
if (ctxconfig->client == GLFW_OPENGL_API)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"OpenGL version string retrieval is broken");
}
else
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"OpenGL ES version string retrieval is broken");
}
glfwMakeContextCurrent((GLFWwindow*) previous);
return GLFW_FALSE;
}
for (i = 0; prefixes[i]; i++)
{
const size_t length = strlen(prefixes[i]);
if (strncmp(version, prefixes[i], length) == 0)
{
version += length;
window->context.client = GLFW_OPENGL_ES_API;
break;
}
}
if (!sscanf(version, "%d.%d.%d",
&window->context.major,
&window->context.minor,
&window->context.revision))
{
if (window->context.client == GLFW_OPENGL_API)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"No version found in OpenGL version string");
}
else
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"No version found in OpenGL ES version string");
}
glfwMakeContextCurrent((GLFWwindow*) previous);
return GLFW_FALSE;
}
if (window->context.major < ctxconfig->major ||
(window->context.major == ctxconfig->major &&
window->context.minor < ctxconfig->minor))
{
// The desired OpenGL version is greater than the actual version
// This only happens if the machine lacks {GLX|WGL}_ARB_create_context
// /and/ the user has requested an OpenGL version greater than 1.0
// For API consistency, we emulate the behavior of the
// {GLX|WGL}_ARB_create_context extension and fail here
if (window->context.client == GLFW_OPENGL_API)
{
_glfwInputError(GLFW_VERSION_UNAVAILABLE,
"Requested OpenGL version %i.%i, got version %i.%i",
ctxconfig->major, ctxconfig->minor,
window->context.major, window->context.minor);
}
else
{
_glfwInputError(GLFW_VERSION_UNAVAILABLE,
"Requested OpenGL ES version %i.%i, got version %i.%i",
ctxconfig->major, ctxconfig->minor,
window->context.major, window->context.minor);
}
glfwMakeContextCurrent((GLFWwindow*) previous);
return GLFW_FALSE;
}
if (window->context.major >= 3)
{
// OpenGL 3.0+ uses a different function for extension string retrieval
// We cache it here instead of in glfwExtensionSupported mostly to alert
// users as early as possible that their build may be broken
window->context.GetStringi = (PFNGLGETSTRINGIPROC)
window->context.getProcAddress("glGetStringi");
if (!window->context.GetStringi)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Entry point retrieval is broken");
glfwMakeContextCurrent((GLFWwindow*) previous);
return GLFW_FALSE;
}
}
if (window->context.client == GLFW_OPENGL_API)
{
// Read back context flags (OpenGL 3.0 and above)
if (window->context.major >= 3)
{
GLint flags;
window->context.GetIntegerv(GL_CONTEXT_FLAGS, &flags);
if (flags & GL_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT)
window->context.forward = GLFW_TRUE;
if (flags & GL_CONTEXT_FLAG_DEBUG_BIT)
window->context.debug = GLFW_TRUE;
else if (glfwExtensionSupported("GL_ARB_debug_output") &&
ctxconfig->debug)
{
// HACK: This is a workaround for older drivers (pre KHR_debug)
// not setting the debug bit in the context flags for
// debug contexts
window->context.debug = GLFW_TRUE;
}
if (flags & GL_CONTEXT_FLAG_NO_ERROR_BIT_KHR)
window->context.noerror = GLFW_TRUE;
}
// Read back OpenGL context profile (OpenGL 3.2 and above)
if (window->context.major >= 4 ||
(window->context.major == 3 && window->context.minor >= 2))
{
GLint mask;
window->context.GetIntegerv(GL_CONTEXT_PROFILE_MASK, &mask);
if (mask & GL_CONTEXT_COMPATIBILITY_PROFILE_BIT)
window->context.profile = GLFW_OPENGL_COMPAT_PROFILE;
else if (mask & GL_CONTEXT_CORE_PROFILE_BIT)
window->context.profile = GLFW_OPENGL_CORE_PROFILE;
else if (glfwExtensionSupported("GL_ARB_compatibility"))
{
// HACK: This is a workaround for the compatibility profile bit
// not being set in the context flags if an OpenGL 3.2+
// context was created without having requested a specific
// version
window->context.profile = GLFW_OPENGL_COMPAT_PROFILE;
}
}
// Read back robustness strategy
if (glfwExtensionSupported("GL_ARB_robustness"))
{
// NOTE: We avoid using the context flags for detection, as they are
// only present from 3.0 while the extension applies from 1.1
GLint strategy;
window->context.GetIntegerv(GL_RESET_NOTIFICATION_STRATEGY_ARB,
&strategy);
if (strategy == GL_LOSE_CONTEXT_ON_RESET_ARB)
window->context.robustness = GLFW_LOSE_CONTEXT_ON_RESET;
else if (strategy == GL_NO_RESET_NOTIFICATION_ARB)
window->context.robustness = GLFW_NO_RESET_NOTIFICATION;
}
}
else
{
// Read back robustness strategy
if (glfwExtensionSupported("GL_EXT_robustness"))
{
// NOTE: The values of these constants match those of the OpenGL ARB
// one, so we can reuse them here
GLint strategy;
window->context.GetIntegerv(GL_RESET_NOTIFICATION_STRATEGY_ARB,
&strategy);
if (strategy == GL_LOSE_CONTEXT_ON_RESET_ARB)
window->context.robustness = GLFW_LOSE_CONTEXT_ON_RESET;
else if (strategy == GL_NO_RESET_NOTIFICATION_ARB)
window->context.robustness = GLFW_NO_RESET_NOTIFICATION;
}
}
if (glfwExtensionSupported("GL_KHR_context_flush_control"))
{
GLint behavior;
window->context.GetIntegerv(GL_CONTEXT_RELEASE_BEHAVIOR, &behavior);
if (behavior == GL_NONE)
window->context.release = GLFW_RELEASE_BEHAVIOR_NONE;
else if (behavior == GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH)
window->context.release = GLFW_RELEASE_BEHAVIOR_FLUSH;
}
// Clearing the front buffer to black to avoid garbage pixels left over from
// previous uses of our bit of VRAM
{
PFNGLCLEARPROC glClear = (PFNGLCLEARPROC)
window->context.getProcAddress("glClear");
glClear(GL_COLOR_BUFFER_BIT);
window->context.swapBuffers(window);
}
glfwMakeContextCurrent((GLFWwindow*) previous);
return GLFW_TRUE;
}
|
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
movq %r14, %rdi
callq 0x1cd6f
leaq 0x11c56(%rip), %rdi # 0x2e665
callq *0x260(%r14)
movq %rax, 0x230(%r14)
leaq 0x1181b(%rip), %rdi # 0x2e23f
callq *0x260(%r14)
movq %rax, 0x238(%r14)
cmpq $0x0, 0x230(%r14)
sete %cl
testq %rax, %rax
sete %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0x1ca56
leaq 0x1488e(%rip), %rsi # 0x312df
jmp 0x1cb5e
movl $0x1f02, %edi # imm = 0x1F02
callq *%rax
testq %rax, %rax
je 0x1cb44
movq %rax, %rbx
movq %r12, 0x10(%rsp)
movq %r15, 0x8(%rsp)
xorl %ebp, %ebp
leaq 0x3b294(%rip), %r15 # 0x57d10
movq (%rbp,%r15), %r13
movq %r13, %rdi
callq 0x14230
movq %rax, %r12
movq %rbx, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x14250
testl %eax, %eax
jne 0x1caac
addq %r12, %rbx
movl $0x30002, 0x1f8(%r14) # imm = 0x30002
testl %eax, %eax
je 0x1cabd
leaq 0x8(%rbp), %rax
cmpq $0x10, %rbp
movq %rax, %rbp
jne 0x1ca7c
leaq 0x200(%r14), %r13
leaq 0x204(%r14), %r12
leaq 0x208(%r14), %r8
leaq 0x1487d(%rip), %rsi # 0x31356
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r13, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x14520
testl %eax, %eax
je 0x1cb85
movl (%r13), %r8d
movq 0x10(%rsp), %rbp
movl 0x8(%rbp), %edx
cmpl %edx, %r8d
movq 0x8(%rsp), %r15
jge 0x1cbb5
movl 0x204(%r14), %r9d
cmpl $0x30001, 0x1f8(%r14) # imm = 0x30001
movl 0xc(%rbp), %ecx
leaq 0x1488d(%rip), %rax # 0x313b6
leaq 0x148b8(%rip), %rsi # 0x313e8
cmoveq %rax, %rsi
xorl %ebp, %ebp
movl $0x10007, %edi # imm = 0x10007
xorl %eax, %eax
callq 0x1d1a1
jmp 0x1cb6c
cmpl $0x30001, (%r12) # imm = 0x30001
leaq 0x147ac(%rip), %rax # 0x312ff
leaq 0x147cf(%rip), %rsi # 0x31329
cmoveq %rax, %rsi
xorl %ebp, %ebp
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
callq 0x1d1a1
movq %r15, %rdi
callq 0x1cd6f
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x30001, 0x1f8(%r14) # imm = 0x30001
leaq 0x147c8(%rip), %rax # 0x3135f
leaq 0x147eb(%rip), %rsi # 0x31389
cmoveq %rax, %rsi
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
callq 0x1d1a1
movq 0x8(%rsp), %r15
jmp 0x1cb6c
jne 0x1cbc4
movl (%r12), %eax
cmpl 0xc(%rbp), %eax
jl 0x1cb0d
cmpl $0x3, %r8d
jl 0x1cbe8
leaq 0x138fe(%rip), %rdi # 0x304cf
callq *0x260(%r14)
movq %rax, 0x228(%r14)
testq %rax, %rax
je 0x1ca4a
cmpl $0x30001, 0x1f8(%r14) # imm = 0x30001
jne 0x1cca9
cmpl $0x3, (%r13)
jl 0x1cc5c
leaq 0x4(%rsp), %rbx
movl $0x821e, %edi # imm = 0x821E
movq %rbx, %rsi
callq *0x230(%r14)
movl (%rbx), %eax
testb $0x1, %al
je 0x1cc25
movl $0x1, 0x20c(%r14)
testb $0x2, %al
jne 0x1cc3f
leaq 0x147ed(%rip), %rdi # 0x3141d
callq 0x1ce05
testl %eax, %eax
je 0x1cc4a
cmpl $0x0, 0x14(%rbp)
je 0x1cc4a
movl $0x1, 0x210(%r14)
testb $0x8, 0x4(%rsp)
je 0x1cc5c
movl $0x1, 0x214(%r14)
cmpl $0x3, (%r13)
jle 0x1ccb2
leaq 0x4(%rsp), %rbx
movl $0x9126, %edi # imm = 0x9126
movq %rbx, %rsi
callq *0x230(%r14)
movl (%rbx), %eax
movl $0x32002, %ecx # imm = 0x32002
testb $0x2, %al
jne 0x1cca0
movl $0x32001, %ecx # imm = 0x32001
testb $0x1, %al
jne 0x1cca0
leaq 0x1479f(%rip), %rdi # 0x31431
callq 0x1ce05
movl $0x32002, %ecx # imm = 0x32002
testl %eax, %eax
je 0x1ccbb
movl %ecx, 0x218(%r14)
jmp 0x1ccbb
leaq 0x14796(%rip), %rdi # 0x31446
jmp 0x1ccc2
jne 0x1ccbb
cmpl $0x2, (%r12)
jge 0x1cc63
leaq 0x14218(%rip), %rdi # 0x30eda
callq 0x1ce05
testl %eax, %eax
je 0x1cd02
leaq 0x4(%rsp), %rbx
movl $0x8256, %edi # imm = 0x8256
movq %rbx, %rsi
callq *0x230(%r14)
movl (%rbx), %eax
cmpl $0x8252, %eax # imm = 0x8252
je 0x1ccf6
cmpl $0x8261, %eax # imm = 0x8261
jne 0x1cd02
movl $0x31001, %eax # imm = 0x31001
jmp 0x1ccfb
movl $0x31002, %eax # imm = 0x31002
movl %eax, 0x21c(%r14)
leaq 0x34622(%rip), %rdi # 0x5132b
callq 0x1ce05
testl %eax, %eax
je 0x1cd46
leaq 0x4(%rsp), %rbx
movl $0x82fb, %edi # imm = 0x82FB
movq %rbx, %rsi
callq *0x230(%r14)
movl (%rbx), %eax
testl %eax, %eax
je 0x1cd3a
cmpl $0x82fc, %eax # imm = 0x82FC
jne 0x1cd46
movl $0x35001, %eax # imm = 0x35001
jmp 0x1cd3f
movl $0x35002, %eax # imm = 0x35002
movl %eax, 0x220(%r14)
leaq 0x1156d(%rip), %rdi # 0x2e2ba
callq *0x260(%r14)
movl $0x4000, %edi # imm = 0x4000
callq *%rax
movq %r14, %rdi
callq *0x248(%r14)
movl $0x1, %ebp
jmp 0x1cb6c
|
/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 + strlen(string);
if (where == start || *(where - 1) == ' ')
{
if (*terminator == ' ' || *terminator == '\0')
break;
}
start = terminator;
}
return GLFW_TRUE;
}
|
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 0x1cfee
xorl %ecx, %ecx
movq %rax, %r14
jmp 0x1cfee
movl $0x1, %ecx
testl %ecx, %ecx
je 0x1cfab
cmpl $0x2, %ecx
jne 0x1cffe
movl $0x1, %eax
jmp 0x1d000
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
|
/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");
return;
}
window->context.swapInterval(interval);
}
|
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, %esi
jmp 0x1d0d5
leaq 0x144af(%rip), %rsi # 0x3157f
movl $0x10002, %edi # imm = 0x10002
xorl %eax, %eax
popq %rbx
jmp 0x1d1a1
|
/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 query entry point without a current OpenGL or OpenGL ES context");
return NULL;
}
return window->context.getProcAddress(procname);
}
|
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 # imm = 0x10001
xorl %esi, %esi
jmp 0x1d127
leaq 0x145af(%rip), %rsi # 0x316d1
movl $0x10002, %edi # imm = 0x10002
xorl %eax, %eax
callq 0x1d1a1
xorl %eax, %eax
popq %rbx
retq
leaq 0x1455b(%rip), %rdi # 0x31694
leaq 0x14371(%rip), %rsi # 0x314b1
leaq 0x1455e(%rip), %rcx # 0x316a5
movl $0x2ea, %edx # imm = 0x2EA
callq 0x14320
nopl (%rax)
|
/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)
{
code = error->code;
error->code = GLFW_NO_ERROR;
if (description && code)
*description = error->description;
}
return code;
}
|
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
testq %rbx, %rbx
setne %dl
movl 0x8(%rax), %ecx
movl $0x0, 0x8(%rax)
testl %ecx, %ecx
setne %sil
andb %dl, %sil
cmpb $0x1, %sil
jne 0x1d7f0
addq $0xc, %rax
movq %rax, (%rbx)
jmp 0x1d7f0
xorl %ecx, %ecx
movl %ecx, %eax
popq %rbx
retq
|
/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->callbacks.charmods((GLFWwindow*) window, codepoint, mods);
if (plain)
{
if (window->callbacks.character)
window->callbacks.character((GLFWwindow*) window, codepoint);
}
}
|
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, %rdi
movl %ebx, %esi
movl %eax, %edx
callq *%rcx
testl %ebp, %ebp
je 0x1d8dc
movq 0x328(%r14), %rax
testq %rax, %rax
je 0x1d8dc
movq %r14, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
popq %rbx
popq %r14
popq %rbp
retq
|
/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((GLFWwindow*) window, xpos, ypos);
}
|
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);
return GLFW_RELEASE;
}
if (window->keys[key] == _GLFW_STICK)
{
// Sticky mode: release key now
window->keys[key] = GLFW_RELEASE;
return GLFW_PRESS;
}
return (int) window->keys[key];
}
|
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, %eax
callq 0x1d1a1
jmp 0x1dfb0
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
callq 0x1d1a1
jmp 0x1dfb0
movl %edx, %eax
movsbl 0x80(%rdi,%rax), %ebx
cmpl $0x3, %ebx
jne 0x1dfb0
movb $0x0, 0x80(%rdi,%rax)
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
retq
leaq 0x134e7(%rip), %rdi # 0x314a2
leaq 0x2e8de(%rip), %rsi # 0x4c8a0
leaq 0x2ea03(%rip), %rcx # 0x4c9cc
movl $0x278, %edx # imm = 0x278
callq 0x14320
|
/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'))
{
char line[1024];
const size_t length = strcspn(c, "\r\n");
if (length < sizeof(line))
{
_GLFWmapping mapping = {{0}};
memcpy(line, c, length);
line[length] = '\0';
if (parseMapping(&mapping, line))
{
_GLFWmapping* previous = findMapping(mapping.guid);
if (previous)
*previous = mapping;
else
{
_glfw.mappingCount++;
_glfw.mappings =
realloc(_glfw.mappings,
sizeof(_GLFWmapping) * _glfw.mappingCount);
_glfw.mappings[_glfw.mappingCount - 1] = mapping;
}
}
}
c += length;
}
else
{
c += strcspn(c, "\r\n");
c += strspn(c, "\r\n");
}
}
for (jid = 0; jid <= GLFW_JOYSTICK_LAST; jid++)
{
_GLFWjoystick* js = _glfw.joysticks + jid;
if (js->present)
js->mapping = findValidMapping(js);
}
return GLFW_TRUE;
}
|
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), %ecx
cmpb $0xa, %cl
jb 0x1ece5
movzbl %al, %eax
addl $-0x41, %eax
cmpl $0x25, %eax
ja 0x1f22f
movabsq $0x3f0000003f, %rcx # imm = 0x3F0000003F
btq %rax, %rcx
jae 0x1f22f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14060
movq %rax, %r13
cmpq $0x3ff, %rax # imm = 0x3FF
ja 0x1f21d
movl $0xf5, %edx
leaq 0x17b(%rsp), %rdi
xorl %esi, %esi
callq 0x142b0
leaq 0x270(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x143d0
movb $0x0, 0x270(%rsp,%r13)
movq %r14, (%rsp)
leaq 0x2e320(%rip), %rax # 0x4d05d
movq %rax, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
leaq 0x30244(%rip), %rax # 0x4ef96
movq %rax, 0x20(%rsp)
leaq 0x21c(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0xfc5a(%rip), %rax # 0x2e9c5
movq %rax, 0x30(%rsp)
leaq 0x220(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x11db0(%rip), %rax # 0x30b34
movq %rax, 0x40(%rsp)
leaq 0x224(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x323e3(%rip), %rax # 0x51180
movq %rax, 0x50(%rsp)
leaq 0x228(%rsp), %rax
movq %rax, 0x58(%rsp)
leaq 0x115c1(%rip), %rax # 0x30377
movq %rax, 0x60(%rsp)
leaq 0x234(%rsp), %rax
movq %rax, 0x68(%rsp)
leaq 0x2e297(%rip), %rax # 0x4d066
movq %rax, 0x70(%rsp)
leaq 0x238(%rsp), %rax
movq %rax, 0x78(%rsp)
leaq 0x2e284(%rip), %rax # 0x4d06c
movq %rax, 0x80(%rsp)
leaq 0x23c(%rsp), %rax
movq %rax, 0x88(%rsp)
leaq 0x2e26b(%rip), %rax # 0x4d072
movq %rax, 0x90(%rsp)
leaq 0x22c(%rsp), %rax
movq %rax, 0x98(%rsp)
leaq 0x2e259(%rip), %rax # 0x4d07f
movq %rax, 0xa0(%rsp)
leaq 0x230(%rsp), %rax
movq %rax, 0xa8(%rsp)
leaq 0x2e248(%rip), %rax # 0x4d08d
movq %rax, 0xb0(%rsp)
leaq 0x240(%rsp), %rax
movq %rax, 0xb8(%rsp)
leaq 0x2e233(%rip), %rax # 0x4d097
movq %rax, 0xc0(%rsp)
leaq 0x244(%rsp), %rax
movq %rax, 0xc8(%rsp)
leaq 0x2e21f(%rip), %rax # 0x4d0a2
movq %rax, 0xd0(%rsp)
leaq 0x248(%rsp), %rax
movq %rax, 0xd8(%rsp)
leaq 0x2e205(%rip), %rax # 0x4d0a7
movq %rax, 0xe0(%rsp)
leaq 0x24c(%rsp), %rax
movq %rax, 0xe8(%rsp)
leaq 0x2e1ee(%rip), %rax # 0x4d0af
movq %rax, 0xf0(%rsp)
leaq 0x250(%rsp), %rax
movq %rax, 0xf8(%rsp)
leaq 0x2e1d6(%rip), %rax # 0x4d0b6
movq %rax, 0x100(%rsp)
leaq 0x254(%rsp), %rax
movq %rax, 0x108(%rsp)
leaq 0x2e1be(%rip), %rax # 0x4d0bd
movq %rax, 0x110(%rsp)
leaq 0x268(%rsp), %rax
movq %rax, 0x118(%rsp)
leaq 0x2e1ab(%rip), %rax # 0x4d0c9
movq %rax, 0x120(%rsp)
leaq 0x26c(%rsp), %rax
movq %rax, 0x128(%rsp)
leaq 0x2e199(%rip), %rax # 0x4d0d6
movq %rax, 0x130(%rsp)
leaq 0x258(%rsp), %rax
movq %rax, 0x138(%rsp)
leaq 0x2e180(%rip), %rax # 0x4d0dc
movq %rax, 0x140(%rsp)
leaq 0x25c(%rsp), %rax
movq %rax, 0x148(%rsp)
leaq 0x2e167(%rip), %rax # 0x4d0e2
movq %rax, 0x150(%rsp)
leaq 0x260(%rsp), %rax
movq %rax, 0x158(%rsp)
leaq 0x2e14f(%rip), %rax # 0x4d0e9
movq %rax, 0x160(%rsp)
leaq 0x264(%rsp), %rax
movq %rax, 0x168(%rsp)
movq %r14, %rdi
leaq 0x2d4a3(%rip), %rsi # 0x4c45f
callq 0x14060
cmpq $0x20, %rax
jne 0x1f201
cmpb $0x2c, 0x290(%rsp)
jne 0x1f201
movaps 0x270(%rsp), %xmm0
movaps 0x280(%rsp), %xmm1
leaq 0x1fb(%rsp), %rax
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq 0x291(%rsp), %rdi
movq %rdi, (%rsp)
leaq 0x2d454(%rip), %rsi # 0x4c45f
callq 0x14060
cmpq $0x7f, %rax
ja 0x1f201
cmpb $0x2c, 0x291(%rsp,%rax)
jne 0x1f201
movq %rax, %r15
leaq 0x291(%rsp), %rsi
addq %rsi, %r15
leaq 0x17b(%rsp), %rdi
movq %rax, %rdx
callq 0x143d0
incq %r15
movq %r15, (%rsp)
movzbl (%r15), %eax
cmpl $0x2d, %eax
je 0x1f20f
cmpl $0x2b, %eax
je 0x1f20f
testl %eax, %eax
je 0x1f253
movl $0x8, %r14d
movq 0x8(%rsp,%r14), %rbp
movq %rbp, %rdi
callq 0x14230
movq %rax, %r12
movq %r15, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x14250
testl %eax, %eax
jne 0x1f09a
cmpb $0x3a, (%r15,%r12)
je 0x1f0dd
addq $0x10, %r14
cmpq $0x168, %r14 # imm = 0x168
jne 0x1f071
movq (%rsp), %r15
movq %r15, %rdi
leaq 0x2d3aa(%rip), %r14 # 0x4c45f
movq %r14, %rsi
callq 0x14060
movq %rax, %r12
addq %r15, %r12
movq %r12, (%rsp)
movq %r12, %rdi
movq %r14, %rsi
callq 0x141f0
movq %rax, %r15
addq %r12, %r15
jmp 0x1f049
leaq (%r15,%r12), %rdi
incq %rdi
movq %rdi, (%rsp)
movq 0x10(%rsp,%r14), %rbp
testq %rbp, %rbp
je 0x1f11a
addq %r12, %r15
movzbl (%rdi), %eax
cmpl $0x2d, %eax
je 0x1f138
movl $0x1, %r12d
cmpl $0x2b, %eax
jne 0x1f14d
addq $0x2, %r15
movq %r15, (%rsp)
movl $0x0, 0xc(%rsp)
jmp 0x1f155
movl $0x5, %edx
leaq 0x2dfca(%rip), %rsi # 0x4d0f0
callq 0x14250
testl %eax, %eax
je 0x1f0a7
jmp 0x1f20f
movl $0xffffffff, 0xc(%rsp) # imm = 0xFFFFFFFF
addq $0x2, %r15
movq %r15, (%rsp)
xorl %r12d, %r12d
jmp 0x1f155
movl $0xffffffff, 0xc(%rsp) # imm = 0xFFFFFFFF
movq (%rsp), %rdi
movzbl (%rdi), %eax
cmpl $0x61, %eax
je 0x1f17d
cmpl $0x68, %eax
je 0x1f176
cmpl $0x62, %eax
jne 0x1f0a7
movb $0x2, %al
xorl %r14d, %r14d
jmp 0x1f182
movb $0x3, %al
movb $0x1, %r14b
jmp 0x1f182
xorl %r14d, %r14d
movb $0x1, %al
movb %al, (%rbp)
incq %rdi
movq %rsp, %rsi
movl $0xa, %edx
callq 0x14150
movq %rax, %r15
testb %r14b, %r14b
je 0x1f1b8
movq (%rsp), %rdi
incq %rdi
movq %rsp, %rsi
movl $0xa, %edx
callq 0x14150
shlq $0x4, %r15
orq %rax, %r15
movb %r15b, 0x1(%rbp)
cmpb $0x1, (%rbp)
jne 0x1f0a7
movl %r12d, %ecx
movl 0xc(%rsp), %esi
subl %esi, %ecx
movl $0x2, %eax
xorl %edx, %edx
divl %ecx
movb %al, 0x2(%rbp)
addl %esi, %r12d
movl %r12d, %ecx
negb %cl
movb %cl, 0x3(%rbp)
movq (%rsp), %rcx
cmpb $0x7e, (%rcx)
jne 0x1f0a7
negb %al
movb %al, 0x2(%rbp)
movb %r12b, 0x3(%rbp)
jmp 0x1f0a7
movl $0x10004, %edi # imm = 0x10004
xorl %esi, %esi
xorl %eax, %eax
callq 0x1d1a1
leaq 0x732aa(%rip), %r12 # 0x924c0
leaq 0x2dd21(%rip), %r14 # 0x4cf3e
addq %r13, %rbx
movb (%rbx), %al
testb %al, %al
jne 0x1ecba
jmp 0x1f30a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14060
movq %rax, %r15
addq %rbx, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x141f0
movq %rax, %rbx
addq %r15, %rbx
jmp 0x1f220
movl $0x80, %eax
leaq 0x73261(%rip), %r12 # 0x924c0
movb 0x17b(%rsp,%rax), %cl
leal -0x41(%rcx), %edx
cmpb $0x5, %dl
ja 0x1f278
orb $0x20, %cl
movb %cl, 0x17b(%rsp,%rax)
incq %rax
cmpq $0xa0, %rax
jne 0x1f25f
leaq 0x1fb(%rsp), %r14
movq %r14, %rdi
callq 0x2d625
movq %r14, %rdi
callq 0x1f389
testq %rax, %rax
je 0x1f2aa
movl $0xf5, %edx
movq %rax, %rdi
jmp 0x1f2f8
movslq 0x1fe10(%r12), %rax
incq %rax
movl %eax, 0x1fe10(%r12)
movq 0x1fe08(%r12), %rdi
imulq $0xf5, %rax, %rsi
callq 0x148d0
movq %rax, 0x1fe08(%r12)
movslq 0x1fe10(%r12), %rcx
imulq $0xf5, %rcx, %rcx
leaq (%rax,%rcx), %rdi
addq $-0xf5, %rdi
movl $0xf5, %edx
leaq 0x17b(%rsp), %rsi
callq 0x143d0
jmp 0x1f216
xorl %r14d, %r14d
cmpl $0x0, 0x408(%r12,%r14)
je 0x1f32f
leaq (%r12,%r14), %rbx
addq $0x408, %rbx # imm = 0x408
movq %rbx, %rdi
callq 0x1db23
movq %rax, 0x70(%rbx)
addq $0x1fa0, %r14 # imm = 0x1FA0
cmpq $0x1fa00, %r14 # imm = 0x1FA00
jne 0x1f30d
movl $0x1, %ebx
jmp 0x1f356
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
callq 0x1d1a1
movl %ebx, %eax
addq $0x678, %rsp # imm = 0x678
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2db92(%rip), %rdi # 0x4cf03
leaq 0x2d528(%rip), %rsi # 0x4c8a0
leaq 0x2db93(%rip), %rcx # 0x4cf12
movl $0x460, %edx # imm = 0x460
callq 0x14320
|
/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
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/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 = monitor->widthMM;
if (heightMM)
*heightMM = monitor->heightMM;
}
|
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, (%rdx)
retq
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x1d1a1
pushq %rax
leaq 0x2d0f3(%rip), %rdi # 0x4d188
leaq 0x2d064(%rip), %rsi # 0x4d100
leaq 0x2d170(%rip), %rcx # 0x4d213
movl $0x16b, %edx # imm = 0x16B
callq 0x14320
|
/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();
_glfwPlatformGetMonitorContentScale(monitor, xscale, yscale);
}
|
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), %rdi # 0x4d188
leaq 0x2d00a(%rip), %rsi # 0x4d100
leaq 0x2d153(%rip), %rcx # 0x4d250
movl $0x17e, %edx # imm = 0x17E
callq 0x14320
|
/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 = monitor->modeCount;
return monitor->modes;
}
|
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 0x20264
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
callq 0x1d1a1
jmp 0x20264
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2cf12(%rip), %rdi # 0x4d188
leaq 0x2ce83(%rip), %rsi # 0x4d100
leaq 0x2d0a0(%rip), %rcx # 0x4d324
movl $0x1ae, %edx # imm = 0x1AE
callq 0x14320
leaq 0x2cb56(%rip), %rdi # 0x4cdeb
leaq 0x2ce64(%rip), %rsi # 0x4d100
leaq 0x2d081(%rip), %rcx # 0x4d324
movl $0x1af, %edx # imm = 0x1AF
callq 0x14320
|
/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))
return NULL;
return &monitor->currentRamp;
}
|
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, %ebx
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
callq 0x1d1a1
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2cc79(%rip), %rdi # 0x4d188
leaq 0x2cbea(%rip), %rsi # 0x4d100
leaq 0x2cee0(%rip), %rcx # 0x4d3fd
movl $0x1f9, %edx # imm = 0x1F9
callq 0x14320
|
/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)
_glfw.vk.handle = _glfw_dlopen("vulkan-1.dll");
#elif defined(_GLFW_COCOA)
_glfw.vk.handle = _glfw_dlopen("libvulkan.1.dylib");
#else
_glfw.vk.handle = _glfw_dlopen("libvulkan.so.1");
#endif
if (!_glfw.vk.handle)
{
if (mode == _GLFW_REQUIRE_LOADER)
_glfwInputError(GLFW_API_UNAVAILABLE, "Vulkan: Loader not found");
return GLFW_FALSE;
}
_glfw.vk.GetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)
_glfw_dlsym(_glfw.vk.handle, "vkGetInstanceProcAddr");
if (!_glfw.vk.GetInstanceProcAddr)
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"Vulkan: Loader does not export vkGetInstanceProcAddr");
_glfwTerminateVulkan();
return GLFW_FALSE;
}
_glfw.vk.EnumerateInstanceExtensionProperties = (PFN_vkEnumerateInstanceExtensionProperties)
vkGetInstanceProcAddr(NULL, "vkEnumerateInstanceExtensionProperties");
if (!_glfw.vk.EnumerateInstanceExtensionProperties)
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"Vulkan: Failed to retrieve vkEnumerateInstanceExtensionProperties");
_glfwTerminateVulkan();
return GLFW_FALSE;
}
#endif // _GLFW_VULKAN_STATIC
err = vkEnumerateInstanceExtensionProperties(NULL, &count, NULL);
if (err)
{
// NOTE: This happens on systems with a loader but without any Vulkan ICD
if (mode == _GLFW_REQUIRE_LOADER)
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"Vulkan: Failed to query instance extension count: %s",
_glfwGetVulkanResultString(err));
}
_glfwTerminateVulkan();
return GLFW_FALSE;
}
ep = calloc(count, sizeof(VkExtensionProperties));
err = vkEnumerateInstanceExtensionProperties(NULL, &count, ep);
if (err)
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"Vulkan: Failed to query instance extensions: %s",
_glfwGetVulkanResultString(err));
free(ep);
_glfwTerminateVulkan();
return GLFW_FALSE;
}
for (i = 0; i < count; i++)
{
if (strcmp(ep[i].extensionName, "VK_KHR_surface") == 0)
_glfw.vk.KHR_surface = GLFW_TRUE;
#if defined(_GLFW_WIN32)
else if (strcmp(ep[i].extensionName, "VK_KHR_win32_surface") == 0)
_glfw.vk.KHR_win32_surface = GLFW_TRUE;
#elif defined(_GLFW_COCOA)
else if (strcmp(ep[i].extensionName, "VK_MVK_macos_surface") == 0)
_glfw.vk.MVK_macos_surface = GLFW_TRUE;
#elif defined(_GLFW_X11)
else if (strcmp(ep[i].extensionName, "VK_KHR_xlib_surface") == 0)
_glfw.vk.KHR_xlib_surface = GLFW_TRUE;
else if (strcmp(ep[i].extensionName, "VK_KHR_xcb_surface") == 0)
_glfw.vk.KHR_xcb_surface = GLFW_TRUE;
#elif defined(_GLFW_WAYLAND)
else if (strcmp(ep[i].extensionName, "VK_KHR_wayland_surface") == 0)
_glfw.vk.KHR_wayland_surface = GLFW_TRUE;
#endif
}
free(ep);
_glfw.vk.available = GLFW_TRUE;
_glfwPlatformGetRequiredInstanceExtensions(_glfw.vk.extensions);
return GLFW_TRUE;
}
|
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 # 0x4d508
movl $0x1, %esi
callq 0x146a0
movq %rax, 0x1fe78(%rbx)
testq %rax, %rax
je 0x20744
leaq 0x2ce7e(%rip), %rsi # 0x4d54f
movq %rax, %rdi
callq 0x144f0
movq %rax, 0x1fe98(%rbx)
testq %rax, %rax
je 0x2076b
leaq 0x2ce90(%rip), %rsi # 0x4d580
xorl %r14d, %r14d
xorl %edi, %edi
callq *%rax
movq %rax, 0x1fe90(%rbx)
testq %rax, %rax
je 0x20777
leaq 0x4(%rsp), %rsi
xorl %edi, %edi
xorl %edx, %edx
callq *%rax
testl %eax, %eax
je 0x207a4
cmpl $0x2, %ebp
jne 0x20738
movl %eax, %edi
callq 0x208b4
leaq 0x2ce7e(%rip), %rsi # 0x4d5a7
movl $0x10006, %edi # imm = 0x10006
movq %rax, %rdx
xorl %eax, %eax
callq 0x1d1a1
movq 0x1fe78(%rbx), %rdi
xorl %r14d, %r14d
jmp 0x20791
xorl %r14d, %r14d
cmpl $0x2, %ebp
jne 0x20699
leaq 0x2cdc0(%rip), %rsi # 0x4d517
xorl %r14d, %r14d
movl $0x10006, %edi # imm = 0x10006
xorl %eax, %eax
callq 0x1d1a1
jmp 0x20699
leaq 0x2cdbe(%rip), %rsi # 0x4d530
xorl %r14d, %r14d
jmp 0x2077e
leaq 0x2cde7(%rip), %rsi # 0x4d565
movl $0x10006, %edi # imm = 0x10006
xorl %eax, %eax
callq 0x1d1a1
movq 0x1fe78(%rbx), %rdi
testq %rdi, %rdi
je 0x20699
callq 0x143b0
jmp 0x20699
leaq 0x4(%rsp), %r12
movl (%r12), %edi
movl $0x104, %esi # imm = 0x104
callq 0x14330
movq %rax, %r15
xorl %r14d, %r14d
xorl %edi, %edi
movq %r12, %rsi
movq %rax, %rdx
callq *0x1fe90(%rbx)
testl %eax, %eax
je 0x207f6
movl %eax, %edi
callq 0x208b4
leaq 0x2cdff(%rip), %rsi # 0x4d5dc
movl $0x10006, %edi # imm = 0x10006
movq %rax, %rdx
xorl %eax, %eax
callq 0x1d1a1
movq %r15, %rdi
callq 0x14600
jmp 0x2078a
movl 0x4(%rsp), %r13d
testq %r13, %r13
je 0x20870
leaq 0x2ce05(%rip), %r14 # 0x4d60c
leaq 0x2ce0d(%rip), %r12 # 0x4d61b
movq %r15, %rbp
movq %rbp, %rdi
movq %r14, %rsi
callq 0x146b0
testl %eax, %eax
je 0x2084e
movq %rbp, %rdi
movq %r12, %rsi
callq 0x146b0
testl %eax, %eax
je 0x2085a
movq %rbp, %rdi
leaq 0x2cdf6(%rip), %rsi # 0x4d62f
callq 0x146b0
testl %eax, %eax
jne 0x20864
movl $0x1, 0x1fea8(%rbx)
jmp 0x20864
movl $0x1, 0x1fea0(%rbx)
jmp 0x20864
movl $0x1, 0x1fea4(%rbx)
addq $0x104, %rbp # imm = 0x104
decq %r13
jne 0x20811
movq %r15, %rdi
callq 0x14600
movl $0x1, 0x1fe70(%rbx)
addq $0x1fe80, %rbx # imm = 0x1FE80
movq %rbx, %rdi
callq 0x29d0b
movl $0x1, %r14d
jmp 0x20699
|
/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;
assert(instance != VK_NULL_HANDLE);
assert(window != NULL);
assert(surface != NULL);
*surface = VK_NULL_HANDLE;
_GLFW_REQUIRE_INIT_OR_RETURN(VK_ERROR_INITIALIZATION_FAILED);
if (!_glfwInitVulkan(_GLFW_REQUIRE_LOADER))
return VK_ERROR_INITIALIZATION_FAILED;
if (!_glfw.vk.extensions[0])
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"Vulkan: Window surface creation extensions not found");
return VK_ERROR_EXTENSION_NOT_PRESENT;
}
if (window->context.client != GLFW_NO_API)
{
_glfwInputError(GLFW_INVALID_VALUE,
"Vulkan: Window surface creation requires the window to have the client API set to GLFW_NO_API");
return VK_ERROR_NATIVE_WINDOW_IN_USE_KHR;
}
return _glfwPlatformCreateWindowSurface(instance, window, allocator, surface);
}
|
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
testl %eax, %eax
je 0x20c62
cmpq $0x0, 0x1fe80(%r13)
je 0x20c71
cmpl $0x0, 0x1f8(%r15)
je 0x20c8b
leaq 0x2d0ca(%rip), %rsi # 0x4dd0b
movl $0x10004, %edi # imm = 0x10004
xorl %eax, %eax
callq 0x1d1a1
movl $0xc46535ff, %eax # imm = 0xC46535FF
jmp 0x20c67
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
callq 0x1d1a1
movl $0xfffffffd, %eax # imm = 0xFFFFFFFD
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x2cfe4(%rip), %rsi # 0x4dc5c
movl $0x10006, %edi # imm = 0x10006
xorl %eax, %eax
callq 0x1d1a1
movl $0xfffffff9, %eax # imm = 0xFFFFFFF9
jmp 0x20c67
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x29e61
leaq 0x2cf27(%rip), %rdi # 0x4dbd3
leaq 0x2ce43(%rip), %rsi # 0x4daf6
leaq 0x2cfd7(%rip), %rcx # 0x4dc91
movl $0x12d, %edx # imm = 0x12D
callq 0x14320
leaq 0x107d7(%rip), %rdi # 0x314a2
leaq 0x2ce24(%rip), %rsi # 0x4daf6
leaq 0x2cfb8(%rip), %rcx # 0x4dc91
movl $0x12e, %edx # imm = 0x12E
callq 0x14320
leaq 0x2d011(%rip), %rdi # 0x4dcfb
leaq 0x2ce05(%rip), %rsi # 0x4daf6
leaq 0x2cf99(%rip), %rcx # 0x4dc91
movl $0x12f, %edx # imm = 0x12F
callq 0x14320
nop
|
/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 # 0x4ded2
leaq 0x2cb4d(%rip), %rcx # 0x4e088
movl $0x1ef, %edx # imm = 0x1EF
callq 0x14320
leaq 0x2c978(%rip), %rdi # 0x4dec4
leaq 0x2c97f(%rip), %rsi # 0x4ded2
leaq 0x2cb2e(%rip), %rcx # 0x4e088
movl $0x1f0, %edx # imm = 0x1F0
callq 0x14320
|
/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 0x2cabf(%rip), %rcx # 0x4e153
movl $0x213, %edx # imm = 0x213
callq 0x14320
|
/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), %rdi # 0x314a2
leaq 0x2c53e(%rip), %rsi # 0x4ded2
leaq 0x2c939(%rip), %rcx # 0x4e2d4
movl $0x287, %edx # imm = 0x287
callq 0x14320
|
/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 > 1.f)
{
_glfwInputError(GLFW_INVALID_VALUE, "Invalid window opacity %f", opacity);
return;
}
_glfwPlatformSetWindowOpacity(window, 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
cvtss2sd %xmm0, %xmm0
leaq 0x2c913(%rip), %rsi # 0x4e41a
movl $0x10004, %edi # imm = 0x10004
movb $0x1, %al
popq %rcx
jmp 0x1d1a1
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
popq %rcx
jmp 0x1d1a1
popq %rax
jmp 0x2825b
leaq 0xf972(%rip), %rdi # 0x314a2
leaq 0x2c39b(%rip), %rsi # 0x4ded2
leaq 0x2c87c(%rip), %rcx # 0x4e3ba
movl $0x2c1, %edx # imm = 0x2C1
callq 0x14320
leaq 0x2c89a(%rip), %rdi # 0x4e3e9
leaq 0x2c37c(%rip), %rsi # 0x4ded2
leaq 0x2c85d(%rip), %rcx # 0x4e3ba
movl $0x2c2, %edx # imm = 0x2C2
callq 0x14320
leaq 0x2c88e(%rip), %rdi # 0x4e3fc
leaq 0x2c35d(%rip), %rsi # 0x4ded2
leaq 0x2c83e(%rip), %rcx # 0x4e3ba
movl $0x2c3, %edx # imm = 0x2C3
callq 0x14320
leaq 0x2c87e(%rip), %rdi # 0x4e40b
leaq 0x2c33e(%rip), %rsi # 0x4ded2
leaq 0x2c81f(%rip), %rcx # 0x4e3ba
movl $0x2c4, %edx # imm = 0x2C4
callq 0x14320
|
/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:
return _glfwPlatformWindowIconified(window);
case GLFW_VISIBLE:
return _glfwPlatformWindowVisible(window);
case GLFW_MAXIMIZED:
return _glfwPlatformWindowMaximized(window);
case GLFW_HOVERED:
return _glfwPlatformWindowHovered(window);
case GLFW_FOCUS_ON_SHOW:
return window->focusOnShow;
case GLFW_TRANSPARENT_FRAMEBUFFER:
return _glfwPlatformFramebufferTransparent(window);
case GLFW_RESIZABLE:
return window->resizable;
case GLFW_DECORATED:
return window->decorated;
case GLFW_FLOATING:
return window->floating;
case GLFW_AUTO_ICONIFY:
return window->autoIconify;
case GLFW_CLIENT_API:
return window->context.client;
case GLFW_CONTEXT_CREATION_API:
return window->context.source;
case GLFW_CONTEXT_VERSION_MAJOR:
return window->context.major;
case GLFW_CONTEXT_VERSION_MINOR:
return window->context.minor;
case GLFW_CONTEXT_REVISION:
return window->context.revision;
case GLFW_CONTEXT_ROBUSTNESS:
return window->context.robustness;
case GLFW_OPENGL_FORWARD_COMPAT:
return window->context.forward;
case GLFW_OPENGL_DEBUG_CONTEXT:
return window->context.debug;
case GLFW_OPENGL_PROFILE:
return window->context.profile;
case GLFW_CONTEXT_RELEASE_BEHAVIOR:
return window->context.release;
case GLFW_CONTEXT_NO_ERROR:
return window->context.noerror;
}
_glfwInputError(GLFW_INVALID_ENUM, "Invalid window attribute 0x%08X", attrib);
return 0;
}
|
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 *%rax
movl 0x1f8(%rdi), %ebx
jmp 0x21e04
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
callq 0x1d1a1
movl %ebx, %eax
popq %rbx
retq
leaq 0x2c031(%rip), %rcx # 0x4de40
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
popq %rbx
jmp 0x27c12
leaq 0x2c73f(%rip), %rsi # 0x4e564
xorl %ebx, %ebx
movl $0x10003, %edi # imm = 0x10003
xorl %eax, %eax
callq 0x1d1a1
jmp 0x21e04
popq %rbx
jmp 0x27dc3
popq %rbx
jmp 0x27e72
popq %rbx
jmp 0x27ce4
movl 0x8(%rdi), %ebx
jmp 0x21e04
movl 0x14(%rdi), %ebx
jmp 0x21e04
movl 0xc(%rdi), %ebx
jmp 0x21e04
movl 0x18(%rdi), %ebx
jmp 0x21e04
popq %rbx
jmp 0x276ce
popq %rbx
jmp 0x27011
movl 0x10(%rdi), %ebx
jmp 0x21e04
movl 0x21c(%rdi), %ebx
jmp 0x21e04
movl 0x214(%rdi), %ebx
jmp 0x21e04
movl 0x204(%rdi), %ebx
jmp 0x21e04
movl 0x208(%rdi), %ebx
jmp 0x21e04
movl 0x218(%rdi), %ebx
jmp 0x21e04
movl 0x200(%rdi), %ebx
jmp 0x21e04
movl 0x20c(%rdi), %ebx
jmp 0x21e04
movl 0x210(%rdi), %ebx
jmp 0x21e04
movl 0x1fc(%rdi), %ebx
jmp 0x21e04
movl 0x220(%rdi), %ebx
jmp 0x21e04
leaq 0xf5ca(%rip), %rdi # 0x314a2
leaq 0x2bff3(%rip), %rsi # 0x4ded2
leaq 0x2c653(%rip), %rcx # 0x4e539
movl $0x324, %edx # imm = 0x324
callq 0x14320
|
/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->yhot = yhot;
unsigned char* source = (unsigned char*) image->pixels;
XcursorPixel* target = native->pixels;
for (i = 0; i < image->width * image->height; i++, target++, source += 4)
{
unsigned int alpha = source[3];
*target = (alpha << 24) |
((unsigned char) ((source[0] * alpha) / 255) << 16) |
((unsigned char) ((source[1] * alpha) / 255) << 8) |
((unsigned char) ((source[2] * alpha) / 255) << 0);
}
cursor = XcursorImageLoadCursor(_glfw.x11.display, native);
XcursorImageDestroy(native);
return cursor;
}
|
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, 0x14(%rax)
movl 0x4(%rbx), %eax
imull (%rbx), %eax
testl %eax, %eax
jle 0x22710
movq 0x20(%r14), %rax
movq 0x8(%rbx), %rcx
xorl %edx, %edx
movl $0xff, %esi
movzbl 0x3(%rcx,%rdx,4), %edi
movzbl (%rcx,%rdx,4), %r8d
imull %edi, %r8d
movzbl 0x1(%rcx,%rdx,4), %r9d
imull %edi, %r9d
movzbl 0x2(%rcx,%rdx,4), %r10d
imull %edi, %r10d
shll $0x18, %edi
imulq $0x1010102, %r8, %r8 # imm = 0x1010102
shrq $0x20, %r8
andl %esi, %r8d
shll $0x10, %r8d
orl %edi, %r8d
imulq $0x1010102, %r9, %rdi # imm = 0x1010102
shrq $0x20, %rdi
shll $0x8, %edi
movzwl %di, %edi
orl %r8d, %edi
imulq $0x1010102, %r10, %r8 # imm = 0x1010102
shrq $0x20, %r8
andl %esi, %r8d
orl %edi, %r8d
movl %r8d, (%rax,%rdx,4)
movl 0x4(%rbx), %edi
imull (%rbx), %edi
incq %rdx
cmpl %edi, %edx
jl 0x226a0
movq 0x1fec0(%r12), %rdi
movq %r14, %rsi
callq *0x20d68(%r12)
movq %rax, %rbx
movq %r14, %rdi
callq *0x20d60(%r12)
movq %rbx, %rax
jmp 0x22738
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/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.display,
_glfw.x11.root);
RROutput primary = XRRGetOutputPrimary(_glfw.x11.display,
_glfw.x11.root);
if (_glfw.x11.xinerama.available)
screens = XineramaQueryScreens(_glfw.x11.display, &screenCount);
disconnectedCount = _glfw.monitorCount;
if (disconnectedCount)
{
disconnected = calloc(_glfw.monitorCount, sizeof(_GLFWmonitor*));
memcpy(disconnected,
_glfw.monitors,
_glfw.monitorCount * sizeof(_GLFWmonitor*));
}
for (int i = 0; i < sr->noutput; i++)
{
int j, type, widthMM, heightMM;
XRROutputInfo* oi = XRRGetOutputInfo(_glfw.x11.display, sr, sr->outputs[i]);
if (oi->connection != RR_Connected || oi->crtc == None)
{
XRRFreeOutputInfo(oi);
continue;
}
for (j = 0; j < disconnectedCount; j++)
{
if (disconnected[j] &&
disconnected[j]->x11.output == sr->outputs[i])
{
disconnected[j] = NULL;
break;
}
}
if (j < disconnectedCount)
{
XRRFreeOutputInfo(oi);
continue;
}
XRRCrtcInfo* ci = XRRGetCrtcInfo(_glfw.x11.display, sr, oi->crtc);
if (ci->rotation == RR_Rotate_90 || ci->rotation == RR_Rotate_270)
{
widthMM = oi->mm_height;
heightMM = oi->mm_width;
}
else
{
widthMM = oi->mm_width;
heightMM = oi->mm_height;
}
if (widthMM <= 0 || heightMM <= 0)
{
// HACK: If RandR does not provide a physical size, assume the
// X11 default 96 DPI and calcuate from the CRTC viewport
// NOTE: These members are affected by rotation, unlike the mode
// info and output info members
widthMM = (int) (ci->width * 25.4f / 96.f);
heightMM = (int) (ci->height * 25.4f / 96.f);
}
_GLFWmonitor* monitor = _glfwAllocMonitor(oi->name, widthMM, heightMM);
monitor->x11.output = sr->outputs[i];
monitor->x11.crtc = oi->crtc;
for (j = 0; j < screenCount; j++)
{
if (screens[j].x_org == ci->x &&
screens[j].y_org == ci->y &&
screens[j].width == ci->width &&
screens[j].height == ci->height)
{
monitor->x11.index = j;
break;
}
}
if (monitor->x11.output == primary)
type = _GLFW_INSERT_FIRST;
else
type = _GLFW_INSERT_LAST;
_glfwInputMonitor(monitor, GLFW_CONNECTED, type);
XRRFreeOutputInfo(oi);
XRRFreeCrtcInfo(ci);
}
XRRFreeScreenResources(sr);
if (screens)
XFree(screens);
for (int i = 0; i < disconnectedCount; i++)
{
if (disconnected[i])
_glfwInputMonitor(disconnected[i], GLFW_DISCONNECTED, 0);
}
free(disconnected);
}
else
{
const int widthMM = DisplayWidthMM(_glfw.x11.display, _glfw.x11.screen);
const int heightMM = DisplayHeightMM(_glfw.x11.display, _glfw.x11.screen);
_glfwInputMonitor(_glfwAllocMonitor("Display", widthMM, heightMM),
GLFW_CONNECTED,
_GLFW_INSERT_FIRST);
}
}
|
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), %rdi
movq 0x1fed0(%r13), %rsi
callq *0x20cc0(%r13)
movq %rax, 0x28(%rsp)
cmpl $0x0, 0x20d70(%r13)
je 0x24a89
movq 0x1fec0(%r13), %rdi
leaq 0x4(%rsp), %rsi
callq *0x20d98(%r13)
movq %rax, 0x8(%rsp)
jmp 0x24a92
movq 0x1fec0(%r13), %rax
movq 0xe8(%rax), %rax
movslq 0x1fec8(%r13), %rcx
shlq $0x7, %rcx
movl 0x20(%rax,%rcx), %esi
movl 0x24(%rax,%rcx), %edx
leaq 0x2c713(%rip), %rdi # 0x5117a
callq 0x1fc1f
movq %rax, %rdi
movl $0x40001, %esi # imm = 0x40001
xorl %edx, %edx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1fa24
movq $0x0, 0x8(%rsp)
movslq 0x400(%r13), %r12
movl %r12d, %ebx
testq %r12, %r12
movq %r12, 0x18(%rsp)
je 0x24acf
movl $0x8, %esi
movq %r12, %rdi
callq 0x14330
movq %rax, %r15
movq 0x3f8(%r13), %rsi
leaq (,%r12,8), %rdx
movq %rax, %rdi
callq 0x143d0
jmp 0x24ad2
xorl %r15d, %r15d
cmpl $0x0, 0x20(%r14)
jle 0x24cd7
movq 0x8(%rsp), %rax
addq $0xa, %rax
movq %rax, 0x20(%rsp)
xorl %r12d, %r12d
leaq 0x20c90(%r13), %rax
movq %rax, 0x30(%rsp)
movl $0x20c90, %eax # imm = 0x20C90
addq 0x334d2(%rip), %rax # 0x57fd8
movq %rax, 0x10(%rsp)
movq 0x1fec0(%r13), %rdi
movq 0x28(%r14), %rax
movq (%rax,%r12,8), %rdx
movq %r14, %rsi
callq *0x20cb8(%r13)
movq %rax, %r13
cmpw $0x0, 0x30(%rax)
je 0x24b38
movq 0x30(%rsp), %rax
jmp 0x24cae
movq 0x8(%r13), %rdx
testq %rdx, %rdx
je 0x24ca9
testl %ebx, %ebx
jle 0x24b71
xorl %eax, %eax
movq (%r15,%rax,8), %rcx
testq %rcx, %rcx
je 0x24b69
movq 0x88(%rcx), %rcx
movq 0x28(%r14), %rsi
cmpq (%rsi,%r12,8), %rcx
je 0x24ca1
incq %rax
cmpq %rax, %rbx
jne 0x24b4b
leaq 0x6d948(%rip), %rax # 0x924c0
movq 0x1fec0(%rax), %rdi
movq %r14, %rsi
callq *0x20cb0(%rax)
movq %rax, %rbp
movzwl 0x20(%rax), %edx
movl $0x20, %ecx
movl $0x28, %eax
cmpl $0x2, %edx
je 0x24bad
cmpl $0x8, %edx
je 0x24bad
movl $0x28, %ecx
movl $0x20, %eax
movq (%r13,%rcx), %rdx
movl (%r13,%rax), %esi
testl %esi, %esi
setle %al
testl %edx, %edx
setle %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x24c03
movl 0x10(%rbp), %eax
cvtsi2ss %rax, %xmm0
movss 0x2aa14(%rip), %xmm1 # 0x4f5ec
mulss %xmm1, %xmm0
movss 0x29e20(%rip), %xmm2 # 0x4ea04
divss %xmm2, %xmm0
cvttss2si %xmm0, %esi
movl 0x14(%rbp), %eax
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
mulss %xmm1, %xmm0
divss %xmm2, %xmm0
cvttss2si %xmm0, %edx
movq 0x10(%r13), %rdi
callq 0x1fc1f
movq 0x28(%r14), %rcx
movq (%rcx,%r12,8), %rcx
movq %rcx, 0x88(%rax)
movq 0x8(%r13), %rdx
movq %rdx, 0x90(%rax)
movslq 0x4(%rsp), %rdx
testq %rdx, %rdx
jle 0x24c70
movl 0x8(%rbp), %esi
movq 0x20(%rsp), %r8
xorl %edi, %edi
movswl -0x6(%r8), %r9d
cmpl %r9d, %esi
jne 0x24c64
movswl -0x4(%r8), %r9d
cmpl %r9d, 0xc(%rbp)
jne 0x24c64
movswl -0x2(%r8), %r9d
cmpl %r9d, 0x10(%rbp)
jne 0x24c64
movswl (%r8), %r9d
cmpl %r9d, 0x14(%rbp)
je 0x24ccf
incq %rdi
addq $0xc, %r8
cmpq %rdi, %rdx
jne 0x24c3a
xorl %edx, %edx
cmpq 0x28(%rsp), %rcx
setne %dl
movq %rax, %rdi
movl $0x40001, %esi # imm = 0x40001
callq 0x1fa24
movq %r13, %rdi
leaq 0x6d82f(%rip), %r13 # 0x924c0
callq *0x20c90(%r13)
leaq 0x20c80(%r13), %rax
jmp 0x24cb8
movq $0x0, (%r15,%rax,8)
movq 0x10(%rsp), %rax
movq %r13, %rbp
leaq 0x6d808(%rip), %r13 # 0x924c0
movq %rbp, %rdi
callq *(%rax)
incq %r12
movslq 0x20(%r14), %rax
cmpq %rax, %r12
jl 0x24b0b
jmp 0x24cd7
movl %edi, 0xa0(%rax)
jmp 0x24c70
movq %r14, %rdi
callq *0x20c98(%r13)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x24cf0
callq 0x14650
testl %ebx, %ebx
movq 0x18(%rsp), %r14
jle 0x24d18
xorl %ebx, %ebx
movq (%r15,%rbx,8), %rdi
testq %rdi, %rdi
je 0x24d10
movl $0x40002, %esi # imm = 0x40002
xorl %edx, %edx
callq 0x1fa24
incq %rbx
cmpq %rbx, %r14
jne 0x24cfb
movq %r15, %rdi
callq 0x14600
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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,
"X11: Gamma ramp size must match current ramp size");
return;
}
XRRCrtcGamma* gamma = XRRAllocGamma(ramp->size);
memcpy(gamma->red, ramp->red, ramp->size * sizeof(unsigned short));
memcpy(gamma->green, ramp->green, ramp->size * sizeof(unsigned short));
memcpy(gamma->blue, ramp->blue, ramp->size * sizeof(unsigned short));
XRRSetCrtcGamma(_glfw.x11.display, monitor->x11.crtc, gamma);
XRRFreeGamma(gamma);
}
else if (_glfw.x11.vidmode.available)
{
XF86VidModeSetGammaRamp(_glfw.x11.display,
_glfw.x11.screen,
ramp->size,
(unsigned short*) ramp->red,
(unsigned short*) ramp->green,
(unsigned short*) ramp->blue);
}
else
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"X11: Gamma ramp access not supported by server");
}
}
|
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
jne 0x2590a
movq %r15, %r12
callq *0x20c78(%r15)
movq %rax, %r15
movq 0x8(%rax), %rdi
movq (%rbx), %rsi
movl 0x18(%rbx), %edx
addq %rdx, %rdx
callq 0x143d0
movq 0x10(%r15), %rdi
movq 0x8(%rbx), %rsi
movl 0x18(%rbx), %edx
addq %rdx, %rdx
callq 0x143d0
movq 0x18(%r15), %rdi
movq 0x10(%rbx), %rsi
movl 0x18(%rbx), %edx
addq %rdx, %rdx
callq 0x143d0
movq 0x1fec0(%r12), %rdi
movq 0x90(%r14), %rsi
movq %r15, %rdx
callq *0x20cf0(%r12)
movq %r15, %rdi
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *0x20c88(%rax)
cmpl $0x0, 0x20db0(%rcx)
je 0x25913
movq 0x20dd8(%rcx), %rax
movq 0x1fec0(%rcx), %rdi
movl 0x1fec8(%rcx), %esi
movl 0x18(%rbx), %edx
movq (%rbx), %rcx
movq 0x8(%rbx), %r8
movq 0x10(%rbx), %r9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
leaq 0x29d0e(%rip), %rsi # 0x4f61f
jmp 0x2591a
leaq 0x29cd6(%rip), %rsi # 0x4f5f0
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1d1a1
|
/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);
#if defined(__linux__)
if (_glfw.linjs.inotify > 0)
FD_SET(_glfw.linjs.inotify, &fds);
#endif
if (timeout)
{
const long seconds = (long) *timeout;
const long microseconds = (long) ((*timeout - seconds) * 1e6);
struct timeval tv = { seconds, microseconds };
const uint64_t base = _glfwPlatformGetTimerValue();
const int result = select(count, &fds, NULL, NULL, &tv);
const int error = errno;
*timeout -= (_glfwPlatformGetTimerValue() - base) /
(double) _glfwPlatformGetTimerFrequency();
if (result > 0)
return GLFW_TRUE;
if ((result == -1 && error == EINTR) || *timeout <= 0.0)
return GLFW_FALSE;
}
else if (select(count, &fds, NULL, NULL, NULL) != -1 || errno != EINTR)
return GLFW_TRUE;
}
}
|
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 $-0x40, %edx
subl %edx, %ecx
movl $0x1, %r13d
shlq %cl, %r13
movq %rdi, %r14
sarl $0x6, %eax
movslq %eax, %r12
leaq 0x30(%rsp), %r15
xorpd %xmm0, %xmm0
movapd %xmm0, 0xa0(%rsp)
movapd %xmm0, 0x90(%rsp)
movapd %xmm0, 0x80(%rsp)
movapd %xmm0, 0x70(%rsp)
movapd %xmm0, 0x60(%rsp)
movapd %xmm0, 0x50(%rsp)
movapd %xmm0, 0x40(%rsp)
movapd %xmm0, 0x30(%rsp)
orq %r13, 0x30(%rsp,%r12,8)
leaq 0x6c5ef(%rip), %rax # 0x924c0
movl 0x20f38(%rax), %ecx
testl %ecx, %ecx
jle 0x25eeb
movl $0x1, %eax
shlq %cl, %rax
shrl $0x6, %ecx
orq %rax, 0x30(%rsp,%rcx,8)
testq %r14, %r14
jne 0x25f22
movl %ebx, %edi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x14510
movl $0x1, %ebp
cmpl $-0x1, %eax
jne 0x26030
callq 0x14030
cmpl $0x4, (%rax)
je 0x25e88
jmp 0x26030
movsd (%r14), %xmm0
cvttsd2si %xmm0, %rax
xorps %xmm1, %xmm1
cvtsi2sd %rax, %xmm1
subsd %xmm1, %xmm0
mulsd 0x29718(%rip), %xmm0 # 0x4f658
cvttsd2si %xmm0, %rcx
movq %rax, 0x20(%rsp)
movq %rcx, 0x28(%rsp)
callq 0x2a241
movq %rax, 0x10(%rsp)
movl %ebx, %edi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
leaq 0x20(%rsp), %r8
callq 0x14510
movl %eax, %ebp
callq 0x14030
movl (%rax), %eax
movl %eax, 0x8(%rsp)
callq 0x2a241
subq 0x10(%rsp), %rax
movq %rax, %xmm0
movq 0x268f0(%rip), %xmm1 # 0x4c880
punpckldq %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x268f4(%rip), %xmm1 # 0x4c890
subpd %xmm1, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm1, 0x10(%rsp)
callq 0x2a28d
movq %rax, %xmm0
punpckldq 0x268bc(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x268c4(%rip), %xmm0 # 0x4c890
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1 # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd 0x10(%rsp), %xmm2
divsd %xmm1, %xmm2
movsd (%r14), %xmm0
subsd %xmm2, %xmm0
movsd %xmm0, (%r14)
testl %ebp, %ebp
jle 0x25ffd
movl $0x1, %ebp
xorl %ecx, %ecx
jmp 0x26024
notl %ebp
movl 0x8(%rsp), %eax
xorl $0x4, %eax
orl %ebp, %eax
setne %al
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
setb %cl
andb %al, %cl
movl $0x0, %eax
movl 0xc(%rsp), %ebp
cmovel %eax, %ebp
movl %ebp, 0xc(%rsp)
testb %cl, %cl
jne 0x25e88
movl %ebp, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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;
}
if (window->context.destroy)
window->context.destroy(window);
if (window->x11.handle)
{
XDeleteContext(_glfw.x11.display, window->x11.handle, _glfw.x11.context);
XUnmapWindow(_glfw.x11.display, window->x11.handle);
XDestroyWindow(_glfw.x11.display, window->x11.handle);
window->x11.handle = (Window) 0;
}
if (window->x11.colormap)
{
XFreeColormap(_glfw.x11.display, window->x11.colormap);
window->x11.colormap = (Colormap) 0;
}
XFlush(_glfw.x11.display);
}
|
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), %rax
testq %rax, %rax
je 0x26ba8
movq %rbx, %rdi
callq *%rax
movq 0x348(%rbx), %rsi
testq %rsi, %rsi
je 0x26bf8
movq 0x1fec0(%r14), %rdi
movl 0x1fef0(%r14), %edx
callq 0x147c0
movq 0x1fec0(%r14), %rdi
movq 0x348(%rbx), %rsi
callq 0x14760
movq 0x1fec0(%r14), %rdi
movq 0x348(%rbx), %rsi
callq 0x14830
movq $0x0, 0x348(%rbx)
movq 0x340(%rbx), %rsi
testq %rsi, %rsi
je 0x26c1b
movq 0x1fec0(%r14), %rdi
callq 0x140c0
movq $0x0, 0x340(%rbx)
movq 0x1fec0(%r14), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x147e0
|
/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 $0x10, %rsp
testq %r14, %r14
je 0x26f36
movl 0xc(%rsp), %eax
movl %eax, (%r14)
testq %rbx, %rbx
je 0x26f41
movl 0x8(%rsp), %eax
movl %eax, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
|
/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)
return;
if (!_glfwPlatformWindowVisible(window) &&
_glfw.x11.NET_REQUEST_FRAME_EXTENTS)
{
XEvent event;
double timeout = 0.5;
// Ensure _NET_FRAME_EXTENTS is set, allowing glfwGetWindowFrameSize to
// function before the window is mapped
sendEventToWM(window, _glfw.x11.NET_REQUEST_FRAME_EXTENTS,
0, 0, 0, 0, 0);
// HACK: Use a timeout because earlier versions of some window managers
// (at least Unity, Fluxbox and Xfwm) failed to send the reply
// They have been fixed but broken versions are still in the wild
// If you are affected by this and your window manager is NOT
// listed above, PLEASE report it to their and our issue trackers
while (!XCheckIfEvent(_glfw.x11.display,
&event,
isFrameExtentsEvent,
(XPointer) window))
{
if (!waitForEvent(&timeout))
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"X11: The window manager has a broken _NET_REQUEST_FRAME_EXTENTS implementation; please report this issue");
return;
}
}
}
if (_glfwGetWindowPropertyX11(window->x11.handle,
_glfw.x11.NET_FRAME_EXTENTS,
XA_CARDINAL,
(unsigned char**) &extents) == 4)
{
if (left)
*left = extents[0];
if (top)
*top = extents[2];
if (right)
*right = extents[1];
if (bottom)
*bottom = extents[3];
}
if (extents)
XFree(extents);
}
|
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
leaq 0x6b1c5(%rip), %r15 # 0x924c0
cmpq $0x0, 0x20b88(%r15)
je 0x272d9
movq %r8, %r13
movq %rsi, %r12
movq %rdx, 0x18(%rsp)
movq %rcx, 0x20(%rsp)
movq 0x1fec0(%r15), %rdi
movq 0x348(%rbp), %rsi
leaq 0x38(%rsp), %rbx
movq %rbx, %rdx
callq 0x14970
cmpl $0x2, 0x5c(%rbx)
setne %al
movq 0x20b90(%r15), %r14
testq %r14, %r14
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x2741d
movq %r13, 0x10(%rsp)
movabsq $0x3fe0000000000000, %rax # imm = 0x3FE0000000000000
leaq 0x28(%rsp), %r13
movq %rax, (%r13)
leaq 0x38(%rsp), %rbx
movl $0xc0, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x142b0
movl $0x21, (%rbx)
movq 0x348(%rbp), %rax
movq %rax, 0x20(%rbx)
movl $0x20, 0x30(%rbx)
movq %r14, 0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x38(%rbx)
movq $0x0, 0x58(%rbx)
movq 0x1fec0(%r15), %rdi
movq 0x1fed0(%r15), %rsi
movl $0x180000, %ecx # imm = 0x180000
xorl %edx, %edx
movq %rbx, %r8
callq 0x140f0
leaq 0x104(%rip), %rbx # 0x274d2
leaq 0xf8(%rsp), %r14
movq 0x1fec0(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %rbp, %rcx
callq 0x14a40
testl %eax, %eax
jne 0x27413
movq %r13, %rdi
callq 0x25e33
testl %eax, %eax
jne 0x273d6
leaq 0x2835e(%rip), %rsi # 0x4f760
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
callq 0x1d1a1
jmp 0x272d9
movq 0x10(%rsp), %r13
leaq 0x38(%rsp), %rbx
movq 0x348(%rbp), %rsi
movq 0x20b88(%r15), %rdx
movq 0x1fec0(%r15), %rdi
leaq 0x8(%rsp), %rax
leaq 0x28(%rsp), %r10
leaq 0xf8(%rsp), %r14
leaq 0x34(%rsp), %r11
movabsq $0x7fffffffffffffff, %r8 # imm = 0x7FFFFFFFFFFFFFFF
xorl %ecx, %ecx
xorl %r9d, %r9d
pushq %rax
pushq %r10
pushq %r14
pushq %r11
pushq %rbx
pushq $0x6
callq 0x14110
addq $0x30, %rsp
cmpq $0x4, (%r14)
jne 0x274ba
testq %r12, %r12
je 0x27481
movq 0x8(%rsp), %rax
movl (%rax), %eax
movl %eax, (%r12)
movq 0x18(%rsp), %rdx
testq %rdx, %rdx
movq 0x20(%rsp), %rcx
je 0x2749a
movq 0x8(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, (%rdx)
testq %rcx, %rcx
je 0x274a9
movq 0x8(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, (%rcx)
testq %r13, %r13
je 0x274ba
movq 0x8(%rsp), %rax
movl 0x18(%rax), %eax
movl %eax, (%r13)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x272d9
callq 0x14650
jmp 0x272d9
|
/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, &event);
XFlush(_glfw.x11.display);
}
|
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(%rbx)
xorl %edx, %edx
xorl %ecx, %ecx
movq %rbx, %r8
callq 0x140f0
movq 0x1fec0(%r14), %rdi
callq 0x147e0
addq $0xc8, %rsp
popq %rbx
popq %r14
retq
|
/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.restoreCursorPosY);
updateCursorImage(window);
_glfwCenterCursorInContentArea(window);
XGrabPointer(_glfw.x11.display, window->x11.handle, True,
ButtonPressMask | ButtonReleaseMask | PointerMotionMask,
GrabModeAsync, GrabModeAsync,
window->x11.handle,
_glfw.x11.hiddenCursorHandle,
CurrentTime);
}
|
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), %rdi
movq 0x1fed0(%rax), %rsi
movl $0x1, %ecx
callq *0x20e18(%rax)
leaq 0x68e88(%rip), %r14 # 0x924c0
movq %rbx, 0x20ab8(%r14)
leaq 0x20aa8(%r14), %rsi
leaq 0x20ab0(%r14), %rdx
movq %rbx, %rdi
callq 0x294d3
movq %rbx, %rdi
callq 0x2973f
movq %rbx, %rdi
callq 0x1dbf7
movq 0x348(%rbx), %rsi
movq 0x1fec0(%r14), %rdi
subq $0x8, %rsp
movl $0x1, %edx
movl $0x4c, %ecx
movl $0x1, %r8d
movl $0x1, %r9d
pushq $0x0
pushq 0x1fee8(%r14)
pushq %rsi
callq 0x141c0
addq $0x38, %rsp
popq %rbx
popq %r14
retq
|
/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,
_glfw.x11.screen));
if (_glfw.vk.KHR_xcb_surface && _glfw.x11.x11xcb.handle)
{
PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR
vkGetPhysicalDeviceXcbPresentationSupportKHR =
(PFN_vkGetPhysicalDeviceXcbPresentationSupportKHR)
vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceXcbPresentationSupportKHR");
if (!vkGetPhysicalDeviceXcbPresentationSupportKHR)
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"X11: Vulkan instance missing VK_KHR_xcb_surface extension");
return GLFW_FALSE;
}
xcb_connection_t* connection = XGetXCBConnection(_glfw.x11.display);
if (!connection)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"X11: Failed to retrieve XCB connection");
return GLFW_FALSE;
}
return vkGetPhysicalDeviceXcbPresentationSupportKHR(device,
queuefamily,
connection,
visualID);
}
else
{
PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR
vkGetPhysicalDeviceXlibPresentationSupportKHR =
(PFN_vkGetPhysicalDeviceXlibPresentationSupportKHR)
vkGetInstanceProcAddr(instance, "vkGetPhysicalDeviceXlibPresentationSupportKHR");
if (!vkGetPhysicalDeviceXlibPresentationSupportKHR)
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"X11: Vulkan instance missing VK_KHR_xlib_surface extension");
return GLFW_FALSE;
}
return vkGetPhysicalDeviceXlibPresentationSupportKHR(device,
queuefamily,
_glfw.x11.display,
visualID);
}
}
|
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 0x1fe98(%r13), %rax
je 0x29e00
cmpq $0x0, 0x20da0(%r13)
je 0x29e00
leaq 0x25aa9(%rip), %rsi # 0x4f879
movq %r12, %rdi
callq *%rax
testq %rax, %rax
je 0x29e34
movq %rax, %r12
movq 0x1fec0(%r13), %rdi
callq *0x20da8(%r13)
testq %rax, %rax
je 0x29e42
movq %r14, %rdi
movl %ebx, %esi
movq %rax, %rdx
movq %r15, %rcx
movq %r12, %rax
jmp 0x29e20
leaq 0x25b00(%rip), %rsi # 0x4f907
movq %r12, %rdi
callq *%rax
testq %rax, %rax
je 0x29e2b
movq 0x1fec0(%r13), %rdx
movq %r14, %rdi
movl %ebx, %esi
movq %r15, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *%rax
leaq 0x25b03(%rip), %rsi # 0x4f935
jmp 0x29e3b
leaq 0x25a6b(%rip), %rsi # 0x4f8a6
movl $0x10006, %edi # imm = 0x10006
jmp 0x29e4e
leaq 0x25a97(%rip), %rsi # 0x4f8e0
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
callq 0x1d1a1
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/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.helperWindowHandle,
CurrentTime);
if (XGetSelectionOwner(_glfw.x11.display, _glfw.x11.PRIMARY) !=
_glfw.x11.helperWindowHandle)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"X11: Failed to become owner of primary selection");
}
}
|
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 0x1fec0(%r14), %rdi
movq 0x20c10(%r14), %rsi
callq 0x149c0
cmpq 0x1fee0(%r14), %rax
jne 0x2a0a4
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
jmp 0x2a0b0
leaq 0x2594c(%rip), %rsi # 0x4f9f7
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1d1a1
|
/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 %rax, %r14
movb (%rbx), %al
testb %al, %al
je 0x2a174
incq %rbx
movq %r14, %r15
movsbl %al, %esi
movq %r15, %rdi
callq 0x29824
addq %rax, %r15
movb (%rbx), %al
incq %rbx
testb %al, %al
jne 0x2a15d
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
|
/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.glx.handle);
window->context.glx.handle = NULL;
}
}
|
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)
movq $0x0, 0x270(%rbx)
popq %rbx
retq
|
/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
"libEGL.so.1",
#endif
NULL
};
if (_glfw.egl.handle)
return GLFW_TRUE;
for (i = 0; sonames[i]; i++)
{
_glfw.egl.handle = _glfw_dlopen(sonames[i]);
if (_glfw.egl.handle)
break;
}
if (!_glfw.egl.handle)
{
_glfwInputError(GLFW_API_UNAVAILABLE, "EGL: Library not found");
return GLFW_FALSE;
}
_glfw.egl.prefix = (strncmp(sonames[i], "lib", 3) == 0);
_glfw.egl.GetConfigAttrib = (PFN_eglGetConfigAttrib)
_glfw_dlsym(_glfw.egl.handle, "eglGetConfigAttrib");
_glfw.egl.GetConfigs = (PFN_eglGetConfigs)
_glfw_dlsym(_glfw.egl.handle, "eglGetConfigs");
_glfw.egl.GetDisplay = (PFN_eglGetDisplay)
_glfw_dlsym(_glfw.egl.handle, "eglGetDisplay");
_glfw.egl.GetError = (PFN_eglGetError)
_glfw_dlsym(_glfw.egl.handle, "eglGetError");
_glfw.egl.Initialize = (PFN_eglInitialize)
_glfw_dlsym(_glfw.egl.handle, "eglInitialize");
_glfw.egl.Terminate = (PFN_eglTerminate)
_glfw_dlsym(_glfw.egl.handle, "eglTerminate");
_glfw.egl.BindAPI = (PFN_eglBindAPI)
_glfw_dlsym(_glfw.egl.handle, "eglBindAPI");
_glfw.egl.CreateContext = (PFN_eglCreateContext)
_glfw_dlsym(_glfw.egl.handle, "eglCreateContext");
_glfw.egl.DestroySurface = (PFN_eglDestroySurface)
_glfw_dlsym(_glfw.egl.handle, "eglDestroySurface");
_glfw.egl.DestroyContext = (PFN_eglDestroyContext)
_glfw_dlsym(_glfw.egl.handle, "eglDestroyContext");
_glfw.egl.CreateWindowSurface = (PFN_eglCreateWindowSurface)
_glfw_dlsym(_glfw.egl.handle, "eglCreateWindowSurface");
_glfw.egl.MakeCurrent = (PFN_eglMakeCurrent)
_glfw_dlsym(_glfw.egl.handle, "eglMakeCurrent");
_glfw.egl.SwapBuffers = (PFN_eglSwapBuffers)
_glfw_dlsym(_glfw.egl.handle, "eglSwapBuffers");
_glfw.egl.SwapInterval = (PFN_eglSwapInterval)
_glfw_dlsym(_glfw.egl.handle, "eglSwapInterval");
_glfw.egl.QueryString = (PFN_eglQueryString)
_glfw_dlsym(_glfw.egl.handle, "eglQueryString");
_glfw.egl.GetProcAddress = (PFN_eglGetProcAddress)
_glfw_dlsym(_glfw.egl.handle, "eglGetProcAddress");
if (!_glfw.egl.GetConfigAttrib ||
!_glfw.egl.GetConfigs ||
!_glfw.egl.GetDisplay ||
!_glfw.egl.GetError ||
!_glfw.egl.Initialize ||
!_glfw.egl.Terminate ||
!_glfw.egl.BindAPI ||
!_glfw.egl.CreateContext ||
!_glfw.egl.DestroySurface ||
!_glfw.egl.DestroyContext ||
!_glfw.egl.CreateWindowSurface ||
!_glfw.egl.MakeCurrent ||
!_glfw.egl.SwapBuffers ||
!_glfw.egl.SwapInterval ||
!_glfw.egl.QueryString ||
!_glfw.egl.GetProcAddress)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"EGL: Failed to load required entry points");
_glfwTerminateEGL();
return GLFW_FALSE;
}
_glfw.egl.display = eglGetDisplay(_GLFW_EGL_NATIVE_DISPLAY);
if (_glfw.egl.display == EGL_NO_DISPLAY)
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"EGL: Failed to get EGL display: %s",
getEGLErrorString(eglGetError()));
_glfwTerminateEGL();
return GLFW_FALSE;
}
if (!eglInitialize(_glfw.egl.display, &_glfw.egl.major, &_glfw.egl.minor))
{
_glfwInputError(GLFW_API_UNAVAILABLE,
"EGL: Failed to initialize EGL: %s",
getEGLErrorString(eglGetError()));
_glfwTerminateEGL();
return GLFW_FALSE;
}
_glfw.egl.KHR_create_context =
extensionSupportedEGL("EGL_KHR_create_context");
_glfw.egl.KHR_create_context_no_error =
extensionSupportedEGL("EGL_KHR_create_context_no_error");
_glfw.egl.KHR_gl_colorspace =
extensionSupportedEGL("EGL_KHR_gl_colorspace");
_glfw.egl.KHR_get_all_proc_addresses =
extensionSupportedEGL("EGL_KHR_get_all_proc_addresses");
_glfw.egl.KHR_context_flush_control =
extensionSupportedEGL("EGL_KHR_context_flush_control");
return GLFW_TRUE;
}
|
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, %rdi
callq 0x144f0
movq %rax, 0x20fb8(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25c50(%rip), %rsi # 0x51166
callq 0x144f0
movq %rax, 0x20fc0(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25c44(%rip), %rsi # 0x51174
callq 0x144f0
movq %rax, 0x20fc8(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25c38(%rip), %rsi # 0x51182
callq 0x144f0
movq %rax, 0x20fd0(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25c2a(%rip), %rsi # 0x5118e
callq 0x144f0
movq %rax, 0x20fd8(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25c1e(%rip), %rsi # 0x5119c
callq 0x144f0
movq %rax, 0x20fe0(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25c11(%rip), %rsi # 0x511a9
callq 0x144f0
movq %rax, 0x20fe8(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25c02(%rip), %rsi # 0x511b4
callq 0x144f0
movq %rax, 0x20ff0(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25bf9(%rip), %rsi # 0x511c5
callq 0x144f0
movq %rax, 0x20ff8(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25bf1(%rip), %rsi # 0x511d7
callq 0x144f0
movq %rax, 0x21000(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25be9(%rip), %rsi # 0x511e9
callq 0x144f0
movq %rax, 0x21008(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25be6(%rip), %rsi # 0x51200
callq 0x144f0
movq %rax, 0x21010(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25bdb(%rip), %rsi # 0x5120f
callq 0x144f0
movq %rax, 0x21018(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25bd0(%rip), %rsi # 0x5121e
callq 0x144f0
movq %rax, 0x21020(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25bc6(%rip), %rsi # 0x5122e
callq 0x144f0
movq %rax, 0x21028(%r14)
movq 0x20fb0(%r14), %rdi
leaq 0x25bbb(%rip), %rsi # 0x5123d
callq 0x144f0
movq %rax, 0x21030(%r14)
cmpq $0x0, 0x20fb8(%r14)
setne %dl
movq 0x20fc8(%r14), %rcx
cmpq $0x0, 0x20fc0(%r14)
setne %sil
andb %dl, %sil
testq %rcx, %rcx
setne %dl
cmpq $0x0, 0x20fd0(%r14)
setne %dil
andb %dl, %dil
andb %sil, %dil
cmpq $0x0, 0x20fd8(%r14)
setne %dl
cmpq $0x0, 0x20fe0(%r14)
setne %sil
andb %dl, %sil
cmpq $0x0, 0x20fe8(%r14)
setne %dl
andb %sil, %dl
andb %dil, %dl
cmpq $0x0, 0x20ff0(%r14)
setne %sil
cmpq $0x0, 0x20ff8(%r14)
setne %dil
andb %sil, %dil
cmpq $0x0, 0x21000(%r14)
setne %sil
andb %dil, %sil
cmpq $0x0, 0x21008(%r14)
setne %dil
andb %sil, %dil
andb %dl, %dil
cmpq $0x0, 0x21010(%r14)
setne %dl
cmpq $0x0, 0x21018(%r14)
setne %sil
andb %dl, %sil
cmpq $0x0, 0x21020(%r14)
setne %dl
andb %sil, %dl
cmpq $0x0, 0x21028(%r14)
setne %sil
andb %dl, %sil
andb %dil, %sil
testq %rax, %rax
setne %al
testb %al, %sil
je 0x2b82d
movq 0x1fec0(%r14), %rdi
callq *%rcx
movq %rax, 0x20f88(%r14)
testq %rax, %rax
je 0x2b844
leaq 0x20f90(%r14), %rsi
leaq 0x20f94(%r14), %rdx
movq %rax, %rdi
callq *0x20fd8(%r14)
testl %eax, %eax
je 0x2b85b
leaq 0x25b07(%rip), %rdi # 0x512be
callq 0x2b8f7
movl %eax, 0x20f9c(%r14)
leaq 0x25b0b(%rip), %rdi # 0x512d5
callq 0x2b8f7
movl %eax, 0x20fa0(%r14)
leaq 0x25b18(%rip), %rdi # 0x512f5
callq 0x2b8f7
movl %eax, 0x20fa4(%r14)
leaq 0x25b1b(%rip), %rdi # 0x5130b
callq 0x2b8f7
movl %eax, 0x20fa8(%r14)
leaq 0x25b27(%rip), %rdi # 0x5132a
callq 0x2b8f7
movl %eax, 0x20fac(%r14)
movl $0x1, %ebx
jmp 0x2b886
leaq 0x2591b(%rip), %rsi # 0x51138
xorl %ebx, %ebx
movl $0x10006, %edi # imm = 0x10006
xorl %eax, %eax
callq 0x1d1a1
jmp 0x2b886
leaq 0x25a1b(%rip), %rsi # 0x5124f
xorl %ebx, %ebx
movl $0x10008, %edi # imm = 0x10008
xorl %eax, %eax
callq 0x1d1a1
jmp 0x2b881
callq *0x20fd0(%r14)
movl %eax, %edi
callq 0x2b8d3
leaq 0x25a20(%rip), %rsi # 0x51279
jmp 0x2b870
callq *0x20fd0(%r14)
movl %eax, %edi
callq 0x2b8d3
leaq 0x25a2c(%rip), %rsi # 0x5129c
xorl %ebx, %ebx
movl $0x10006, %edi # imm = 0x10006
movq %rax, %rdx
xorl %eax, %eax
callq 0x1d1a1
callq 0x2b890
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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.