name string | code string | asm string | file string |
|---|---|---|---|
andres::Iterator<int, true, std::allocator<unsigned long>>::operator+=(long const&) | inline Iterator<T, isConst, A>&
Iterator<T, isConst, A>::operator+=
(
const difference_type& x
)
{
marray_detail::Assert(MARRAY_NO_DEBUG || view_ != 0);
if(index_ < view_->size()) { // view initialized and iterator not at the end
if(index_ + x < view_->size()) {
index_ += x;
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq (%rdi), %r14
testq %r14, %r14
je 0x135351
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq 0x30(%r14), %rcx
cmpq %rcx, %rax
jae 0x13533c
movq %rsi, %r15
addq (%rsi), %rax
cmpq %rcx, %rax
jae 0x13528b
movq %rax, 0x10(%rbx)
movq %r14, %rdi
callq 0xea468
cmpb $0x1, 0x3c(%r1... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::Iterator<int, false, std::allocator<unsigned long>>::operator--(int) | inline Iterator<T, isConst, A>
Iterator<T, isConst, A>::operator--(int)
{
marray_detail::Assert(MARRAY_NO_DEBUG || (view_ != 0 && index_ > 0));
Iterator<T, isConst, A> copy = *this;
--(*this);
return copy;
} | pushq %r15
pushq %r14
pushq %rbx
movq (%rsi), %rax
testq %rax, %rax
je 0x13565e
movq %rsi, %r14
movq 0x10(%rsi), %rcx
testq %rcx, %rcx
je 0x13565e
movq %rdi, %rbx
movq %rax, (%rdi)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
leaq 0x18(%rdi), %r15
leaq 0x18(%r14), %rsi
movq %r15, %rdi
callq 0x12ee98
... | /bjoern-andres[P]marray/include/andres/marray.hxx |
bool andres::Iterator<int, false, std::allocator<unsigned long>>::operator!=<false>(andres::Iterator<int, false, std::allocator<unsigned long>> const&) const | inline bool
Iterator<T, isConst, A>::operator!=
(
const Iterator<T, isConstLocal, A>& it
) const
{
marray_detail::Assert(MARRAY_NO_DEBUG || view_ != 0);
marray_detail::Assert(MARRAY_NO_ARG_TEST || it.view_ != 0);
marray_detail::Assert(MARRAY_NO_ARG_TEST ||
static_cast<const void*>(it.view_) == ... | pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rax
testq %rax, %rax
je 0x1356ea
movq (%rsi), %rcx
testq %rcx, %rcx
je 0x135708
cmpq %rax, %rcx
jne 0x135726
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x270b0
movq %rax, %rbx
leaq 0x3444(%rip), %rs... | /bjoern-andres[P]marray/include/andres/marray.hxx |
bool andres::Iterator<int, true, std::allocator<unsigned long>>::operator!=<true>(andres::Iterator<int, true, std::allocator<unsigned long>> const&) const | inline bool
Iterator<T, isConst, A>::operator!=
(
const Iterator<T, isConstLocal, A>& it
) const
{
marray_detail::Assert(MARRAY_NO_DEBUG || view_ != 0);
marray_detail::Assert(MARRAY_NO_ARG_TEST || it.view_ != 0);
marray_detail::Assert(MARRAY_NO_ARG_TEST ||
static_cast<const void*>(it.view_) == ... | pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rax
testq %rax, %rax
je 0x13579c
movq (%rsi), %rcx
testq %rcx, %rcx
je 0x1357ba
cmpq %rax, %rcx
jne 0x1357d8
movq 0x10(%rdi), %rax
cmpq 0x10(%rsi), %rax
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x270b0
movq %rax, %rbx
leaq 0x3392(%rip), %rs... | /bjoern-andres[P]marray/include/andres/marray.hxx |
void andres::Iterator<int, false, std::allocator<unsigned long>>::coordinate<__gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>>(__gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>) const | inline void
Iterator<T, isConst, A>::coordinate
(
CoordinateIterator it
) const
{
marray_detail::Assert(MARRAY_NO_DEBUG || view_ != 0);
marray_detail::Assert(MARRAY_NO_ARG_TEST || index_ < view_->size());
if(view_->isSimple()) {
view_->indexToCoordinates(index_, it);
}
else {
for... | pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %r15
testq %r15, %r15
je 0x135893
movq %rdi, %r14
movq 0x10(%rdi), %rax
cmpq 0x30(%r15), %rax
jae 0x1358b1
movq %rsi, %rbx
movq %r15, %rdi
callq 0xe9fe4
cmpb $0x0, 0x3c(%r15)
je 0x135862
movq (%r14), %rdi
movq 0x10(%r14), %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
j... | /bjoern-andres[P]marray/include/andres/marray.hxx |
andres::Marray<int, std::allocator<unsigned long>>& andres::Marray<int, std::allocator<unsigned long>>::operator=<int, false, std::allocator<unsigned long>>(andres::View<int, false, std::allocator<unsigned long>> const&) | Marray<T, A>&
Marray<T, A>::operator=
(
const View<TLocal, isConstLocal, ALocal>& in
)
{
if(!MARRAY_NO_ARG_TEST) {
in.testInvariant();
}
if( (void*)(this) != (void*)(&in) ) { // no self-assignment
if(in.data_ == 0) {
dataAllocator_.deallocate(this->data_, this->size());
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0xe9fe4
cmpq %r14, %rbx
je 0x135b61
cmpq $0x0, (%r14)
je 0x135ac8
movq %rbx, %rdi
callq 0xe9fe4
movq %r14, %rdi
callq 0xe9fe4
movq (%rbx), %r12
testq %r12, %r12
je 0x1359c9
movq (%r14), %r13
tes... | /bjoern-andres[P]marray/include/andres/marray.hxx |
void andres::Marray<int, std::allocator<unsigned long>>::resizeHelper<false, __gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>>(__gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>, __gnu_cxx::__normal_iterator<unsi... | inline void
Marray<T, A>::resizeHelper
(
ShapeIterator begin,
ShapeIterator end,
const T& value
)
{
testInvariant();
// compute size
std::vector<std::size_t> newShape;
std::size_t newSize = 1;
for(ShapeIterator it = begin; it != end; ++it) {
std::size_t x = static_cast<std::si... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %rbp
movq %rdi, %rbx
callq 0xe9fe4
cmpb $0x0, 0x3c(%rbx)
je 0x136c94
movq %r15, 0x58(%rsp)
pxor %xmm0, %xmm0
movdqa %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
cmpq %r14, %... | /bjoern-andres[P]marray/include/andres/marray.hxx |
BPlusTree::PrintRecordsInNode(std::shared_ptr<Node>) | void BPlusTree::PrintRecordsInNode(std::shared_ptr<Node> node) {
for (int i = 0; i < node->ptrs.size(); i++) {
PrintRecordOfKey(node->ptrs[i], node->keys[i]);
}
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq (%rsi), %rax
movq (%rax), %rcx
cmpq %rcx, 0x8(%rax)
je 0x5742
movq %rsi, %rbx
movl $0x8, %r15d
xorl %r12d, %r12d
leaq -0x38(%rbp), %r14
movq 0x88e4(%rip), %r13 # 0xdfc0
movq -0x8(%rcx,%r15), %rdx
movq %rdx, -0x3... | /lsscecilia[P]dbms/src/bplustree.cpp |
glfwInputCursorPos | void _glfwInputCursorPos(_GLFWwindow* window, double xpos, double ypos)
{
if (window->virtualCursorPosX == xpos && window->virtualCursorPosY == ypos)
return;
window->virtualCursorPosX = xpos;
window->virtualCursorPosY = ypos;
if (window->callbacks.cursorPos)
window->callbacks.cursorPos... | movsd 0x1e0(%rdi), %xmm2
ucomisd %xmm0, %xmm2
jne 0x17e88
jp 0x17e88
movsd 0x1e8(%rdi), %xmm2
ucomisd %xmm1, %xmm2
jne 0x17e88
jnp 0x17ea6
movsd %xmm0, 0x1e0(%rdi)
movsd %xmm1, 0x1e8(%rdi)
movq 0x308(%rdi), %rax
testq %rax, %rax
je 0x17ea6
jmpq *%rax
retq
| /loganzartman[P]gl-pic-fluid/glfw/src/input.c |
glfwGetInputMode | GLFWAPI int glfwGetInputMode(GLFWwindow* handle, int mode)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(0);
switch (mode)
{
case GLFW_CURSOR:
return window->cursorMode;
case GLFW_STICKY_KEYS:
return wind... | pushq %rbx
testq %rdi, %rdi
je 0x181fa
leaq 0x3f49f(%rip), %rax # 0x57630
cmpl $0x0, (%rax)
je 0x181b8
movl %esi, %edx
leal -0x33001(%rdx), %eax
cmpl $0x4, %eax
ja 0x181e1
leaq 0x2ea2e(%rip), %rcx # 0x46bd8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x74(%rdi), %ebx
jmp 0x181f6
xorl %ebx, %ebx
m... | /loganzartman[P]gl-pic-fluid/glfw/src/input.c |
basic_suite::test_null() | void test_uint8()
{
std::vector<output_type> result;
format::writer writer(result);
TRIAL_PROTOCOL_TEST_EQUAL(writer.value(std::uint8_t(0x00)), 1);
TRIAL_PROTOCOL_TEST_EQUAL(writer.value(std::uint8_t(0x7F)), 1);
TRIAL_PROTOCOL_TEST_EQUAL(writer.value(std::uint8_t(0xD0)), 2);
TRIAL_PROTOCOL_TEST_... | pushq %r14
pushq %rbx
subq $0xa8, %rsp
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
leaq 0x40(%rsp), %rdi
callq 0x6eee
leaq 0x40(%rsp), %rdi
callq 0x8126
leaq 0x18(%rsp), %r9
movq %rax, (%r9)
leaq 0x14(%rsp), %r14
movl $0x1, (%r14)
movq %r14, (%rsp)
leaq 0x7c2d(%rip), %rdi # ... | /breese[P]trial/test/bintoken/writer_suite.cpp |
number_suite::test_int16() | void test_uint8()
{
std::vector<output_type> result;
format::writer writer(result);
TRIAL_PROTOCOL_TEST_EQUAL(writer.value(std::uint8_t(0x00)), 1);
TRIAL_PROTOCOL_TEST_EQUAL(writer.value(std::uint8_t(0x7F)), 1);
TRIAL_PROTOCOL_TEST_EQUAL(writer.value(std::uint8_t(0xD0)), 2);
TRIAL_PROTOCOL_TEST_... | pushq %r14
pushq %rbx
subq $0xa8, %rsp
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
leaq 0x40(%rsp), %rdi
callq 0x6eee
leaq 0x40(%rsp), %rdi
movl $0x100, %esi # imm = 0x100
callq 0x816e
leaq 0x10(%rsp), %r9
movq %rax, (%r9)
leaq 0x1c(%rsp), %r14
movl $0x3, (%r14)
movq %... | /breese[P]trial/test/bintoken/writer_suite.cpp |
number_suite::test_int32() | void test_uint8()
{
std::vector<output_type> result;
format::writer writer(result);
TRIAL_PROTOCOL_TEST_EQUAL(writer.value(std::uint8_t(0x00)), 1);
TRIAL_PROTOCOL_TEST_EQUAL(writer.value(std::uint8_t(0x7F)), 1);
TRIAL_PROTOCOL_TEST_EQUAL(writer.value(std::uint8_t(0xD0)), 2);
TRIAL_PROTOCOL_TEST_... | pushq %r14
pushq %rbx
subq $0xa8, %rsp
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
leaq 0x40(%rsp), %rdi
callq 0x6eee
leaq 0x40(%rsp), %rdi
movl $0x1000000, %esi # imm = 0x1000000
callq 0x816e
leaq 0x10(%rsp), %r9
movq %rax, (%r9)
leaq 0x1c(%rsp), %r14
movl $0x5, (%r14)
mo... | /breese[P]trial/test/bintoken/writer_suite.cpp |
number_suite::test_int64() | void test_uint8()
{
std::vector<output_type> result;
format::writer writer(result);
TRIAL_PROTOCOL_TEST_EQUAL(writer.value(std::uint8_t(0x00)), 1);
TRIAL_PROTOCOL_TEST_EQUAL(writer.value(std::uint8_t(0x7F)), 1);
TRIAL_PROTOCOL_TEST_EQUAL(writer.value(std::uint8_t(0xD0)), 2);
TRIAL_PROTOCOL_TEST_... | pushq %r14
pushq %rbx
subq $0x98, %rsp
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
leaq 0x30(%rsp), %rdi
callq 0x6eee
leaq 0x30(%rsp), %rdi
movabsq $0x100000000000000, %rsi # imm = 0x100000000000000
callq 0x8452
leaq 0x8(%rsp), %r9
movq %rax, (%r9)
leaq 0x2c(%rsp), %r14
movl $0x9... | /breese[P]trial/test/bintoken/writer_suite.cpp |
number_suite::run() | void run()
{
test_zero();
test_int8();
test_uint8();
test_int16();
test_uint16();
test_int32();
test_uint32();
test_int64();
test_uint64();
test_float();
test_double();
} | pushq %rax
callq 0x27dd
callq 0x2909
callq 0x2a73
callq 0x2d65
callq 0x2f09
callq 0x32bf
callq 0x34e1
callq 0x39fd
callq 0x3d0c
callq 0x4502
popq %rax
jmp 0x471f
| /breese[P]trial/test/bintoken/writer_suite.cpp |
string_suite::test_literal() | void test_uint8()
{
std::vector<output_type> result;
format::writer writer(result);
TRIAL_PROTOCOL_TEST_EQUAL(writer.value(std::uint8_t(0x00)), 1);
TRIAL_PROTOCOL_TEST_EQUAL(writer.value(std::uint8_t(0x7F)), 1);
TRIAL_PROTOCOL_TEST_EQUAL(writer.value(std::uint8_t(0xD0)), 2);
TRIAL_PROTOCOL_TEST_... | pushq %r14
pushq %rbx
subq $0xa8, %rsp
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
leaq 0x40(%rsp), %rdi
callq 0x6eee
leaq 0x5a83(%rip), %rsi # 0xa765
leaq 0x40(%rsp), %rdi
callq 0x8968
leaq 0x10(%rsp), %r9
movq %rax, (%r9)
leaq 0x1c(%rsp), %r14
movl $0x5, (%r14)
movq %r14, ... | /breese[P]trial/test/bintoken/writer_suite.cpp |
string_suite::test_view() | void test_uint8()
{
std::vector<output_type> result;
format::writer writer(result);
TRIAL_PROTOCOL_TEST_EQUAL(writer.value(std::uint8_t(0x00)), 1);
TRIAL_PROTOCOL_TEST_EQUAL(writer.value(std::uint8_t(0x7F)), 1);
TRIAL_PROTOCOL_TEST_EQUAL(writer.value(std::uint8_t(0xD0)), 2);
TRIAL_PROTOCOL_TEST_... | pushq %r14
pushq %rbx
subq $0xd8, %rsp
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
leaq 0x70(%rsp), %rdi
callq 0x6eee
leaq 0x5856(%rip), %rsi # 0xa765
leaq 0x50(%rsp), %rdi
leaq 0x40(%rsp), %rdx
callq 0x737a
movq 0x50(%rsp), %rbx
movq %rbx, %rdi
callq 0x2070
leaq 0x40(%rsp),... | /breese[P]trial/test/bintoken/writer_suite.cpp |
compact_suite::test_int8_empty() | void test_uint8()
{
std::vector<output_type> result;
format::writer writer(result);
TRIAL_PROTOCOL_TEST_EQUAL(writer.value(std::uint8_t(0x00)), 1);
TRIAL_PROTOCOL_TEST_EQUAL(writer.value(std::uint8_t(0x7F)), 1);
TRIAL_PROTOCOL_TEST_EQUAL(writer.value(std::uint8_t(0xD0)), 2);
TRIAL_PROTOCOL_TEST_... | pushq %rbx
subq $0x90, %rsp
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
leaq 0x30(%rsp), %rdi
callq 0x6eee
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x898e
movq %rsp, %rbx
movq %rax, (%rbx)
leaq 0xc(%rsp), %rax
movl $0x2, (%rax)
subq $0x8, %rsp
leaq 0x567f(%rip)... | /breese[P]trial/test/bintoken/writer_suite.cpp |
compact_suite::test_int8() | void test_uint8()
{
std::vector<output_type> result;
format::writer writer(result);
TRIAL_PROTOCOL_TEST_EQUAL(writer.value(std::uint8_t(0x00)), 1);
TRIAL_PROTOCOL_TEST_EQUAL(writer.value(std::uint8_t(0x7F)), 1);
TRIAL_PROTOCOL_TEST_EQUAL(writer.value(std::uint8_t(0xD0)), 2);
TRIAL_PROTOCOL_TEST_... | pushq %rbx
subq $0xa0, %rsp
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
leaq 0x40(%rsp), %rdi
callq 0x6eee
leaq 0xc(%rsp), %rsi
movb $0x43, 0x2(%rsi)
movw $0x4241, (%rsi) # imm = 0x4241
leaq 0x40(%rsp), %rdi
pushq $0x3
popq %rdx
callq 0x898e
leaq 0x10(%rsp), %rbx
movq %ra... | /breese[P]trial/test/bintoken/writer_suite.cpp |
compact_suite::test_int16() | void test_uint8()
{
std::vector<output_type> result;
format::writer writer(result);
TRIAL_PROTOCOL_TEST_EQUAL(writer.value(std::uint8_t(0x00)), 1);
TRIAL_PROTOCOL_TEST_EQUAL(writer.value(std::uint8_t(0x7F)), 1);
TRIAL_PROTOCOL_TEST_EQUAL(writer.value(std::uint8_t(0xD0)), 2);
TRIAL_PROTOCOL_TEST_... | pushq %rbx
subq $0x90, %rsp
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
leaq 0x30(%rsp), %rdi
callq 0x6eee
leaq 0x28(%rsp), %rsi
movw $0x1303, 0x4(%rsi) # imm = 0x1303
movl $0x12021101, (%rsi) # imm = 0x12021101
leaq 0x30(%rsp), %rdi
pushq $0x3
popq %rdx
callq 0x8aae
mov... | /breese[P]trial/test/bintoken/writer_suite.cpp |
compact_suite::test_int32() | void test_uint8()
{
std::vector<output_type> result;
format::writer writer(result);
TRIAL_PROTOCOL_TEST_EQUAL(writer.value(std::uint8_t(0x00)), 1);
TRIAL_PROTOCOL_TEST_EQUAL(writer.value(std::uint8_t(0x7F)), 1);
TRIAL_PROTOCOL_TEST_EQUAL(writer.value(std::uint8_t(0xD0)), 2);
TRIAL_PROTOCOL_TEST_... | pushq %rbx
subq $0xb0, %rsp
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
leaq 0x50(%rsp), %rdi
callq 0x6eee
movabsq $0x3222120231211101, %rax # imm = 0x3222120231211101
leaq 0x40(%rsp), %rsi
movq %rax, (%rsi)
movl $0x33231303, 0x8(%rsi) # imm = 0x33231303
leaq 0x50(%rsp), %rdi
pu... | /breese[P]trial/test/bintoken/writer_suite.cpp |
compact_suite::test_int64() | void test_uint8()
{
std::vector<output_type> result;
format::writer writer(result);
TRIAL_PROTOCOL_TEST_EQUAL(writer.value(std::uint8_t(0x00)), 1);
TRIAL_PROTOCOL_TEST_EQUAL(writer.value(std::uint8_t(0x7F)), 1);
TRIAL_PROTOCOL_TEST_EQUAL(writer.value(std::uint8_t(0xD0)), 2);
TRIAL_PROTOCOL_TEST_... | pushq %rbx
subq $0xd0, %rsp
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
leaq 0x70(%rsp), %rdi
callq 0x6eee
movups 0x5a2e(%rip), %xmm0 # 0xafd0
leaq 0x50(%rsp), %rsi
movaps %xmm0, (%rsi)
movabsq $0x7363534333231303, %rax # imm = 0x7363534333231303
movq %rax, 0x10(%rsi)
leaq 0x... | /breese[P]trial/test/bintoken/writer_suite.cpp |
compact_suite::test_float32() | void test_uint8()
{
std::vector<output_type> result;
format::writer writer(result);
TRIAL_PROTOCOL_TEST_EQUAL(writer.value(std::uint8_t(0x00)), 1);
TRIAL_PROTOCOL_TEST_EQUAL(writer.value(std::uint8_t(0x7F)), 1);
TRIAL_PROTOCOL_TEST_EQUAL(writer.value(std::uint8_t(0xD0)), 2);
TRIAL_PROTOCOL_TEST_... | pushq %rbx
subq $0xb0, %rsp
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
leaq 0x50(%rsp), %rdi
callq 0x6eee
movabsq $-0x4080000000000000, %rax # imm = 0xBF80000000000000
leaq 0x40(%rsp), %rsi
movq %rax, (%rsi)
movl $0x3f800000, 0x8(%rsi) # imm = 0x3F800000
leaq 0x50(%rsp), %rdi
p... | /breese[P]trial/test/bintoken/writer_suite.cpp |
compact_suite::run() | void run()
{
test_int8_empty();
test_int8();
test_int16();
test_int32();
test_int64();
test_float32();
test_float64();
} | pushq %rax
callq 0x5163
callq 0x5251
callq 0x5353
callq 0x545a
callq 0x5579
callq 0x5695
popq %rax
jmp 0x57ae
| /breese[P]trial/test/bintoken/writer_suite.cpp |
fctkern__tst_cnt(_fctkern_t const*) | static size_t
fctkern__tst_cnt(fctkern_t const *nk)
{
size_t tally =0;
FCT_ASSERT( nk != NULL );
FCT_NLIST_FOREACH_BGN(fct_ts_t *, ts, &(nk->ts_list))
{
tally += fct_ts__tst_cnt(ts);
}
FCT_NLIST_FOREACH_END();
return tally;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x411d
jmp 0x413c
leaq 0x465c(%rip), %rdi # 0x8780
leaq 0x414f(%rip), %rsi # 0x827a
movl $0x8dc, %edx # imm = 0x8DC
leaq 0x5410(%rip), %rcx # 0x9547
callq 0x1090
movq -0x8(%rbp), %... | /imb[P]fctx/include/fct.h |
dynamic_api_suite::api_ctor_move() | void api_ctor_move()
{
map_view<int, int> span;
BOOST_TEST_EQ(span.capacity(), 0);
BOOST_TEST_EQ(span.size(), 0);
map_view<int, int> clone(std::move(span));
BOOST_TEST_EQ(clone.capacity(), 0);
BOOST_TEST_EQ(clone.size(), 0);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
leaq 0x10(%rsp), %r12
andq $0x0, (%r12)
leaq 0x1c(%rsp), %r13
andl $0x0, (%r13)
movq %r13, (%rsp)
leaq 0x1d20(%rip), %rdi # 0x3004
leaq 0x1d29(%rip), %r14 # 0x3014
leaq 0x1d24(%rip), %r15 # 0x3016
leaq 0x1db4(%rip), %rbx # 0x30a... | /breese[P]vista/test/map_view_suite.cpp |
TestMaterial::RandomTestSupportFunction() | void TestMaterial::RandomTestSupportFunction()
{
std::cout << "RandomTestSupportFunction" << std::endl;
std::vector<Vector3> supportVector(RandomTestEnd);
clock_t begin, end;
srand(static_cast<unsigned int>(time(NULL)));
std::vector<Vector3> v(RandomTestEnd);
for (long j=0; j<RandomTestEnd; j++)
{
... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq 0xa3c7(%rip), %rdi # 0xffd8
leaq 0x64f8(%rip), %rsi # 0xc110
callq 0x5280
movq %rax, %rdi
movq 0xa3a1(%rip), %rsi # 0xffc8
callq 0x52c0
leaq -0x21(%rbp), %rdi
movq... | /jrl-umi3218[P]sch-core/tests/shared-tests/tests/common.cpp |
TestMaterial::initializeUniverse() | void TestMaterial::initializeUniverse()
{
if (nonSTPBV_)
{
sObj.addObject(new S_Box(0.2,0.2,0.2));
sObj.addObject(new S_Box(0.2,0.2,0.2));
sObj.addObject(new S_Sphere(0.1));
sObj.addObject(new S_Sphere(0.12));
sObj.addObject(new S_Superellipsoid(.25,.30,.30,0.9,0.2));
sObj.addObject(new S_S... | pushq %rbp
movq %rsp, %rbp
subq $0x2c0, %rsp # imm = 0x2C0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x198(%rbp)
testb $0x1, 0x88(%rax)
je 0x6b39
movq -0x198(%rbp), %rax
movq %rax, -0x1a8(%rbp)
movl $0xa8, %edi
callq 0x5290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x1a0(%rbp)
movsd 0x5ab4(%r... | /jrl-umi3218[P]sch-core/tests/shared-tests/tests/common.cpp |
TestMaterial::TestPrecision() | void TestMaterial::TestPrecision()
{
std::cout << "TestPrecision" << std::endl;
std::vector<Vector3> axe(AnimationEnd) ;
std::vector<double> angle(AnimationEnd) ;
std::cout.precision(18);
#ifdef DO_TEST
sObj.sceneProximityQuery();
#endif
display();
clock_t begin, end;
#ifdef OUTPUT_FILE
std::fst... | pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp # imm = 0x1A0
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq 0x8bb7(%rip), %rdi # 0xffd8
leaq 0x4dd4(%rip), %rsi # 0xc1fc
callq 0x5280
movq %rax, %rdi
movq 0x8b91(%rip), %rsi # 0xffc8
callq 0x52c0
leaq -0x21(%rbp), %rdi
movq... | /jrl-umi3218[P]sch-core/tests/shared-tests/tests/common.cpp |
TestMaterial::GeneralTest() | void TestMaterial::GeneralTest()
{
std::fstream outfile;
outfile.open("/tmp/sch_generaltest_result.txt",std::ios_base::out|std::ios_base::trunc);
outfile.precision(18);
for (size_t k=0; k<stppObjects.size(); k++)
{
CD_Scene testscene;
testscene.addObject(sObj[0]);
sObj[0]->resetTransformation()... | pushq %rbp
movq %rsp, %rbp
subq $0x630, %rsp # imm = 0x630
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x4d0(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x5330
movl $0x10, %edi
movl $0x20, %esi
callq 0x9c50
movl %eax, -0x4c4(%rbp)
jmp 0x85fd
movl -0x4c4(%rbp), %edx
leaq 0x3c12(%rip), %rsi # 0xc21c
l... | /jrl-umi3218[P]sch-core/tests/shared-tests/tests/common.cpp |
sch::CD_Scene::getWitnessPoints(int, int, CD_Matrix::Vector3T<double, false>&, CD_Matrix::Vector3T<double, false>&) | SCH_API Scalar getWitnessPoints(int a, int b, Point3 & p1, Point3 & p2)
{
if(a != b)
{
p1 = witness_[a][b];
p2 = witness_[b][a];
return distances_[a][b];
}
else
{
return 0;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
je 0x9a6a
movq -0x30(%rbp), %rdi
addq $0x38, %rdi
movslq -0x14(%rbp), ... | /jrl-umi3218[P]sch-core/include/sch/CD/CD_Scene.h |
uv__utf8_decode1 | unsigned uv__utf8_decode1(const char** p, const char* pe) {
unsigned a;
assert(*p < pe);
a = (unsigned char) *(*p)++;
if (a < 128)
return a; /* ASCII, common case. */
return uv__utf8_decode1_slow(p, pe, a);
} | movq (%rdi), %r9
cmpq %rsi, %r9
jae 0x98c4
leaq 0x1(%r9), %rdx
movq %rdx, (%rdi)
movzbl (%r9), %ecx
testb %cl, %cl
js 0x97d6
movl %ecx, %eax
retq
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpb $-0x9, %cl
ja 0x98c3
subq %rdx, %rsi
je 0x98c3
cmpq $0x1, %rsi
je 0x9850
cmpq $0x2, %rsi
je 0x982a
cmpb $-0x10, %cl
jb 0x... | /neovim[P]libuv/src/idna.c |
uv_os_tmpdir | int uv_os_tmpdir(char* buffer, size_t* size) {
const char* buf;
size_t len;
if (buffer == NULL || size == NULL || *size == 0)
return UV_EINVAL;
#define CHECK_ENV_VAR(name) \
do { \
... | testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
movl $0xffffffea, %eax # imm = 0xFFFFFFEA
jne 0xe7df
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq (%rsi), %r13
testq %r13, %r13
je 0xe7d6
movq %rdi, %r14
leaq 0x106e7(%rip), %rdi # 0x1ee45
callq 0x8040
testq %rax, ... | /neovim[P]libuv/src/unix/core.c |
uv_fs_fchmod | int uv_fs_fchmod(uv_loop_t* loop,
uv_fs_t* req,
uv_file file,
int mode,
uv_fs_cb cb) {
INIT(FCHMOD);
req->file = file;
req->mode = mode;
POST;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x1091b
movq %rsi, %rbx
movl $0x6, 0x8(%rsi)
movl $0xe, 0x40(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rsi)
movq %rdi, 0x48(%rsi)
xorl %r14d, %r14d
movq %r14, 0x68(%rsi)
movq %r14, 0x110(%rsi)
movq %r14, 0x128(%rsi)
movq %r8, 0x50(%rsi)
movl %edx, 0x118(%rsi)
movl... | /neovim[P]libuv/src/unix/fs.c |
uv_fs_fsync | int uv_fs_fsync(uv_loop_t* loop, uv_fs_t* req, uv_file file, uv_fs_cb cb) {
INIT(FSYNC);
req->file = file;
POST;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x10c72
movq %rsi, %rbx
movl $0x6, 0x8(%rsi)
movl $0xf, 0x40(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rsi)
movq %rdi, 0x48(%rsi)
xorl %r14d, %r14d
movq %r14, 0x68(%rsi)
movq %r14, 0x110(%rsi)
movq %r14, 0x128(%rsi)
movq %rcx, 0x50(%rsi)
movl %edx, 0x118(%rsi)
tes... | /neovim[P]libuv/src/unix/fs.c |
uv_fs_ftruncate | int uv_fs_ftruncate(uv_loop_t* loop,
uv_fs_t* req,
uv_file file,
int64_t off,
uv_fs_cb cb) {
INIT(FTRUNCATE);
req->file = file;
req->off = off;
POST;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x10d0c
movq %rsi, %rbx
movl $0x6, 0x8(%rsi)
movl $0x9, 0x40(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rsi)
movq %rdi, 0x48(%rsi)
xorl %r14d, %r14d
movq %r14, 0x68(%rsi)
movq %r14, 0x110(%rsi)
movq %r14, 0x128(%rsi)
movq %r8, 0x50(%rsi)
movl %edx, 0x118(%rsi)
movq... | /neovim[P]libuv/src/unix/fs.c |
uv_fs_lutime | int uv_fs_lutime(uv_loop_t* loop,
uv_fs_t* req,
const char* path,
double atime,
double mtime,
uv_fs_cb cb) {
INIT(LUTIME);
PATH;
req->atime = atime;
req->mtime = mtime;
POST;
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
testq %rsi, %rsi
je 0x10e8d
movq %rsi, %rbx
movq %rdi, %r14
movl $0x6, 0x8(%rsi)
movl $0x24, 0x40(%rsi)
xorps %xmm2, %xmm2
movups %xmm2, 0x58(%rsi)
movq %rdi, 0x48(%rsi)
xorl %eax, %eax
movq %rax, 0x68(%rsi)
movq %rax, 0x110(%rsi)
movq %rax, 0x128(%rsi)
movq %rcx, 0x50(%rsi)
testq... | /neovim[P]libuv/src/unix/fs.c |
uv_fs_readlink | int uv_fs_readlink(uv_loop_t* loop,
uv_fs_t* req,
const char* path,
uv_fs_cb cb) {
INIT(READLINK);
PATH;
POST;
} | pushq %r14
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x1187b
movq %rsi, %rbx
movq %rdi, %r14
movl $0x6, 0x8(%rsi)
movl $0x19, 0x40(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rsi)
movq %rdi, 0x48(%rsi)
xorl %eax, %eax
movq %rax, 0x68(%rsi)
movq %rax, 0x110(%rsi)
movq %rax, 0x128(%rsi)
movq %rcx, 0x50(%rsi)
testq %rdx,... | /neovim[P]libuv/src/unix/fs.c |
uv_fs_write | int uv_fs_write(uv_loop_t* loop,
uv_fs_t* req,
uv_file file,
const uv_buf_t bufs[],
unsigned int nbufs,
int64_t off,
uv_fs_cb cb) {
INIT(WRITE);
if (bufs == NULL || nbufs == 0)
return UV_EINVAL;
req->file = file;... | movl $0xffffffea, %eax # imm = 0xFFFFFFEA
testq %rsi, %rsi
je 0x12131
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq 0x40(%rsp), %rbp
movl $0x6, 0x8(%rsi)
movl $0x4, 0x40(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rsi)
movq %rdi,... | /neovim[P]libuv/src/unix/fs.c |
uv__getaddrinfo_translate_error | int uv__getaddrinfo_translate_error(int sys_err) {
switch (sys_err) {
case 0: return 0;
#if defined(EAI_ADDRFAMILY)
case EAI_ADDRFAMILY: return UV_EAI_ADDRFAMILY;
#endif
#if defined(EAI_AGAIN)
case EAI_AGAIN: return UV_EAI_AGAIN;
#endif
#if defined(EAI_BADFLAGS)
case EAI_BADFLAGS: return UV_EAI_BADFLAGS;
#end... | pushq %rax
leal 0xc(%rdi), %eax
cmpl $0xc, %eax
ja 0x125cc
leaq 0xcf54(%rip), %rcx # 0x1f510
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0xfffff43f, %edi # imm = 0xFFFFF43F
jmp 0x12627
cmpl $-0x65, %edi
jne 0x1262b
movl $0xfffff445, %edi # imm = 0xFFFFF445
jmp 0x12627
movl $0xfffff440, ... | /neovim[P]libuv/src/unix/getaddrinfo.c |
uv_if_indextoname | int uv_if_indextoname(unsigned int ifindex, char* buffer, size_t* size) {
char ifname_buf[UV_IF_NAMESIZE];
size_t len;
if (buffer == NULL || size == NULL || *size == 0)
return UV_EINVAL;
if (if_indextoname(ifindex, ifname_buf) == NULL)
return UV__ERR(errno);
len = strnlen(ifname_buf, sizeof(ifname_... | testq %rsi, %rsi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
movl $0xffffffea, %eax # imm = 0xFFFFFFEA
jne 0x129ee
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
cmpq $0x0, (%rdx)
je 0x129e5
movq %rsi, %r14
movq %rsp, %rsi
callq 0x8a70
testq %rax, %rax
je 0x129cc
movq %rsp, %rdi
movl $0x11,... | /neovim[P]libuv/src/unix/getaddrinfo.c |
uv_loop_init | int uv_loop_init(uv_loop_t* loop) {
uv__loop_internal_fields_t* lfields;
void* saved_data;
int err;
saved_data = loop->data;
memset(loop, 0, sizeof(*loop));
loop->data = saved_data;
lfields = (uv__loop_internal_fields_t*) uv__calloc(1, sizeof(*lfields));
if (lfields == NULL)
return UV_ENOMEM;
l... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
addq $0x8, %rdi
movl $0x348, %edx # imm = 0x348
xorl %esi, %esi
callq 0x85a0
movq %r14, (%rbx)
movl $0x1, %edi
movl $0x40, %esi
callq 0xb2a9
testq %rax, %rax
je 0x13241
movq %rax, %r14
movq %rax, 0x... | /neovim[P]libuv/src/unix/loop.c |
uv__loop_configure | int uv__loop_configure(uv_loop_t* loop, uv_loop_option option, va_list ap) {
uv__loop_internal_fields_t* lfields;
lfields = uv__get_internal_fields(loop);
if (option == UV_METRICS_IDLE_TIME) {
lfields->flags |= UV_METRICS_IDLE_TIME;
return 0;
}
if (option != UV_LOOP_BLOCK_SIGNAL)
return UV_ENOSY... | testl %esi, %esi
je 0x1341e
movl $0xffffffda, %eax # imm = 0xFFFFFFDA
cmpl $0x1, %esi
jne 0x13450
movq 0x28(%rdi), %rax
orl $0x1, (%rax)
jmp 0x1344e
movl (%rdx), %eax
cmpq $0x28, %rax
ja 0x13434
movq %rax, %rcx
addq 0x10(%rdx), %rcx
addl $0x8, %eax
movl %eax, (%rdx)
jmp 0x13440
movq 0x8(%rdx), %rcx
leaq 0x8(%rcx)... | /neovim[P]libuv/src/unix/loop.c |
uv_pipe_open | int uv_pipe_open(uv_pipe_t* handle, uv_file fd) {
int flags;
int mode;
int err;
flags = 0;
if (uv__fd_exists(handle->loop, fd))
return UV_EEXIST;
do
mode = fcntl(fd, F_GETFL);
while (mode == -1 && errno == EINTR);
if (mode == -1)
return UV__ERR(errno); /* according to docs, must be EBADF ... | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq 0x8(%rdi), %rdi
callq 0xe38c
movl %eax, %ecx
movl $0xffffffef, %eax # imm = 0xFFFFFFEF
testl %ecx, %ecx
jne 0x136a6
jmp 0x13656
callq 0x80d0
movl (%rax), %eax
cmpl $0x4, %eax
jne 0x136a4
movl %ebx, %edi
movl $0x3, %esi
xorl %eax, %eax
callq 0x8... | /neovim[P]libuv/src/unix/pipe.c |
uv_pipe_connect | void uv_pipe_connect(uv_connect_t* req,
uv_pipe_t* handle,
const char* name,
uv_connect_cb cb) {
struct sockaddr_un saddr;
int new_sock;
int err;
int r;
new_sock = (uv__stream_fd(handle) == -1);
if (new_sock) {
err = uv__socket(AF_UNIX, SOCK_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %r15
leaq 0x88(%rsi), %rbp
movl 0xb8(%rsi), %ebx
cmpl $-0x1, %ebx
jne 0x136fa
movl $0x1, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0xd9eb
testl %eax, %eax
js 0x137b1
movl %eax, ... | /neovim[P]libuv/src/unix/pipe.c |
uv__signal_loop_fork | int uv__signal_loop_fork(uv_loop_t* loop) {
uv__io_stop(loop, &loop->signal_io_watcher, POLLIN);
uv__close(loop->signal_pipefd[0]);
uv__close(loop->signal_pipefd[1]);
loop->signal_pipefd[0] = -1;
loop->signal_pipefd[1] = -1;
return uv__signal_loop_once_init(loop);
} | pushq %rbx
movq %rdi, %rbx
leaq 0x230(%rdi), %rsi
movl $0x1, %edx
callq 0xe1bb
movl 0x228(%rbx), %edi
callq 0xdb06
movl 0x22c(%rbx), %edi
callq 0xdb06
movq $-0x1, 0x228(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x1494b
| /neovim[P]libuv/src/unix/signal.c |
uv__signal_loop_cleanup | void uv__signal_loop_cleanup(uv_loop_t* loop) {
QUEUE* q;
/* Stop all the signal watchers that are still attached to this loop. This
* ensures that the (shared) signal tree doesn't contain any invalid entries
* entries, and that signal handlers are removed when appropriate.
* It's safe to use QUEUE_FOREAC... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq 0x10(%rdi), %r15
cmpq %r14, %r15
je 0x149d3
cmpl $0x10, -0x10(%r15)
jne 0x149ce
leaq -0x20(%r15), %rdi
callq 0x14a0d
movq (%r15), %r15
jmp 0x149b9
movl 0x228(%rbx), %edi
cmpl $-0x1, %edi
je 0x149ed
callq 0xdb06
movl $0xffffffff, 0x228(%rbx) # i... | /neovim[P]libuv/src/unix/signal.c |
uv__stream_flush_write_queue | void uv__stream_flush_write_queue(uv_stream_t* stream, int error) {
uv_write_t* req;
QUEUE* q;
while (!QUEUE_EMPTY(&stream->write_queue)) {
q = QUEUE_HEAD(&stream->write_queue);
QUEUE_REMOVE(q);
req = QUEUE_DATA(q, uv_write_t, queue);
req->error = error;
QUEUE_INSERT_TAIL(&stream->write_comp... | leaq 0xc0(%rdi), %rax
movq 0xc0(%rdi), %rcx
cmpq %rcx, %rax
je 0x16263
leaq 0xd0(%rdi), %rdx
movq (%rcx), %r8
movq 0x8(%rcx), %r9
movq %r8, (%r9)
movq 0x8(%rcx), %r9
movq %r9, 0x8(%r8)
movl %esi, 0x24(%rcx)
movq %rdx, (%rcx)
movq 0xd8(%rdi), %r8
movq %r8, 0x8(%rcx)
movq %rcx, (%r8)
movq %rcx, 0xd8(%rdi)
movq 0xc0(%rdi)... | /neovim[P]libuv/src/unix/stream.c |
uv_listen | int uv_listen(uv_stream_t* stream, int backlog, uv_connection_cb cb) {
int err;
switch (stream->type) {
case UV_TCP:
err = uv_tcp_listen((uv_tcp_t*)stream, backlog, cb);
break;
case UV_NAMED_PIPE:
err = uv_pipe_listen((uv_pipe_t*)stream, backlog, cb);
break;
default:
err = UV_EINVAL;
... | pushq %rbx
movq %rdi, %rbx
movl 0x10(%rdi), %ecx
cmpl $0x7, %ecx
je 0x16882
movl $0xffffffea, %eax # imm = 0xFFFFFFEA
cmpl $0xc, %ecx
jne 0x168ac
movq %rbx, %rdi
callq 0x17859
jmp 0x1688a
movq %rbx, %rdi
callq 0x13588
testl %eax, %eax
jne 0x168ac
movl 0x58(%rbx), %ecx
xorl %eax, %eax
testb $0x4, %cl
jne 0x168ac
m... | /neovim[P]libuv/src/unix/stream.c |
uv_tcp_getsockname | int uv_tcp_getsockname(const uv_tcp_t* handle,
struct sockaddr* name,
int* namelen) {
if (handle->delayed_error)
return handle->delayed_error;
return uv__getsockpeername((const uv_handle_t*) handle,
getsockname,
... | movl 0xe8(%rdi), %eax
testl %eax, %eax
je 0x177c8
retq
movq %rdx, %rcx
movq %rsi, %rdx
movq 0x1080b(%rip), %rsi # 0x27fe0
jmp 0xeb74
| /neovim[P]libuv/src/unix/tcp.c |
uv_tcp_listen | int uv_tcp_listen(uv_tcp_t* tcp, int backlog, uv_connection_cb cb) {
static int single_accept_cached = -1;
unsigned long flags;
int single_accept;
int err;
if (tcp->delayed_error)
return tcp->delayed_error;
single_accept = uv__load_relaxed(&single_accept_cached);
if (single_accept == -1) {
const... | movl 0xe8(%rdi), %eax
testl %eax, %eax
je 0x17864
retq
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
movl 0x1101a(%rip), %ecx # 0x28890
cmpl $-0x1, %ecx
jne 0x178a5
leaq 0x8d78(%rip), %rdi # 0x205fa
callq 0x8040
testq %rax, %rax
je 0x1789d
movq %rax, %rdi
callq 0x8e10
xorl %e... | /neovim[P]libuv/src/unix/tcp.c |
uv_rwlock_tryrdlock | int uv_rwlock_tryrdlock(uv_rwlock_t* rwlock) {
int err;
err = pthread_rwlock_tryrdlock(rwlock);
if (err) {
if (err != EBUSY && err != EAGAIN)
abort();
return UV_EBUSY;
}
return 0;
} | pushq %rax
callq 0x8500
testl %eax, %eax
je 0x17e11
cmpl $0xb, %eax
je 0x17e0c
cmpl $0x10, %eax
jne 0x17e13
movl $0xfffffff0, %eax # imm = 0xFFFFFFF0
popq %rcx
retq
callq 0x80c0
| /neovim[P]libuv/src/unix/thread.c |
uv_guess_handle | uv_handle_type uv_guess_handle(uv_file file) {
struct sockaddr sa;
struct stat s;
socklen_t len;
int type;
if (file < 0)
return UV_UNKNOWN_HANDLE;
if (isatty(file))
return UV_TTY;
if (fstat(file, &s))
return UV_UNKNOWN_HANDLE;
if (S_ISREG(s.st_mode))
return UV_FILE;
if (S_ISCHR(s.... | testl %edi, %edi
js 0x183ee
pushq %rbx
subq $0xb0, %rsp
movl %edi, %ebx
callq 0x81d0
movl %eax, %ecx
movl $0xe, %eax
testl %ecx, %ecx
jne 0x183e5
leaq 0x20(%rsp), %rsi
movl %ebx, %edi
callq 0x8f00
testl %eax, %eax
je 0x183f1
xorl %eax, %eax
addq $0xb0, %rsp
popq %rbx
retq
xorl %eax, %eax
retq
movl $0xf000, %ecx ... | /neovim[P]libuv/src/unix/tty.c |
uv__udp_finish_close | void uv__udp_finish_close(uv_udp_t* handle) {
uv_udp_send_t* req;
QUEUE* q;
assert(!uv__io_active(&handle->io_watcher, POLLIN | POLLOUT));
assert(handle->io_watcher.fd == -1);
while (!QUEUE_EMPTY(&handle->write_queue)) {
q = QUEUE_HEAD(&handle->write_queue);
QUEUE_REMOVE(q);
req = QUEUE_DATA(q,... | pushq %rbx
movq %rdi, %rbx
addq $0x80, %rdi
movl $0x5, %esi
callq 0xe337
testl %eax, %eax
jne 0x187f2
cmpl $-0x1, 0xb0(%rbx)
jne 0x18811
leaq 0xb8(%rbx), %rax
movq 0xb8(%rbx), %rcx
cmpq %rcx, %rax
je 0x187d3
leaq 0xc8(%rbx), %rdx
movq (%rcx), %rsi
movq 0x8(%rcx), %rdi
movq %rsi, (%rdi)
movq 0x8(%rcx), %rdi
movq %rdi, 0... | /neovim[P]libuv/src/unix/udp.c |
uv__udp_disconnect | int uv__udp_disconnect(uv_udp_t* handle) {
int r;
struct sockaddr addr;
memset(&addr, 0, sizeof(addr));
addr.sa_family = AF_UNSPEC;
do {
errno = 0;
r = connect(handle->io_watcher.fd, &addr, sizeof(addr));
} while (r == -1 && errno == EINTR);
if (r == -1 && errno != EAFNOSUPPO... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x80d0
movq %rax, %r14
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, (%r15)
movl $0x0, (%r14)
movl 0xb0(%rbx), %edi
movq %r15, %rsi
movl $0x10, %edx
callq 0x8ed0
cmpl $-0x1, %eax
jne 0x18cb1
movl (%r14), %eax
cmpl $0x4, %eax
je 0x18c85
cmpl $0x6... | /neovim[P]libuv/src/unix/udp.c |
uv_udp_open | int uv_udp_open(uv_udp_t* handle, uv_os_sock_t sock) {
int err;
/* Check for already active socket. */
if (handle->io_watcher.fd != -1)
return UV_EBUSY;
if (uv__fd_exists(handle->loop, sock))
return UV_EEXIST;
err = uv__nonblock(sock, 1);
if (err)
return err;
err = uv__set_reuse(sock);
i... | movl $0xfffffff0, %eax # imm = 0xFFFFFFF0
cmpl $-0x1, 0xb0(%rdi)
je 0x1999c
retq
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0xe38c
movl %eax, %ecx
movl $0xffffffef, %eax # imm = 0xFFFFFFEF
testl %ecx, %ecx
jne 0x199ed
movl %ebp, %edi
movl $0x1, %esi
callq 0xd... | /neovim[P]libuv/src/unix/udp.c |
uv_udp_set_broadcast | int uv_udp_set_broadcast(uv_udp_t* handle, int on) {
if (setsockopt(handle->io_watcher.fd,
SOL_SOCKET,
SO_BROADCAST,
&on,
sizeof(on))) {
return UV__ERR(errno);
}
return 0;
} | pushq %rax
leaq 0x4(%rsp), %rcx
movl %esi, (%rcx)
movl 0xb0(%rdi), %edi
movl $0x1, %esi
movl $0x6, %edx
movl $0x4, %r8d
callq 0x8210
testl %eax, %eax
je 0x19e4a
callq 0x80d0
movq %rax, %rcx
xorl %eax, %eax
subl (%rcx), %eax
jmp 0x19e4c
xorl %eax, %eax
popq %rcx
retq
| /neovim[P]libuv/src/unix/udp.c |
uv_get_process_title | int uv_get_process_title(char* buffer, size_t size) {
if (buffer == NULL || size == 0)
return UV_EINVAL;
/* If uv_setup_args wasn't called or failed, we can't continue. */
if (args_mem == NULL)
return UV_ENOBUFS;
uv_once(&process_title_mutex_once, init_process_title_mutex_once);
uv_mutex_lock(&proce... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
movl $0xffffffea, %ebp # imm = 0xFFFFFFEA
jne 0x1a3c1
cmpq $0x0, 0xeae9(%rip) # 0x28e40
je 0x1a3bc
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xeafa(%rip), %rdi # 0x28e60
leaq -0x46(%rip), %... | /neovim[P]libuv/src/unix/proctitle.c |
uv__slurp | static int uv__slurp(const char* filename, char* buf, size_t len) {
ssize_t n;
int fd;
assert(len > 0);
fd = uv__open_cloexec(filename, O_RDONLY);
if (fd < 0)
return fd;
do
n = read(fd, buf, len - 1);
while (n == -1 && errno == EINTR);
if (uv__close_nocheckstdio(fd))
abort();
if (n < ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
xorl %esi, %esi
callq 0xdb6a
movl %eax, %ebp
testl %eax, %eax
js 0x1a745
decq %r14
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x8740
cmpq $-0x1, %rax
jne 0x1a71c
callq 0x80d0
cmpl $0x4, (%rax)
je 0x1a6ef
movq %rax, %r15
mo... | /neovim[P]libuv/src/unix/linux-core.c |
uv_get_total_memory | uint64_t uv_get_total_memory(void) {
struct sysinfo info;
uint64_t rc;
rc = uv__read_proc_meminfo("MemTotal:");
if (rc != 0)
return rc;
if (0 == sysinfo(&info))
return (uint64_t) info.totalram * info.mem_unit;
return 0;
} | subq $0x78, %rsp
leaq 0x5ac8(%rip), %rdi # 0x20b19
callq 0x1afc9
testq %rax, %rax
jne 0x1b077
leaq 0x8(%rsp), %rdi
callq 0x8e20
testl %eax, %eax
je 0x1b06d
xorl %eax, %eax
jmp 0x1b077
movl 0x70(%rsp), %eax
imulq 0x28(%rsp), %rax
addq $0x78, %rsp
retq
| /neovim[P]libuv/src/unix/linux-core.c |
uv_fs_event_start | int uv_fs_event_start(uv_fs_event_t* handle,
uv_fs_event_cb cb,
const char* path,
unsigned int flags) {
struct watcher_list* w;
size_t len;
int events;
int err;
int wd;
if (uv__is_active(handle))
return UV_EINVAL;
err = init_inotify(h... | movl $0xffffffea, %eax # imm = 0xFFFFFFEA
testb $0x4, 0x58(%rdi)
jne 0x1bc51
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %r15
cmpl $-0x1, 0x348(%r15)
jne 0x1b8f2
movl $0x80800, %edi # imm = 0x80800
callq 0x90... | /neovim[P]libuv/src/unix/linux-inotify.c |
uv_exepath | int uv_exepath(char* buffer, size_t* size) {
ssize_t n;
if (buffer == NULL || size == NULL || *size == 0)
return UV_EINVAL;
n = *size - 1;
if (n > 0)
n = readlink("/proc/self/exe", buffer, n);
if (n == -1)
return UV__ERR(errno);
buffer[n] = '\0';
*size = n;
return 0;
} | testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
movl $0xffffffea, %ecx # imm = 0xFFFFFFEA
jne 0x1bfa3
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %rax
testq %rax, %rax
je 0x1bf9c
movq %rdi, %r14
decq %rax
testq %rax, %rax
jle 0x1bf81
leaq 0x4e8e(%rip), %rdi # 0x20e04
movq %... | /neovim[P]libuv/src/unix/procfs-exepath.c |
uv__random_getrandom | int uv__random_getrandom(void* buf, size_t buflen) {
ssize_t n;
size_t pos;
int rc;
rc = uv__random_getrandom_init();
if (rc != 0)
return rc;
for (pos = 0; pos != buflen; pos += n) {
do {
n = buflen - pos;
/* Most getrandom() implementations promise that reads <= 256 bytes
* wi... | testq %rsi, %rsi
je 0x1c009
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r13d, %r13d
movl $0x100, %ebp # imm = 0x100
movq %rbx, %r15
subq %r13, %r15
cmpq %rbp, %r15
cmovgeq %rbp, %r15
leaq (%r14,%r13), %r12
movq %r12, %rdi
movq %r15, %rsi
... | /neovim[P]libuv/src/unix/random-getrandom.c |
uv__platform_invalidate_fd | void uv__platform_invalidate_fd(uv_loop_t* loop, int fd) {
struct epoll_event* events;
struct epoll_event dummy;
uintptr_t i;
uintptr_t nfds;
assert(loop->watchers != NULL);
assert(fd >= 0);
events = (struct epoll_event*) loop->watchers[loop->nwatchers];
nfds = (uintptr_t) loop->watchers[loop->nwatche... | subq $0x18, %rsp
movq 0x68(%rdi), %rcx
testq %rcx, %rcx
je 0x1c20a
movl %esi, %edx
testl %esi, %esi
js 0x1c229
movl 0x70(%rdi), %esi
movq (%rcx,%rsi,8), %rax
incl %esi
movq (%rcx,%rsi,8), %rcx
testq %rax, %rax
setne %sil
testq %rcx, %rcx
setne %r8b
andb %sil, %r8b
cmpb $0x1, %r8b
jne 0x1c1e1
cmpq $0x1, %rcx
adcq $0x0, ... | /neovim[P]libuv/src/unix/epoll.c |
mul_mat_vec_f32_2 | void mul_mat_vec_f32_2(
const float * restrict src0,
const float * restrict src1,
float * dst,
int nrows,
int ncols) {
const int ncols32 = ncols & ~31;
for (int i = 0; i < nrows; i++) {
__m256 sum0 = _mm256_setzero_ps();
__m256 sum1 = _mm256_setzero_ps();
__m256 sum... | pushq %rbx
movslq %r8d, %rax
andl $-0x20, %r8d
movslq %r8d, %r8
xorl %r9d, %r9d
testl %ecx, %ecx
cmovlel %r9d, %ecx
leaq 0x60(%rdi), %r10
leaq (,%rax,4), %r11
cmpq %rcx, %r9
je 0x135d
vxorps %xmm0, %xmm0, %xmm0
xorl %ebx, %ebx
vxorps %xmm1, %xmm1, %xmm1
vxorps %xmm2, %xmm2, %xmm2
vxorps %xmm3, %xmm3, %xmm3
cmpq %r8, %r... | /ggerganov[P]ggml/tests/test-vec1.c |
mul_mat_vec_f16_0 | void mul_mat_vec_f16_0(
const uint16_t * src0,
const uint16_t * src1,
float * dst,
int nrows,
int ncols) {
const int ncols8 = ncols & ~7;
for (int i = 0; i < nrows; i++) {
__m256 sum = _mm256_setzero_ps();
const uint16_t * src0_row = src0 + i * ncols;
for ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, %r15
movq %rdi, %r12
movslq %r8d, %r13
andl $-0x8, %r8d
movslq %r8d, %r14
xorl %ebx, %ebx
testl %ecx, %ecx
cmovlel %ebx, %ecx
movq %rcx, 0x30(%rsp)
leaq (,%r13,2), %rax
movq %rax, 0x28(%rsp)
cmpq 0x30(%rsp... | /ggerganov[P]ggml/tests/test-vec1.c |
ByteData_DefaultConstructor_Test::~ByteData_DefaultConstructor_Test() | TEST(ByteData, DefaultConstructor) {
ByteData byte_data;
size_t size = 0;
EXPECT_STREQ(byte_data.GetHex().c_str(), "");
EXPECT_EQ(byte_data.GetDataSize(), size);
EXPECT_TRUE(byte_data.IsEmpty());
EXPECT_STREQ(
byte_data.Serialize().GetHex().c_str(),
"00");
EXPECT_TRUE(byte_data.Empty()); // TOD... | pushq %rbx
movq %rdi, %rbx
callq 0x289966
movq %rbx, %rdi
popq %rbx
jmp 0x6e300
| /p2pderivatives[P]cfd-js/external/cfd-core/test/test_bytedata.cpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> testing::PrintToString<unsigned int>(unsigned int const&) | ::std::string PrintToString(const T& value) {
::std::stringstream ss;
internal::UniversalTersePrinter<T>::Print(value, &ss);
return ss.str();
} | pushq %r14
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x6d860
leaq 0x10(%rsp), %rdi
movl (%r14), %esi
callq 0x6d760
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x6fbf0
movq 0x33a800(%rip), %rsi # 0x3f7e28
movq %rsp, %rdi
callq 0x6d970
leaq 0x80(%rsp), ... | /p2pderivatives[P]cfd-js/external/googletest/googletest/include/gtest/gtest-printers.h |
testing::AssertionResult testing::internal::CmpHelperEQFailure<char [41], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [41], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs,... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
leaq 0x28(%rsp), %rdi
callq 0xbe345
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0xbe460
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %... | /p2pderivatives[P]cfd-js/external/googletest/googletest/include/gtest/gtest.h |
cfd::core::ByteData cfd::core::ByteData160::PushBack<cfd::core::ByteData>(cfd::core::ByteData const&) const | ByteData PushBack(const ByteDataClass& back_insert_data) const {
std::vector<uint8_t> result(data_);
std::vector<uint8_t> insert_bytes = back_insert_data.GetBytes();
result.insert(result.end(), insert_bytes.begin(), insert_bytes.end());
return ByteData(result);
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0xbd212
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x6cb10
leaq 0x20(%rsp), %rdi
movq 0x8(%rdi), %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0xbdb9a
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x6d610
movq 0x8(%... | /p2pderivatives[P]cfd-js/external/cfd-core/src/../include/cfdcore/cfdcore_bytedata.h |
cfd::core::ByteData cfd::core::ByteData160::PushBack<cfd::core::ByteData256>(cfd::core::ByteData256 const&) const | ByteData PushBack(const ByteDataClass& back_insert_data) const {
std::vector<uint8_t> result(data_);
std::vector<uint8_t> insert_bytes = back_insert_data.GetBytes();
result.insert(result.end(), insert_bytes.begin(), insert_bytes.end());
return ByteData(result);
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
callq 0xbd212
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x6ca00
leaq 0x20(%rsp), %rdi
movq 0x8(%rdi), %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0xbdb9a
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x6d610
movq 0x8(%... | /p2pderivatives[P]cfd-js/external/cfd-core/src/../include/cfdcore/cfdcore_bytedata.h |
ByteData160_HexConstructor_Test::~ByteData160_HexConstructor_Test() | TEST(ByteData160, HexConstructor) {
std::string target("1234567890123456789012345678901234567890");
ByteData160 byte_data = ByteData160(target);
EXPECT_STREQ(byte_data.GetHex().c_str(), target.c_str());
EXPECT_FALSE(byte_data.IsEmpty());
EXPECT_STREQ(
byte_data.Serialize().GetHex().c_str(),
"14123456... | pushq %rbx
movq %rdi, %rbx
callq 0x289966
movq %rbx, %rdi
popq %rbx
jmp 0x6e300
| /p2pderivatives[P]cfd-js/external/cfd-core/test/test_bytedata160.cpp |
testing::AssertionResult testing::internal::CmpHelperEQ<char [81], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [81], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | AssertionResult CmpHelperEQ(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs,
const T2& rhs) {
if (lhs == rhs) {
return AssertionSuccess();
}
return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs,... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %r8, %rdi
movq %rcx, %rsi
callq 0x6c7d0
movq %rbx, %rdi
testl %eax, %eax
je 0xc757d
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0xc758f
jmp 0xc7582
callq 0x... | /p2pderivatives[P]cfd-js/external/googletest/googletest/include/gtest/gtest.h |
Deserializer_Normal_Test::~Deserializer_Normal_Test() | TEST(Deserializer, Normal) {
std::vector<uint8_t> empty_data;
Deserializer empty_parser(empty_data);
Deserializer parser(ByteData("010203040506070808090a0b0c0d0e0f"));
EXPECT_EQ(1, parser.ReadUint8());
std::vector<uint8_t> exp_buf = {2, 3};
auto buf = parser.ReadBuffer(2);
EXPECT_EQ(exp_buf.size(), buf.... | pushq %rbx
movq %rdi, %rbx
callq 0x289966
movq %rbx, %rdi
popq %rbx
jmp 0x6e300
| /p2pderivatives[P]cfd-js/external/cfd-core/test/test_deserializer.cpp |
HashUtil_operator_Test::TestBody() | TEST(HashUtil, Sha256BytePubkey) {
Pubkey target(
"032f061438c62aa9a1685d7451a4bf1af8d0b8c132b0db4614147df19b687c01db");
ByteData256 byte_data = HashUtil::Sha256(target);
EXPECT_STREQ(
byte_data.GetHex().c_str(),
"2213d0c45bf1ece1a9b0c2d5a21d603601e88e22ae2786fe3f0060ee4aad321d");
} | pushq %r14
pushq %rbx
subq $0xb8, %rsp
leaq 0x60(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1dd4cb(%rip), %rsi # 0x2ab947
leaq 0x1dd552(%rip), %rdx # 0x2ab9d5
leaq 0x50(%rsp), %rdi
callq 0xb5d70
leaq 0xa0(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x6f850
movq 0x50(%rsp), %rdi
cmpq %r14, %rdi
je 0xce4ae
callq 0x6e300... | /p2pderivatives[P]cfd-js/external/cfd-core/test/test_hashutil.cpp |
HashUtil_Ripemd160_Test::~HashUtil_Ripemd160_Test() | TEST(HashUtil, Ripemd160) {
ByteData160 byte_data;
byte_data = HashUtil::Ripemd160(ByteData("0123456789abcdef"));
EXPECT_STREQ(byte_data.GetHex().c_str(), "cea1b21f1a739fba68d1d4290437d2c5609be1d3");
byte_data = HashUtil::Ripemd160(ByteData160("0123456789abcdef0123456789abcdef01234567"));
EXPECT_STREQ(byte_d... | pushq %rbx
movq %rdi, %rbx
callq 0x289966
movq %rbx, %rdi
popq %rbx
jmp 0x6e300
| /p2pderivatives[P]cfd-js/external/cfd-core/test/test_hashutil.cpp |
HDWallet_GetMnemonicWordlistTest_Test::~HDWallet_GetMnemonicWordlistTest_Test() | TEST(HDWallet, GetMnemonicWordlistTest) {
// ref: https://github.com/bitcoin/bips/blob/master/bip-0039/english.txt
std::vector<std::string> expect_en_words = {"abandon", "ability", "able", "about", "above", "absent", "absorb", "abstract", "absurd", "abuse", "access", "accident", "account", "accuse", "achieve", "aci... | pushq %rbx
movq %rdi, %rbx
callq 0x289966
movq %rbx, %rdi
popq %rbx
jmp 0x6e300
| /p2pderivatives[P]cfd-js/external/cfd-core/test/test_hdwallet.cpp |
HDWallet_ConvertTest_Test::~HDWallet_ConvertTest_Test() | TEST(HDWallet, ConvertTest) {
ByteData actual_entropy;
std::vector<std::string> actual_mnemonic;
ByteData actual_seed;
bool actual_is_valid;
HDWallet hd_wallet;
HDWallet copy_wallet;
ByteData copy_seed;
for (Bip39TestVector test_vector : bip39_test_vectors) {
EXPECT_NO_THROW(hd_wallet = HDWallet(te... | pushq %rbx
movq %rdi, %rbx
callq 0x289966
movq %rbx, %rdi
popq %rbx
jmp 0x6e300
| /p2pderivatives[P]cfd-js/external/cfd-core/test/test_hdwallet.cpp |
CryptoUtil_EncodeBase58Check_Test::~CryptoUtil_EncodeBase58Check_Test() | TEST(CryptoUtil, EncodeBase58Check) {
ByteData data(
"0488b21e051431616f00000000e6ba4088246b104837c62bd01fd8ba1cf2931ad1a5376c2360a1f112f2cfc63c02acf89ab4e3daa79bceef2ebecee2af92712e6bf5e4b0d10c74bbecc27ac13da8");
std::string result = CryptoUtil::EncodeBase58Check(data);
EXPECT_STREQ(
result.c_str(),
... | pushq %rbx
movq %rdi, %rbx
callq 0x289966
movq %rbx, %rdi
popq %rbx
jmp 0x6e300
| /p2pderivatives[P]cfd-js/external/cfd-core/test/test_cryptoutil.cpp |
StringUtil_StringToByteError_Test::~StringUtil_StringToByteError_Test() | TEST(StringUtil, StringToByteError) {
try {
std::string target("hello!");
std::vector<uint8_t> bytes = StringUtil::StringToByte(target);
} catch (const cfd::core::CfdException &cfd_except) {
EXPECT_STREQ(cfd_except.what(), "hex to byte convert error.");
return;
}
ASSERT_TRUE(false);
} | pushq %rbx
movq %rdi, %rbx
callq 0x289966
movq %rbx, %rdi
popq %rbx
jmp 0x6e300
| /p2pderivatives[P]cfd-js/external/cfd-core/test/test_stringutil.cpp |
StringUtil_ByteToString_Test::~StringUtil_ByteToString_Test() | TEST(StringUtil, ByteToString) {
std::vector<uint8_t> bytes(5);
bytes[0] = 0x6a;
bytes[1] = 0xcd;
bytes[2] = 0x7a;
bytes[3] = 0xde;
bytes[4] = 0xf4;
std::string result = StringUtil::ByteToString(bytes);
EXPECT_STREQ(result.c_str(), "6acd7adef4");
} | pushq %rbx
movq %rdi, %rbx
callq 0x289966
movq %rbx, %rdi
popq %rbx
jmp 0x6e300
| /p2pderivatives[P]cfd-js/external/cfd-core/test/test_stringutil.cpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> testing::PrintToString<long>(long const&) | ::std::string PrintToString(const T& value) {
::std::stringstream ss;
internal::UniversalTersePrinter<T>::Print(value, &ss);
return ss.str();
} | pushq %r14
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x6d860
leaq 0x10(%rsp), %rdi
movq (%r14), %rsi
callq 0x6e330
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x6fbf0
movq 0x2f4d76(%rip), %rsi # 0x3f7e28
movq %rsp, %rdi
callq 0x6d970
leaq 0x80(%rsp), ... | /p2pderivatives[P]cfd-js/external/googletest/googletest/include/gtest/gtest-printers.h |
Transaction_AddScriptWitnessStack_SetScriptWitnessStack_RemoveScriptWitnessStackAll_Test::TestBody() | TEST(Transaction, AddScriptWitnessStack_SetScriptWitnessStack_RemoveScriptWitnessStackAll) {
Transaction tx(exp_version, exp_locktime);
EXPECT_NO_THROW(
tx.AddTxIn(
Txid(
"d4470b3c4b616042e5004b1ab60cb1734d21b8e1c4854c379ec8c3f7ca1e450f"),
0, 4294967294));
// AddScriptWitn... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x260, %rsp # imm = 0x260
leaq 0x100(%rsp), %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x6e970
callq 0x285981
testb %al, %al
je 0x10b701
callq 0x285981
testb %al, %al
je 0x10b775
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1af651(%rip), %rs... | /p2pderivatives[P]cfd-js/external/cfd-core/test/test_transaction.cpp |
Transaction_AddTxOut_RemoveTxOut_Test::TestBody() | TEST(Transaction, AddTxOut_RemoveTxOut) {
Transaction tx(exp_version, exp_locktime);
Script script("76a9143f1f881ea0e079888a8a9d65025aacf6b98f853588ac");
EXPECT_NO_THROW(tx.AddTxOut(Amount::CreateBySatoshiAmount(100000), script));
EXPECT_EQ(tx.GetTxOutCount(), 1);
EXPECT_NO_THROW(tx.GetTxOut(0));
EXPECT_EQ... | pushq %r15
pushq %r14
pushq %rbx
subq $0x240, %rsp # imm = 0x240
leaq 0xd0(%rsp), %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x6e970
leaq 0x90(%rsp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x1ae83e(%rip), %rsi # 0x2bbd0b
leaq 0x1ae869(%rip), %rdx # 0x2bbd3d
leaq 0x80(%rsp), %rdi
callq 0xb5d70
leaq 0x110(%rsp... | /p2pderivatives[P]cfd-js/external/cfd-core/test/test_transaction.cpp |
Transaction_SetUnlockingScript_Test::~Transaction_SetUnlockingScript_Test() | TEST(Transaction, SetUnlockingScript) {
Transaction tx(exp_version, exp_locktime);
EXPECT_NO_THROW(
tx.AddTxIn(
Txid(
"d4470b3c4b616042e5004b1ab60cb1734d21b8e1c4854c379ec8c3f7ca1e450f"),
0, 4294967294));
EXPECT_NO_THROW(
tx.AddTxIn(
Txid(
"26e0... | pushq %rbx
movq %rdi, %rbx
callq 0x289966
movq %rbx, %rdi
popq %rbx
jmp 0x6e300
| /p2pderivatives[P]cfd-js/external/cfd-core/test/test_transaction.cpp |
Transaction_AddScriptWitnessStack_SetScriptWitnessStack_RemoveScriptWitnessStackAll_Test::~Transaction_AddScriptWitnessStack_SetScriptWitnessStack_RemoveScriptWitnessStackAll_Test() | TEST(Transaction, AddScriptWitnessStack_SetScriptWitnessStack_RemoveScriptWitnessStackAll) {
Transaction tx(exp_version, exp_locktime);
EXPECT_NO_THROW(
tx.AddTxIn(
Txid(
"d4470b3c4b616042e5004b1ab60cb1734d21b8e1c4854c379ec8c3f7ca1e450f"),
0, 4294967294));
// AddScriptWitn... | pushq %rbx
movq %rdi, %rbx
callq 0x289966
movq %rbx, %rdi
popq %rbx
jmp 0x6e300
| /p2pderivatives[P]cfd-js/external/cfd-core/test/test_transaction.cpp |
testing::AssertionResult testing::internal::CmpHelperEQ<char [47], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [47], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | AssertionResult CmpHelperEQ(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs,
const T2& rhs) {
if (lhs == rhs) {
return AssertionSuccess();
}
return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs,... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %r8, %rdi
movq %rcx, %rsi
callq 0x6c7d0
movq %rbx, %rdi
testl %eax, %eax
je 0x1149d5
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x1149e7
jmp 0x1149da
callq... | /p2pderivatives[P]cfd-js/external/googletest/googletest/include/gtest/gtest.h |
AbstractTxIn_ConstractorGetterSetter_Test::TestBody() | TEST(AbstractTxIn, ConstractorGetterSetter) {
const auto check = [](AbstractTxIn actual) -> void {
EXPECT_STREQ(expect_txid.GetHex().c_str(),
actual.GetTxid().GetHex().c_str());
EXPECT_EQ(expect_index, actual.GetVout());
EXPECT_STREQ(expect_txid.GetHex().c_str(),
actual.GetOutPoint().GetTx... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
leaq 0x2e610b(%rip), %rsi # 0x3fada8
leaq 0x2e6144(%rip), %r8 # 0x3fade8
leaq 0x8(%rsp), %rdi
movl $0x1, %edx
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
callq 0x6f520
leaq 0x2d0689(%rip), %r15 # 0x3e5348
leaq 0x130(%rs... | /p2pderivatives[P]cfd-js/external/cfd-core/test/test_abstracttxin.cpp |
AbstractTxIn_ConstractorGetterSetter_Test::TestBody()::$_0::operator()(cfd::core::AbstractTxIn) const | TEST(AbstractTxIn, ConstractorGetterSetter) {
const auto check = [](AbstractTxIn actual) -> void {
EXPECT_STREQ(expect_txid.GetHex().c_str(),
actual.GetTxid().GetHex().c_str());
EXPECT_EQ(expect_index, actual.GetVout());
EXPECT_STREQ(expect_txid.GetHex().c_str(),
actual.GetOutPoint().GetTx... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movq %rdi, %rbx
leaq 0x2e5f10(%rip), %rsi # 0x3fada8
movq %rsp, %r14
movq %r14, %rdi
callq 0x70a50
movq (%r14), %r14
leaq 0x38(%rsp), %rdi
movq %rbx, %rsi
callq 0x6ccf0
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x70a50
movq 0x58(%rsp), %... | /p2pderivatives[P]cfd-js/external/cfd-core/test/test_abstracttxin.cpp |
AbstractTxIn_WitnessStackError_Test::TestBody() | TEST(AbstractTxIn, WitnessStackError) {
AbstractTxIn actual = AbstractTxIn(expect_txid, expect_index, expect_sequence,
expect_unlocking_script);
try {
actual.SetScriptWitnessStack(0, ByteData("0123456789"));
} catch (const CfdException &e) {
EXPECT_STREQ(e.what(), "vi... | pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp # imm = 0x100
leaq 0x2e436b(%rip), %rsi # 0x3fada8
leaq 0x2e43a4(%rip), %r8 # 0x3fade8
leaq 0x70(%rsp), %rdi
movl $0x1, %edx
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
callq 0x6f520
leaq 0x40(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1a79b4(%rip)... | /p2pderivatives[P]cfd-js/external/cfd-core/test/test_abstracttxin.cpp |
AbstractTransaction_AddTxIn_RemoveTxIn_Test::TestBody() | TEST(AbstractTransaction, AddTxIn_RemoveTxIn) {
uint32_t txin_count = 2;
int32_t version = 2;
uint32_t locktime = 3;
uint32_t vout = 0;
uint32_t seq = 0xffffffff;
Transaction tx(version, locktime);
// script is not empty
EXPECT_NO_THROW(
tx.AddTxIn(
Txid(
"e9f71e1f6787f47a... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xe8, %rsp
movl $0x2, 0x64(%rsp)
movl $0x0, 0x60(%rsp)
movl $0xffffffff, 0x5c(%rsp) # imm = 0xFFFFFFFF
leaq 0xa8(%rsp), %rdi
movl $0x2, %esi
movl $0x3, %edx
callq 0x6e970
callq 0x285981
testb %al, %al
je 0x118b57
callq 0x285981
testb %al, %al
je 0x118bc5
leaq 0x98(%rsp)... | /p2pderivatives[P]cfd-js/external/cfd-core/test/test_abstract_transaction.cpp |
AbstractTransaction_SetUnlockingScript_bytedata_Test::TestBody() | TEST(AbstractTransaction, SetUnlockingScript_bytedata) {
int32_t version = 2;
uint32_t locktime = 3;
uint32_t vout = 0;
uint32_t seq = 0xffffffff;
Transaction tx(version, locktime);
tx.AddTxIn(
Txid("e9f71e1f6787f47af671b62f4e29bda856ec3d51a817c62e1cea7f9f0c0190b6"),
vout, seq, Script("76a91410... | pushq %r15
pushq %r14
pushq %rbx
subq $0x160, %rsp # imm = 0x160
leaq 0x120(%rsp), %rdi
movl $0x2, %esi
movl $0x3, %edx
callq 0x6e970
leaq 0x80(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1a4e40(%rip), %rsi # 0x2beae0
leaq 0x1a4e79(%rip), %rdx # 0x2beb20
leaq 0x70(%rsp), %rdi
callq 0xb5d70
leaq 0x8(%rsp)... | /p2pderivatives[P]cfd-js/external/cfd-core/test/test_abstract_transaction.cpp |
AbstractTransaction_AddTxOut_RemoveTxOut_Test::TestBody() | TEST(AbstractTransaction, AddTxOut_RemoveTxOut) {
uint32_t txout_count = 1;
int32_t version = 2;
uint32_t locktime = 3;
uint64_t satoshi = 0x12345678;
Transaction tx(version, locktime);
// script is not empty
EXPECT_NO_THROW(
tx.AddTxOut(Amount::CreateBySatoshiAmount(satoshi),
Scr... | pushq %r14
pushq %rbx
subq $0xd8, %rsp
movl $0x1, 0x3c(%rsp)
movq $0x12345678, 0x78(%rsp) # imm = 0x12345678
leaq 0x98(%rsp), %rdi
movl $0x2, %esi
movl $0x3, %edx
callq 0x6e970
callq 0x285981
testb %al, %al
je 0x11b18e
callq 0x285981
testb %al, %al
je 0x11b202
movq 0x78(%rsp), %rdi
callq 0x6fd30
movq %rax, 0x80(%rsp)
m... | /p2pderivatives[P]cfd-js/external/cfd-core/test/test_abstract_transaction.cpp |
AbstractTransaction_TxSizeByException_Test::TestBody() | TEST(AbstractTransaction, TxSizeByException) {
TestTransaction tx;
EXPECT_EQ(tx.GetTotalSize(), 10);
EXPECT_EQ(tx.GetVsize(), 10);
EXPECT_EQ(tx.GetWeight(), 40);
} | pushq %rbx
subq $0x30, %rsp
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x11d514
movq %rbx, %rdi
callq 0x6e390
movq %rsp, %rcx
movl %eax, (%rcx)
leaq 0x8(%rsp), %r8
movl $0xa, (%r8)
leaq 0x19cf6f(%rip), %rsi # 0x2b9ceb
leaq 0x2086cd(%rip), %rdx # 0x325450
leaq 0x10(%rsp), %rdi
callq 0x113ea1
cmpb $0x0, 0x10(%rsp)... | /p2pderivatives[P]cfd-js/external/cfd-core/test/test_abstract_transaction.cpp |
AbstractTransaction_TxArray_Test::TestBody() | TEST(AbstractTransaction, AddTxIn_RemoveTxIn) {
uint32_t txin_count = 2;
int32_t version = 2;
uint32_t locktime = 3;
uint32_t vout = 0;
uint32_t seq = 0xffffffff;
Transaction tx(version, locktime);
// script is not empty
EXPECT_NO_THROW(
tx.AddTxIn(
Txid(
"e9f71e1f6787f47a... | pushq %rbx
subq $0x40, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
callq 0x11d514
callq 0x285981
testb %al, %al
je 0x11d0b1
callq 0x285981
testb %al, %al
je 0x11d11e
movq %rbx, (%rsp)
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x11d093
movq %rbx, (%rs... | /p2pderivatives[P]cfd-js/external/cfd-core/test/test_abstract_transaction.cpp |
AbstractTransaction_IsCoinBase_Test::TestBody() | TEST(AbstractTransaction, IsCoinBase) {
TestTransaction tx;
bool is_coinbase = false;
EXPECT_NO_THROW((is_coinbase = tx.IsCoinBase()));
EXPECT_FALSE(is_coinbase);
} | pushq %rbx
subq $0x50, %rsp
leaq 0x20(%rsp), %rdi
callq 0x11d514
callq 0x285981
testb %al, %al
je 0x11d1f7
callq 0x285981
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
je 0x11d26d
leaq 0x20(%rsp), %rdi
callq 0x6c600
xorb $0x1, %al
jmp 0x11d26d
movq %rax, %rdi
callq 0x6cca0
callq 0x6fde0
leaq 0x30(%rsp), %rdi
callq 0x28... | /p2pderivatives[P]cfd-js/external/cfd-core/test/test_abstract_transaction.cpp |
Privkey_HasWif_uncompressed_Test::~Privkey_HasWif_uncompressed_Test() | TEST(Privkey, HasWif_uncompressed) {
std::string wif = "5JBb5A38fjjeBnngkvRmCsXN6EY4w8jWvckik3hDvYQMcddGY23";
NetType net_type = NetType::kRegtest;
bool is_compressed = false;
bool has_wif = Privkey::HasWif(wif, &net_type, &is_compressed);
EXPECT_TRUE(has_wif);
EXPECT_FALSE(is_compressed);
EXPECT_EQ(NetTy... | pushq %rbx
movq %rdi, %rbx
callq 0x289966
movq %rbx, %rdi
popq %rbx
jmp 0x6e300
| /p2pderivatives[P]cfd-js/external/cfd-core/test/test_privkey.cpp |
Privkey_TweakConversionTest_Test::~Privkey_TweakConversionTest_Test() | TEST(Privkey, TweakConversionTest) {
Privkey privkey("036b13c5a0dd9935fe175b2b9ff86585c231e734b2148149d788a941f1f4f566");
ByteData256 tweak("98430d10471cf697e2661e31ceb8720750b59a85374290e175799ba5dd06508e");
// test for adding tweak
{
Privkey priv_tweak_added;
EXPECT_NO_THROW(priv_tweak_added = privke... | pushq %rbx
movq %rdi, %rbx
callq 0x289966
movq %rbx, %rdi
popq %rbx
jmp 0x6e300
| /p2pderivatives[P]cfd-js/external/cfd-core/test/test_privkey.cpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> testing::PrintToString<cfd::core::NetType>(cfd::core::NetType const&) | ::std::string PrintToString(const T& value) {
::std::stringstream ss;
internal::UniversalTersePrinter<T>::Print(value, &ss);
return ss.str();
} | pushq %r14
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x6d860
leaq 0x10(%rsp), %rdi
movl (%r14), %esi
callq 0x6cae0
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x6fbf0
movq 0x2cdef3(%rip), %rsi # 0x3f7e28
movq %rsp, %rdi
callq 0x6d970
leaq 0x80(%rsp), ... | /p2pderivatives[P]cfd-js/external/googletest/googletest/include/gtest/gtest-printers.h |
ExtPubkey_DefaultConstructorTest_Test::TestBody() | TEST(ExtPubkey, DefaultConstructorTest) {
ExtPubkey extkey = ExtPubkey();
EXPECT_STREQ("", extkey.GetData().GetHex().c_str());
EXPECT_STREQ("00000000", extkey.GetVersionData().GetHex().c_str());
EXPECT_FALSE(extkey.IsValid());
} | pushq %r14
pushq %rbx
subq $0xc8, %rsp
leaq 0x58(%rsp), %rbx
movq %rbx, %rdi
callq 0x6f150
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x6c560
leaq 0x30(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x6c830
movq 0x30(%rsp), %r8
leaq 0x17e0ca(%rip), %rsi # 0x2a8089
leaq 0x199d75(%rip), %rdx # 0x2c3d3b
leaq 0x222306(%rip... | /p2pderivatives[P]cfd-js/external/cfd-core/test/test_extpubkey.cpp |
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.