name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
wabt::interp::RefPtr<wabt::interp::HostFunc>::RefPtr(wabt::interp::Store&, wabt::interp::Ref) | RefPtr<T>::RefPtr(Store& store, Ref ref) {
#ifndef NDEBUG
if (!store.Is<T>(ref)) {
ObjectKind ref_kind;
if (ref == Ref::Null) {
ref_kind = ObjectKind::Null;
} else {
ref_kind = store.objects_.Get(ref.index)->kind();
}
fprintf(stderr, "Invalid conversion from Ref (%s) to RefPtr<%s>!\n",
GetName(ref_kind), T::GetTypeName());
abort();
}
#endif
root_index_ = store.NewRoot(ref);
obj_ = static_cast<T*>(store.objects_.Get(ref.index).get());
store_ = &store;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
callq 0x1d45c0
testb $0x1, %al
jne 0x1d161c
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x22dda0(%rip), %rax # 0x3ff338
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x1cf640
testb $0x1, %al
jne 0x1d15b2
jmp 0x1d15bb
movl $0x0, -0x24(%rbp)
jmp 0x1d15df
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rsi
callq 0x1d4630
movq %rax, %rdi
callq 0x1d4690
movq %rax, %rdi
callq 0x1d46b0
movl %eax, -0x24(%rbp)
movq 0x1e29fa(%rip), %rax # 0x3b3fe0
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movl -0x24(%rbp), %edi
callq 0x26bb50
movq %rax, -0x50(%rbp)
callq 0x1d46d0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
movq %rax, %rcx
leaq 0x130b7d(%rip), %rsi # 0x30218d
movb $0x0, %al
callq 0x1a6580
callq 0x1a61e0
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
callq 0x26c4f0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rsi
callq 0x1d4630
movq %rax, %rdi
callq 0x1d46e0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
| /dcodeIO[P]wabt/src/interp/interp-inl.h |
unsigned long wabt::interp::FreeList<std::unique_ptr<wabt::interp::Object, std::default_delete<wabt::interp::Object>>>::New<wabt::interp::Table*>(wabt::interp::Table*&&) | auto FreeList<T>::New(Args&&... args) -> Index {
if (!free_.empty()) {
Index index = free_.back();
assert(is_free_[index]);
free_.pop_back();
is_free_[index] = false;
list_[index] = T(std::forward<Args>(args)...);
return index;
}
assert(list_.size() == is_free_.size());
is_free_.push_back(false);
list_.emplace_back(std::forward<Args>(args)...);
return list_.size() - 1;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x18, %rdi
callq 0x1d1690
testb $0x1, %al
jne 0x1d4c33
movq -0x50(%rbp), %rdi
addq $0x18, %rdi
callq 0x1d16d0
movq -0x50(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x20(%rbp)
addq $0x30, %rdi
movq -0x20(%rbp), %rsi
callq 0x1d1710
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1d1770
testb $0x1, %al
jne 0x1d4ba5
jmp 0x1d4ba7
jmp 0x1d4bc6
leaq 0x12d477(%rip), %rdi # 0x302025
leaq 0x12d480(%rip), %rsi # 0x302035
movl $0x92, %edx
leaq 0x12d712(%rip), %rcx # 0x3022d3
callq 0x1a6290
movq -0x50(%rbp), %rdi
addq $0x18, %rdi
callq 0x1d17a0
movq -0x50(%rbp), %rdi
addq $0x30, %rdi
movq -0x20(%rbp), %rsi
callq 0x1d1710
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x1d17d0
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq -0x48(%rbp), %rdi
callq 0x1d1820
movq -0x50(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1d1850
movq %rax, %rdi
leaq -0x48(%rbp), %rsi
callq 0x1d1870
leaq -0x48(%rbp), %rdi
callq 0x1d18a0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1d4ca7
movq -0x50(%rbp), %rdi
callq 0x1d18f0
movq -0x50(%rbp), %rdi
movq %rax, -0x58(%rbp)
addq $0x30, %rdi
callq 0x1d1910
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jne 0x1d4c5b
jmp 0x1d4c7a
leaq 0x12d4d5(%rip), %rdi # 0x302137
leaq 0x12d3cc(%rip), %rsi # 0x302035
movl $0x98, %edx
leaq 0x12d65e(%rip), %rcx # 0x3022d3
callq 0x1a6290
movq -0x50(%rbp), %rdi
addq $0x30, %rdi
xorl %esi, %esi
callq 0x1d1970
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1d4e70
movq -0x50(%rbp), %rdi
callq 0x1d18f0
subq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /dcodeIO[P]wabt/src/interp/interp-inl.h |
wabt::interp::RefPtr<wabt::interp::Table>::RefPtr(wabt::interp::Store&, wabt::interp::Ref) | RefPtr<T>::RefPtr(Store& store, Ref ref) {
#ifndef NDEBUG
if (!store.Is<T>(ref)) {
ObjectKind ref_kind;
if (ref == Ref::Null) {
ref_kind = ObjectKind::Null;
} else {
ref_kind = store.objects_.Get(ref.index)->kind();
}
fprintf(stderr, "Invalid conversion from Ref (%s) to RefPtr<%s>!\n",
GetName(ref_kind), T::GetTypeName());
abort();
}
#endif
root_index_ = store.NewRoot(ref);
obj_ = static_cast<T*>(store.objects_.Get(ref.index).get());
store_ = &store;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
callq 0x1d50c0
testb $0x1, %al
jne 0x1d4dfc
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x22a5c0(%rip), %rax # 0x3ff338
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x1cf640
testb $0x1, %al
jne 0x1d4d92
jmp 0x1d4d9b
movl $0x0, -0x24(%rbp)
jmp 0x1d4dbf
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rsi
callq 0x1d4630
movq %rax, %rdi
callq 0x1d4690
movq %rax, %rdi
callq 0x1d46b0
movl %eax, -0x24(%rbp)
movq 0x1df21a(%rip), %rax # 0x3b3fe0
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movl -0x24(%rbp), %edi
callq 0x26bb50
movq %rax, -0x50(%rbp)
callq 0x1d5130
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
movq %rax, %rcx
leaq 0x12d39d(%rip), %rsi # 0x30218d
movb $0x0, %al
callq 0x1a6580
callq 0x1a61e0
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
callq 0x26c4f0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rsi
callq 0x1d4630
movq %rax, %rdi
callq 0x1d46e0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
| /dcodeIO[P]wabt/src/interp/interp-inl.h |
wabt::interp::RefPtr<wabt::interp::Memory>::RefPtr(wabt::interp::Store&, wabt::interp::Ref) | RefPtr<T>::RefPtr(Store& store, Ref ref) {
#ifndef NDEBUG
if (!store.Is<T>(ref)) {
ObjectKind ref_kind;
if (ref == Ref::Null) {
ref_kind = ObjectKind::Null;
} else {
ref_kind = store.objects_.Get(ref.index)->kind();
}
fprintf(stderr, "Invalid conversion from Ref (%s) to RefPtr<%s>!\n",
GetName(ref_kind), T::GetTypeName());
abort();
}
#endif
root_index_ = store.NewRoot(ref);
obj_ = static_cast<T*>(store.objects_.Get(ref.index).get());
store_ = &store;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
callq 0x1d5810
testb $0x1, %al
jne 0x1d554c
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x229e70(%rip), %rax # 0x3ff338
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x1cf640
testb $0x1, %al
jne 0x1d54e2
jmp 0x1d54eb
movl $0x0, -0x24(%rbp)
jmp 0x1d550f
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rsi
callq 0x1d4630
movq %rax, %rdi
callq 0x1d4690
movq %rax, %rdi
callq 0x1d46b0
movl %eax, -0x24(%rbp)
movq 0x1deaca(%rip), %rax # 0x3b3fe0
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movl -0x24(%rbp), %edi
callq 0x26bb50
movq %rax, -0x50(%rbp)
callq 0x1d5880
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
movq %rax, %rcx
leaq 0x12cc4d(%rip), %rsi # 0x30218d
movb $0x0, %al
callq 0x1a6580
callq 0x1a61e0
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
callq 0x26c4f0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rsi
callq 0x1d4630
movq %rax, %rdi
callq 0x1d46e0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
| /dcodeIO[P]wabt/src/interp/interp-inl.h |
wabt::interp::RefPtr<wabt::interp::Global>::RefPtr(wabt::interp::Store&, wabt::interp::Ref) | RefPtr<T>::RefPtr(Store& store, Ref ref) {
#ifndef NDEBUG
if (!store.Is<T>(ref)) {
ObjectKind ref_kind;
if (ref == Ref::Null) {
ref_kind = ObjectKind::Null;
} else {
ref_kind = store.objects_.Get(ref.index)->kind();
}
fprintf(stderr, "Invalid conversion from Ref (%s) to RefPtr<%s>!\n",
GetName(ref_kind), T::GetTypeName());
abort();
}
#endif
root_index_ = store.NewRoot(ref);
obj_ = static_cast<T*>(store.objects_.Get(ref.index).get());
store_ = &store;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
callq 0x1d5f80
testb $0x1, %al
jne 0x1d5cbc
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x229700(%rip), %rax # 0x3ff338
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x1cf640
testb $0x1, %al
jne 0x1d5c52
jmp 0x1d5c5b
movl $0x0, -0x24(%rbp)
jmp 0x1d5c7f
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rsi
callq 0x1d4630
movq %rax, %rdi
callq 0x1d4690
movq %rax, %rdi
callq 0x1d46b0
movl %eax, -0x24(%rbp)
movq 0x1de35a(%rip), %rax # 0x3b3fe0
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movl -0x24(%rbp), %edi
callq 0x26bb50
movq %rax, -0x50(%rbp)
callq 0x1d5ff0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
movq %rax, %rcx
leaq 0x12c4dd(%rip), %rsi # 0x30218d
movb $0x0, %al
callq 0x1a6580
callq 0x1a61e0
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
callq 0x26c4f0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rsi
callq 0x1d4630
movq %rax, %rdi
callq 0x1d46e0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
| /dcodeIO[P]wabt/src/interp/interp-inl.h |
wabt::interp::Func::classof(wabt::interp::Object const*) | inline bool Func::classof(const Object* obj) {
switch (obj->kind()) {
case ObjectKind::DefinedFunc:
case ObjectKind::HostFunc:
return true;
default:
return false;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d46b0
addl $-0x3, %eax
subl $0x1, %eax
ja 0x1eaa05
jmp 0x1ea9ff
movb $0x1, -0x1(%rbp)
jmp 0x1eaa09
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| /dcodeIO[P]wabt/src/interp/interp-inl.h |
wabt::intrusive_list<wabt::ModuleField>::clear() | inline void intrusive_list<T>::clear() noexcept {
for (T* iter = first_; iter;) {
T* next = iter->next_;
delete iter;
iter = next;
}
first_ = last_ = nullptr;
size_ = 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq (%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1ed3a0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x1ed396
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x1ed36b
movq -0x20(%rbp), %rax
movq $0x0, 0x8(%rax)
movq $0x0, (%rax)
movq $0x0, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /dcodeIO[P]wabt/src/intrusive-list.h |
wabt::interp::RefPtr<wabt::interp::Extern>::RefPtr(wabt::interp::Store&, wabt::interp::Ref) | RefPtr<T>::RefPtr(Store& store, Ref ref) {
#ifndef NDEBUG
if (!store.Is<T>(ref)) {
ObjectKind ref_kind;
if (ref == Ref::Null) {
ref_kind = ObjectKind::Null;
} else {
ref_kind = store.objects_.Get(ref.index)->kind();
}
fprintf(stderr, "Invalid conversion from Ref (%s) to RefPtr<%s>!\n",
GetName(ref_kind), T::GetTypeName());
abort();
}
#endif
root_index_ = store.NewRoot(ref);
obj_ = static_cast<T*>(store.objects_.Get(ref.index).get());
store_ = &store;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
callq 0x1ee0a0
testb $0x1, %al
jne 0x1ee04c
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x211370(%rip), %rax # 0x3ff338
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x1cf640
testb $0x1, %al
jne 0x1edfe2
jmp 0x1edfeb
movl $0x0, -0x24(%rbp)
jmp 0x1ee00f
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rsi
callq 0x1d4630
movq %rax, %rdi
callq 0x1d4690
movq %rax, %rdi
callq 0x1d46b0
movl %eax, -0x24(%rbp)
movq 0x1c5fca(%rip), %rax # 0x3b3fe0
movq (%rax), %rax
movq %rax, -0x58(%rbp)
movl -0x24(%rbp), %edi
callq 0x26bb50
movq %rax, -0x50(%rbp)
callq 0x1ee110
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
movq %rax, %rcx
leaq 0x11414d(%rip), %rsi # 0x30218d
movb $0x0, %al
callq 0x1a6580
callq 0x1a61e0
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rsi
callq 0x26c4f0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movq -0x8(%rbp), %rsi
callq 0x1d4630
movq %rax, %rdi
callq 0x1d46e0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x8(%rax)
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
| /dcodeIO[P]wabt/src/interp/interp-inl.h |
wabt::interp::Extern::classof(wabt::interp::Object const*) | inline bool Extern::classof(const Object* obj) {
switch (obj->kind()) {
case ObjectKind::DefinedFunc:
case ObjectKind::HostFunc:
case ObjectKind::Table:
case ObjectKind::Memory:
case ObjectKind::Global:
case ObjectKind::Event:
return true;
default:
return false;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d46b0
addl $-0x3, %eax
subl $0x5, %eax
ja 0x1ee165
jmp 0x1ee15f
movb $0x1, -0x1(%rbp)
jmp 0x1ee169
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| /dcodeIO[P]wabt/src/interp/interp-inl.h |
wabt::ReadStdin(std::vector<unsigned char, std::allocator<unsigned char>>*) | static Result ReadStdin(std::vector<uint8_t>* out_data) {
out_data->resize(0);
uint8_t buffer[4096];
while (true) {
size_t bytes_read = fread(buffer, 1, sizeof(buffer), stdin);
if (bytes_read == 0) {
if (ferror(stdin)) {
fprintf(stderr, "error reading from stdin: %s\n", strerror(errno));
return Result::Error;
}
return Result::Ok;
}
size_t old_size = out_data->size();
out_data->resize(old_size + bytes_read);
memcpy(out_data->data() + old_size, buffer, bytes_read);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x1030, %rsp # imm = 0x1030
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1ee6d0
leaq -0x1010(%rbp), %rdi
movq 0x1c5a0e(%rip), %rax # 0x3b3fd8
movq (%rax), %rcx
movl $0x1, %esi
movl $0x1000, %edx # imm = 0x1000
callq 0x1a6590
movq %rax, -0x1018(%rbp)
cmpq $0x0, -0x1018(%rbp)
jne 0x1ee653
movq 0x1c59e4(%rip), %rax # 0x3b3fd8
movq (%rax), %rdi
callq 0x1a6690
cmpl $0x0, %eax
je 0x1ee646
movq 0x1c59d8(%rip), %rax # 0x3b3fe0
movq (%rax), %rax
movq %rax, -0x1028(%rbp)
callq 0x1a6070
movl (%rax), %edi
callq 0x1a6100
movq -0x1028(%rbp), %rdi
movq %rax, %rdx
leaq 0x114d5c(%rip), %rsi # 0x30338b
movb $0x0, %al
callq 0x1a6580
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x1ee6a5
leaq -0x4(%rbp), %rdi
xorl %esi, %esi
callq 0x1cba40
jmp 0x1ee6a5
movq -0x10(%rbp), %rdi
callq 0x1cba00
movq %rax, -0x1020(%rbp)
movq -0x10(%rbp), %rdi
movq -0x1020(%rbp), %rsi
addq -0x1018(%rbp), %rsi
callq 0x1ee6d0
movq -0x10(%rbp), %rdi
callq 0x1ce580
movq %rax, %rdi
addq -0x1020(%rbp), %rdi
leaq -0x1010(%rbp), %rsi
movq -0x1018(%rbp), %rdx
callq 0x1a6330
jmp 0x1ee5bc
movl -0x4(%rbp), %eax
addq $0x1030, %rsp # imm = 0x1030
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /dcodeIO[P]wabt/src/common.cc |
wabt::InitStdio() | void InitStdio() {
#if COMPILER_IS_MSVC
int result = _setmode(_fileno(stdout), _O_BINARY);
if (result == -1) {
perror("Cannot set mode binary to stdout");
}
result = _setmode(_fileno(stderr), _O_BINARY);
if (result == -1) {
perror("Cannot set mode binary to stderr");
}
#endif
} | pushq %rbp
movq %rsp, %rbp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /dcodeIO[P]wabt/src/common.cc |
wabt::FormatErrorsToString(std::vector<wabt::Error, std::allocator<wabt::Error>> const&, wabt::Location::Type, wabt::LexerSourceLineFinder*, wabt::Color const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, wabt::PrintHeader, int) | std::string FormatErrorsToString(const Errors& errors,
Location::Type location_type,
LexerSourceLineFinder* line_finder,
const Color& color,
const std::string& header,
PrintHeader print_header,
int source_line_max_length) {
std::string result;
for (const auto& error : errors) {
if (!header.empty()) {
switch (print_header) {
case PrintHeader::Never:
break;
case PrintHeader::Once:
print_header = PrintHeader::Never;
// Fallthrough.
case PrintHeader::Always:
result += header;
result += ":\n";
break;
}
}
int indent = header.empty() ? 0 : 2;
result += FormatError(error, location_type, color, line_finder,
source_line_max_length, indent);
}
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movb $0x0, -0x31(%rbp)
callq 0x1a6560
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x1ef4b0
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x1ef4e0
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1ef510
testb $0x1, %al
jne 0x1eeeda
jmp 0x1eefaf
leaq -0x48(%rbp), %rdi
callq 0x1ef550
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rdi
callq 0x1a6610
testb $0x1, %al
jne 0x1eef4b
movl 0x10(%rbp), %eax
movl %eax, -0x94(%rbp)
testl %eax, %eax
je 0x1eef1d
jmp 0x1eef03
movl -0x94(%rbp), %eax
subl $0x1, %eax
je 0x1eef1f
jmp 0x1eef10
movl -0x94(%rbp), %eax
subl $0x2, %eax
je 0x1eef26
jmp 0x1eef49
jmp 0x1eef49
movl $0x0, 0x10(%rbp)
movq -0x90(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x1a64f0
movq -0x90(%rbp), %rdi
leaq 0x115897(%rip), %rsi # 0x3047db
callq 0x1a63c0
jmp 0x1eef4b
movq -0x30(%rbp), %rdi
callq 0x1a6610
movb %al, %dl
movl $0x2, %eax
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x5c(%rbp)
movq -0x58(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %r8
movl 0x18(%rbp), %r9d
movl -0x5c(%rbp), %eax
leaq -0x80(%rbp), %rdi
movl %eax, (%rsp)
callq 0x1eefe0
movq -0x90(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x1a64f0
leaq -0x80(%rbp), %rdi
callq 0x1a6250
leaq -0x48(%rbp), %rdi
callq 0x1ef570
jmp 0x1eeec4
movb $0x1, -0x31(%rbp)
testb $0x1, -0x31(%rbp)
jne 0x1eefc5
movq -0x90(%rbp), %rdi
callq 0x1a6250
movq -0x88(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /dcodeIO[P]wabt/src/error-formatter.cc |
wabt::(anonymous namespace)::FormatError[abi:cxx11](wabt::Error const&, wabt::Location::Type, wabt::Color const&, wabt::LexerSourceLineFinder*, int, int) | std::string FormatError(const Error& error,
Location::Type location_type,
const Color& color,
LexerSourceLineFinder* line_finder,
int source_line_max_length,
int indent) {
std::string indent_str(indent, ' ');
std::string result = indent_str;
result += color.MaybeBoldCode();
const Location& loc = error.loc;
if (!loc.filename.empty()) {
result += loc.filename.to_string();
result += ":";
}
if (location_type == Location::Type::Text) {
result += StringPrintf("%d:%d: ", loc.line, loc.first_column);
} else if (loc.offset != kInvalidOffset) {
result += StringPrintf("%07" PRIzx ": ", loc.offset);
}
result += color.MaybeRedCode();
result += GetErrorLevelName(error.error_level);
result += ": ";
result += color.MaybeDefaultCode();
result += error.message;
result += '\n';
LexerSourceLineFinder::SourceLine source_line;
if (line_finder) {
line_finder->GetSourceLine(loc, source_line_max_length, &source_line);
}
if (!source_line.line.empty()) {
result += indent_str;
result += source_line.line;
result += '\n';
result += indent_str;
size_t num_spaces = (loc.first_column - 1) - source_line.column_offset;
size_t num_carets = loc.last_column - loc.first_column;
num_carets = std::min(num_carets, source_line.line.size() - num_spaces);
num_carets = std::max<size_t>(num_carets, 1);
result.append(num_spaces, ' ');
result += color.MaybeBoldCode();
result += color.MaybeGreenCode();
result.append(num_carets, '^');
result += color.MaybeDefaultCode();
result += '\n';
}
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdi, -0x118(%rbp)
movq %rdi, %rax
movq %rax, -0x128(%rbp)
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movslq 0x10(%rbp), %rax
movq %rax, -0x120(%rbp)
leaq -0x51(%rbp), %rdi
callq 0x1a6650
movq -0x120(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movl $0x20, %edx
leaq -0x51(%rbp), %rcx
callq 0x1a62a0
leaq -0x51(%rbp), %rdi
callq 0x1a6440
movq -0x118(%rbp), %rdi
movb $0x0, -0x52(%rbp)
leaq -0x50(%rbp), %rsi
callq 0x1a6180
movq -0x20(%rbp), %rdi
callq 0x1ef590
movq -0x118(%rbp), %rdi
movq %rax, %rsi
callq 0x1a63c0
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
callq 0x1ef5d0
testb $0x1, %al
jne 0x1ef0ca
movq -0x60(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x1ff4a0
movq -0x118(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x1a64f0
leaq -0x80(%rbp), %rdi
callq 0x1a6250
movq -0x118(%rbp), %rdi
leaq 0x1124af(%rip), %rsi # 0x301574
callq 0x1a63c0
cmpl $0x0, -0x14(%rbp)
jne 0x1ef114
movq -0x60(%rbp), %rax
movl 0x10(%rax), %edx
movq -0x60(%rbp), %rax
movl 0x14(%rax), %ecx
leaq -0xa0(%rbp), %rdi
leaq 0x1142d7(%rip), %rsi # 0x3033c3
movb $0x0, %al
callq 0x1cd050
movq -0x118(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x1a64f0
leaq -0xa0(%rbp), %rdi
callq 0x1a6250
jmp 0x1ef15d
movq -0x60(%rbp), %rax
cmpq $-0x1, 0x10(%rax)
je 0x1ef15b
movq -0x60(%rbp), %rax
movq 0x10(%rax), %rdx
leaq -0xc0(%rbp), %rdi
leaq 0x114296(%rip), %rsi # 0x3033cb
movb $0x0, %al
callq 0x1cd050
movq -0x118(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x1a64f0
leaq -0xc0(%rbp), %rdi
callq 0x1a6250
jmp 0x1ef15d
movq -0x20(%rbp), %rdi
callq 0x1ef5f0
movq -0x118(%rbp), %rdi
movq %rax, %rsi
callq 0x1a63c0
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0x1ef460
movq -0x118(%rbp), %rdi
movq %rax, %rsi
callq 0x1a63c0
movq -0x118(%rbp), %rdi
leaq 0x11422b(%rip), %rsi # 0x3033c8
callq 0x1a63c0
movq -0x20(%rbp), %rdi
callq 0x1ef630
movq -0x118(%rbp), %rdi
movq %rax, %rsi
callq 0x1a63c0
movq -0x118(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
callq 0x1a64f0
movq -0x118(%rbp), %rdi
movl $0xa, %esi
callq 0x1a6260
leaq -0xe8(%rbp), %rdi
callq 0x1ef670
cmpq $0x0, -0x28(%rbp)
je 0x1ef210
movq -0x28(%rbp), %rdi
movq -0x60(%rbp), %rsi
movslq -0x2c(%rbp), %rdx
leaq -0xe8(%rbp), %rcx
callq 0x1f3f00
movl %eax, -0xec(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x1a6610
testb $0x1, %al
jne 0x1ef380
movq -0x118(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1a64f0
movq -0x118(%rbp), %rdi
leaq -0xe8(%rbp), %rsi
callq 0x1a64f0
movq -0x118(%rbp), %rdi
movl $0xa, %esi
callq 0x1a6260
movq -0x118(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1a64f0
movq -0x60(%rbp), %rax
movl 0x14(%rax), %eax
subl $0x1, %eax
subl -0xc8(%rbp), %eax
cltq
movq %rax, -0xf8(%rbp)
movq -0x60(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x60(%rbp), %rcx
subl 0x14(%rcx), %eax
cltq
movq %rax, -0x100(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x1a62d0
subq -0xf8(%rbp), %rax
movq %rax, -0x108(%rbp)
leaq -0x100(%rbp), %rdi
leaq -0x108(%rbp), %rsi
callq 0x1d0c10
movq (%rax), %rax
movq %rax, -0x100(%rbp)
movq $0x1, -0x110(%rbp)
leaq -0x100(%rbp), %rdi
leaq -0x110(%rbp), %rsi
callq 0x1cff10
movq -0x118(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x100(%rbp)
movq -0xf8(%rbp), %rsi
movl $0x20, %edx
callq 0x1a6430
movq -0x20(%rbp), %rdi
callq 0x1ef590
movq -0x118(%rbp), %rdi
movq %rax, %rsi
callq 0x1a63c0
movq -0x20(%rbp), %rdi
callq 0x1ef690
movq -0x118(%rbp), %rdi
movq %rax, %rsi
callq 0x1a63c0
movq -0x118(%rbp), %rdi
movq -0x100(%rbp), %rsi
movl $0x5e, %edx
callq 0x1a6430
movq -0x20(%rbp), %rdi
callq 0x1ef630
movq -0x118(%rbp), %rdi
movq %rax, %rsi
callq 0x1a63c0
movq -0x118(%rbp), %rdi
movl $0xa, %esi
callq 0x1a6260
movb $0x1, -0x52(%rbp)
leaq -0xe8(%rbp), %rdi
callq 0x1ef6d0
testb $0x1, -0x52(%rbp)
jne 0x1ef3a2
movq -0x118(%rbp), %rdi
callq 0x1a6250
leaq -0x50(%rbp), %rdi
callq 0x1a6250
movq -0x128(%rbp), %rax
addq $0x130, %rsp # imm = 0x130
popq %rbp
retq
nopl (%rax,%rax)
| /dcodeIO[P]wabt/src/error-formatter.cc |
wabt::GetErrorLevelName(wabt::ErrorLevel) | static WABT_INLINE const char* GetErrorLevelName(ErrorLevel error_level) {
switch (error_level) {
case ErrorLevel::Warning:
return "warning";
case ErrorLevel::Error:
return "error";
}
WABT_UNREACHABLE;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
testl %eax, %eax
je 0x1ef481
jmp 0x1ef477
movl -0x10(%rbp), %eax
subl $0x1, %eax
je 0x1ef48e
jmp 0x1ef49b
leaq 0x113f56(%rip), %rax # 0x3033de
movq %rax, -0x8(%rbp)
jmp 0x1ef4a0
leaq 0x11cfd6(%rip), %rax # 0x30c46b
movq %rax, -0x8(%rbp)
jmp 0x1ef4a0
callq 0x1a61e0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /dcodeIO[P]wabt/src/error.h |
wabt::Features::AddOptions(wabt::OptionParser*) | void Features::AddOptions(OptionParser* parser) {
#define WABT_FEATURE(variable, flag, default_, help) \
if (default_ == true) { \
parser->AddOption("disable-" flag, "Disable " help, \
[this]() { disable_##variable(); }); \
} else { \
parser->AddOption("enable-" flag, "Enable " help, \
[this]() { enable_##variable(); }); \
}
#include "src/feature.def"
#undef WABT_FEATURE
parser->AddOption("enable-all", "Enable all features",
[this]() { EnableAll(); });
} | pushq %rbp
movq %rsp, %rbp
subq $0x2c0, %rsp # imm = 0x2C0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x250(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x2b8(%rbp)
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1efc40
movq -0x2b8(%rbp), %rdi
leaq 0x114029(%rip), %rsi # 0x3037d1
leaq 0x114034(%rip), %rdx # 0x3037e3
leaq -0x30(%rbp), %rcx
callq 0x1f9410
leaq -0x30(%rbp), %rdi
callq 0x1e0c10
movq -0x250(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x2b0(%rbp)
movq %rax, -0x60(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1efcc0
movq -0x2b0(%rbp), %rdi
leaq 0x114018(%rip), %rsi # 0x30380a
leaq 0x114029(%rip), %rdx # 0x303822
leaq -0x58(%rbp), %rcx
callq 0x1f9410
leaq -0x58(%rbp), %rdi
callq 0x1e0c10
movq -0x250(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x2a8(%rbp)
movq %rax, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x1efd40
movq -0x2a8(%rbp), %rdi
leaq 0x114006(%rip), %rsi # 0x303848
leaq 0x11401f(%rip), %rdx # 0x303868
leaq -0x80(%rbp), %rcx
callq 0x1f9410
leaq -0x80(%rbp), %rdi
callq 0x1e0c10
movq -0x250(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x2a0(%rbp)
movq %rax, -0xb0(%rbp)
leaq -0xa8(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x1efdc0
movq -0x2a0(%rbp), %rdi
leaq 0x113ffd(%rip), %rsi # 0x303892
leaq 0x11400d(%rip), %rdx # 0x3038a9
leaq -0xa8(%rbp), %rcx
callq 0x1f9410
leaq -0xa8(%rbp), %rdi
callq 0x1e0c10
movq -0x250(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x298(%rbp)
movq %rax, -0xd8(%rbp)
leaq -0xd0(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x1efe40
movq -0x298(%rbp), %rdi
leaq 0x113fdc(%rip), %rsi # 0x3038ca
leaq 0x113fe1(%rip), %rdx # 0x3038d6
leaq -0xd0(%rbp), %rcx
callq 0x1f9410
leaq -0xd0(%rbp), %rdi
callq 0x1e0c10
movq -0x250(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x290(%rbp)
movq %rax, -0x100(%rbp)
leaq -0xf8(%rbp), %rdi
leaq -0x100(%rbp), %rsi
callq 0x1efec0
movq -0x290(%rbp), %rdi
leaq 0x113fa3(%rip), %rsi # 0x3038ea
leaq 0x113fab(%rip), %rdx # 0x3038f9
leaq -0xf8(%rbp), %rcx
callq 0x1f9410
leaq -0xf8(%rbp), %rdi
callq 0x1e0c10
movq -0x250(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x288(%rbp)
movq %rax, -0x128(%rbp)
leaq -0x120(%rbp), %rdi
leaq -0x128(%rbp), %rsi
callq 0x1eff40
movq -0x288(%rbp), %rdi
leaq 0x113f72(%rip), %rsi # 0x303912
leaq 0x113f7f(%rip), %rdx # 0x303926
leaq -0x120(%rbp), %rcx
callq 0x1f9410
leaq -0x120(%rbp), %rdi
callq 0x1e0c10
movq -0x250(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x280(%rbp)
movq %rax, -0x150(%rbp)
leaq -0x148(%rbp), %rdi
leaq -0x150(%rbp), %rsi
callq 0x1effc0
movq -0x280(%rbp), %rdi
leaq 0x113f41(%rip), %rsi # 0x30393a
leaq 0x113f4b(%rip), %rdx # 0x30394b
leaq -0x148(%rbp), %rcx
callq 0x1f9410
leaq -0x148(%rbp), %rdi
callq 0x1e0c10
movq -0x250(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x278(%rbp)
movq %rax, -0x178(%rbp)
leaq -0x170(%rbp), %rdi
leaq -0x178(%rbp), %rsi
callq 0x1f0040
movq -0x278(%rbp), %rdi
leaq 0x113f12(%rip), %rsi # 0x303964
leaq 0x113f1e(%rip), %rdx # 0x303977
leaq -0x170(%rbp), %rcx
callq 0x1f9410
leaq -0x170(%rbp), %rdi
callq 0x1e0c10
movq -0x250(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x270(%rbp)
movq %rax, -0x1a0(%rbp)
leaq -0x198(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0x1f00c0
movq -0x270(%rbp), %rdi
leaq 0x113eea(%rip), %rsi # 0x303995
leaq 0x113efa(%rip), %rdx # 0x3039ac
leaq -0x198(%rbp), %rcx
callq 0x1f9410
leaq -0x198(%rbp), %rdi
callq 0x1e0c10
movq -0x250(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x268(%rbp)
movq %rax, -0x1c8(%rbp)
leaq -0x1c0(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x1f0140
movq -0x268(%rbp), %rdi
leaq 0x113ecb(%rip), %rsi # 0x3039cf
leaq 0x113ed7(%rip), %rdx # 0x3039e2
leaq -0x1c0(%rbp), %rcx
callq 0x1f9410
leaq -0x1c0(%rbp), %rdi
callq 0x1e0c10
movq -0x250(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x260(%rbp)
movq %rax, -0x1f0(%rbp)
leaq -0x1e8(%rbp), %rdi
leaq -0x1f0(%rbp), %rsi
callq 0x1f01c0
movq -0x260(%rbp), %rdi
leaq 0x113ea5(%rip), %rsi # 0x303a02
leaq 0x113ea8(%rip), %rdx # 0x303a0c
leaq -0x1e8(%rbp), %rcx
callq 0x1f9410
leaq -0x1e8(%rbp), %rdi
callq 0x1e0c10
movq -0x250(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x258(%rbp)
movq %rax, -0x218(%rbp)
leaq -0x210(%rbp), %rdi
leaq -0x218(%rbp), %rsi
callq 0x1f0240
movq -0x258(%rbp), %rdi
leaq 0x113e70(%rip), %rsi # 0x303a26
leaq 0x113e79(%rip), %rdx # 0x303a36
leaq -0x210(%rbp), %rcx
callq 0x1f9410
leaq -0x210(%rbp), %rdi
callq 0x1e0c10
movq -0x250(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x248(%rbp)
movq %rax, -0x240(%rbp)
leaq -0x238(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0x1f02c0
movq -0x248(%rbp), %rdi
leaq 0x113e3c(%rip), %rsi # 0x303a4b
leaq 0x113e40(%rip), %rdx # 0x303a56
leaq -0x238(%rbp), %rcx
callq 0x1f9410
leaq -0x238(%rbp), %rdi
callq 0x1e0c10
addq $0x2c0, %rsp # imm = 0x2C0
popq %rbp
retq
nopw (%rax,%rax)
| /dcodeIO[P]wabt/src/feature.cc |
wabt::Features::UpdateDependencies() | void Features::UpdateDependencies() {
// Exception handling requires reference types.
if (exceptions_enabled_) {
reference_types_enabled_ = true;
}
// Reference types requires bulk memory.
if (reference_types_enabled_) {
bulk_memory_enabled_ = true;
}
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, (%rax)
je 0x1f035d
movq -0x10(%rbp), %rax
movb $0x1, 0x9(%rax)
movq -0x10(%rbp), %rax
testb $0x1, 0x9(%rax)
je 0x1f036f
movq -0x10(%rbp), %rax
movb $0x1, 0x8(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /dcodeIO[P]wabt/src/feature.cc |
wabt::Features::EnableAll() | void EnableAll() {
#define WABT_FEATURE(variable, flag, default_, help) enable_##variable();
#include "src/feature.def"
#undef WABT_FEATURE
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x1f3020
movq -0x10(%rbp), %rdi
callq 0x1f34c0
movq -0x10(%rbp), %rdi
callq 0x1f34e0
movq -0x10(%rbp), %rdi
callq 0x1f3500
movq -0x10(%rbp), %rdi
callq 0x1f3160
movq -0x10(%rbp), %rdi
callq 0x1f31b0
movq -0x10(%rbp), %rdi
callq 0x1f3520
movq -0x10(%rbp), %rdi
callq 0x1f3250
movq -0x10(%rbp), %rdi
callq 0x1f32a0
movq -0x10(%rbp), %rdi
callq 0x1f32f0
movq -0x10(%rbp), %rdi
callq 0x1f3340
movq -0x10(%rbp), %rdi
callq 0x1f3390
movq -0x10(%rbp), %rdi
callq 0x1f33e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /dcodeIO[P]wabt/src/feature.h |
wabt::WastParser::ParseRegisterCommand(std::unique_ptr<wabt::Command, std::default_delete<wabt::Command>>*) | Result WastParser::ParseRegisterCommand(CommandPtr* out_command) {
WABT_TRACE(ParseRegisterCommand);
EXPECT(Lpar);
Location loc = GetLocation();
EXPECT(Register);
std::string text;
Var var;
CHECK_RESULT(ParseQuotedText(&text));
ParseVarOpt(&var, Var(last_module_index_, loc));
EXPECT(Rpar);
out_command->reset(new RegisterCommand(text, var));
return Result::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x140(%rbp)
movq -0x140(%rbp), %rdi
movl $0x18, %esi
callq 0x218040
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x228950
jmp 0x228963
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x228b31
jmp 0x228965
movq -0x140(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x217ae0
movq -0x140(%rbp), %rdi
movl $0x22, %esi
callq 0x218040
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x228997
jmp 0x2289aa
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x228b31
jmp 0x2289ac
leaq -0x68(%rbp), %rdi
callq 0x1a6560
leaq -0xd0(%rbp), %rdi
callq 0x1e13a0
leaq -0xb0(%rbp), %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
leaq -0xd0(%rbp), %rdx
callq 0x2dccd0
movq -0x140(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x21b0f0
movl %eax, -0xd4(%rbp)
movl -0xd4(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x228a00
jmp 0x228a1d
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
movl $0x1, -0xd8(%rbp)
jmp 0x228b1c
jmp 0x228a1f
jmp 0x228a21
movq -0x140(%rbp), %rax
movl 0x8(%rax), %esi
leaq -0x120(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0x2dccd0
movq -0x140(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
leaq -0x120(%rbp), %rdx
callq 0x2189c0
leaq -0x120(%rbp), %rdi
callq 0x2dcfd0
movq -0x140(%rbp), %rdi
movl $0x24, %esi
callq 0x218040
movl %eax, -0x124(%rbp)
movl -0x124(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x228a89
jmp 0x228aa3
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
movl $0x1, -0xd8(%rbp)
jmp 0x228b1c
jmp 0x228aa5
jmp 0x228aa7
movq -0x18(%rbp), %rax
movq %rax, -0x150(%rbp)
movl $0x78, %edi
callq 0x1a63e0
movq %rax, -0x148(%rbp)
leaq -0x138(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x1cbf50
movq -0x148(%rbp), %rdi
movq -0x138(%rbp), %rsi
movq -0x130(%rbp), %rdx
leaq -0xb0(%rbp), %rcx
callq 0x231ce0
movq -0x150(%rbp), %rdi
movq -0x148(%rbp), %rsi
callq 0x231cb0
leaq -0x4(%rbp), %rdi
xorl %esi, %esi
callq 0x1cba40
movl $0x1, -0xd8(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x2dcfd0
leaq -0x68(%rbp), %rdi
callq 0x1a6250
movl -0x4(%rbp), %eax
addq $0x150, %rsp # imm = 0x150
popq %rbp
retq
nopl (%rax)
| /dcodeIO[P]wabt/src/wast-parser.cc |
wabt::interp::Store::CopyRoot(unsigned long) | Store::RootList::Index Store::CopyRoot(RootList::Index index) {
// roots_.Get() returns a reference to an element in an internal vector, and
// roots_.New() might forward its arguments to emplace_back on the same
// vector. This seems to "work" in most environments, but fails on Visual
// Studio 2015 Win64. Copying it to a value fixes the issue.
auto obj_index = roots_.Get(index);
return roots_.New(obj_index);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x68, %rdi
movq -0x10(%rbp), %rsi
callq 0x1ed6e0
movq -0x20(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x18(%rbp)
addq $0x68, %rdi
leaq -0x18(%rbp), %rsi
callq 0x278e00
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::Memory::Copy(wabt::interp::Memory&, unsigned long, wabt::interp::Memory const&, unsigned long, unsigned long) | Result Memory::Copy(Memory& dst,
u64 dst_offset,
const Memory& src,
u64 src_offset,
u64 size) {
if (dst.IsValidAccess(dst_offset, 0, size) &&
src.IsValidAccess(src_offset, 0, size)) {
#if WABT_BIG_ENDIAN
auto src_begin = src.data_.end() - src_offset - size;
auto dst_begin = dst.data_.end() - dst_offset - size;
#else
auto src_begin = src.data_.begin() + src_offset;
auto dst_begin = dst.data_.begin() + dst_offset;
#endif
auto src_end = src_begin + size;
auto dst_end = dst_begin + size;
if (src.self() == dst.self() && src_begin < dst_begin) {
std::move_backward(src_begin, src_end, dst_end);
} else {
std::move(src_begin, src_end, dst_begin);
}
return Result::Ok;
}
return Result::Error;
} | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0x27a1f0
testb $0x1, %al
jne 0x26e15d
jmp 0x26e2bf
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0x27a1f0
testb $0x1, %al
jne 0x26e17b
jmp 0x26e2bf
movq -0x20(%rbp), %rdi
addq $0x68, %rdi
callq 0x1dd9d0
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x27a3d0
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
addq $0x68, %rdi
callq 0x23c450
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x27a300
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x27a3d0
movq %rax, -0x58(%rbp)
movq -0x30(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x27a300
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rdi
callq 0x279e20
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
callq 0x279e20
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x1cf640
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0xb1(%rbp)
jne 0x26e219
jmp 0x26e22c
leaq -0x38(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x27a410
movb %al, -0xb1(%rbp)
movb -0xb1(%rbp), %al
testb $0x1, %al
jne 0x26e238
jmp 0x26e270
movq -0x38(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x78(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x88(%rbp), %rdx
callq 0x27a450
movq %rax, -0x90(%rbp)
jmp 0x26e2b2
movq -0x38(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x98(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
callq 0x27a4c0
movq %rax, -0xb0(%rbp)
leaq -0x4(%rbp), %rdi
xorl %esi, %esi
callq 0x1cba40
jmp 0x26e2cd
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax)
| /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::Instance::ResolveInitExpr(wabt::interp::Store&, wabt::interp::InitExpr) | Value Instance::ResolveInitExpr(Store& store, InitExpr init) {
Value result;
switch (init.kind) {
case InitExprKind::I32: result.Set(init.i32_); break;
case InitExprKind::I64: result.Set(init.i64_); break;
case InitExprKind::F32: result.Set(init.f32_); break;
case InitExprKind::F64: result.Set(init.f64_); break;
case InitExprKind::V128: result.Set(init.v128_); break;
case InitExprKind::GlobalGet: {
Global::Ptr global{store, globals_[init.index_]};
result = global->Get();
break;
}
case InitExprKind::RefFunc: {
result.Set(funcs_[init.index_]);
break;
}
case InitExprKind::RefNull:
result.Set(Ref::Null);
break;
case InitExprKind::None:
WABT_UNREACHABLE;
}
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
leaq 0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
callq 0x1cfb80
movq -0x78(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x70(%rbp)
subq $0x8, %rax
ja 0x26e49f
movq -0x70(%rbp), %rax
leaq 0x9c2e8(%rip), %rcx # 0x30a620
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x90(%rbp), %rdi
movq -0x78(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x1cb760
jmp 0x26e49f
movq -0x90(%rbp), %rdi
movq -0x78(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x1cb830
jmp 0x26e49f
movq -0x90(%rbp), %rdi
movq -0x78(%rbp), %rax
movss 0x8(%rax), %xmm0
callq 0x1cb8a0
jmp 0x26e49f
movq -0x90(%rbp), %rdi
movq -0x78(%rbp), %rax
movsd 0x8(%rax), %xmm0
callq 0x1cb940
jmp 0x26e49f
movq -0x90(%rbp), %rdi
movq -0x78(%rbp), %rax
movq 0x8(%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1cbe60
jmp 0x26e49f
movq -0x78(%rbp), %rax
movq -0x80(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq %rcx, -0x98(%rbp)
addq $0xa8, %rdi
movl 0x8(%rax), %eax
movl %eax, %esi
callq 0x1ed7a0
movq -0x98(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x1d5bf0
leaq -0x38(%rbp), %rdi
callq 0x1d5d10
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
callq 0x1ce4b0
movq -0x90(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, (%rax)
movq -0x50(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl -0x48(%rbp), %ecx
movl %ecx, 0x10(%rax)
leaq -0x38(%rbp), %rdi
callq 0x1cd8e0
jmp 0x26e49f
movq -0x78(%rbp), %rax
movq -0x80(%rbp), %rdi
addq $0x60, %rdi
movl 0x8(%rax), %eax
movl %eax, %esi
callq 0x1ed7a0
movq -0x90(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rsi
callq 0x1cbef0
jmp 0x26e49f
movq -0x90(%rbp), %rdi
movq 0x190ead(%rip), %rax # 0x3ff338
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rsi
callq 0x1cbef0
jmp 0x26e49f
callq 0x1a61e0
movq -0x88(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nop
| /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::ElemSegment::ElemSegment(wabt::interp::ElemDesc const*, wabt::interp::RefPtr<wabt::interp::Instance>&) | ElemSegment::ElemSegment(const ElemDesc* desc, Instance::Ptr& inst)
: desc_(desc) {
elements_.reserve(desc->elements.size());
for (auto&& elem_expr : desc->elements) {
switch (elem_expr.kind) {
case ElemKind::RefNull:
elements_.emplace_back(Ref::Null);
break;
case ElemKind::RefFunc:
elements_.emplace_back(inst->funcs_[elem_expr.index]);
break;
}
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
callq 0x1cf2e0
movq -0x48(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1dcca0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x27a990
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1dcda0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1dcdd0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x27aa90
testb $0x1, %al
jne 0x26e7a5
jmp 0x26e827
leaq -0x28(%rbp), %rdi
callq 0x27aad0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4c(%rbp)
testl %eax, %eax
je 0x26e7cb
jmp 0x26e7c1
movl -0x4c(%rbp), %eax
subl $0x1, %eax
je 0x26e7e1
jmp 0x26e817
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
leaq 0x190b5e(%rip), %rsi # 0x3ff338
callq 0x27aaf0
jmp 0x26e817
movq -0x48(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1cf030
movq %rax, %rdi
addq $0x60, %rdi
movq -0x38(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %esi
callq 0x1ed7a0
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x27ab60
jmp 0x26e819
leaq -0x28(%rbp), %rdi
callq 0x27abd0
jmp 0x26e78f
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
| /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::Module::Module(wabt::interp::Store&, wabt::interp::ModuleDesc) | Module::Module(Store&, ModuleDesc desc)
: Object(skind), desc_(std::move(desc)) {
for (auto&& import: desc_.imports) {
import_types_.emplace_back(import.type);
}
for (auto&& export_: desc_.exports) {
export_types_.emplace_back(export_.type);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdx, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movl $0x9, %esi
callq 0x278da0
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdi
leaq 0x1440df(%rip), %rax # 0x3b2988
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x40, %rdi
callq 0x1d7700
movq -0x60(%rbp), %rdi
addq $0x160, %rdi # imm = 0x160
callq 0x27ac10
movq -0x60(%rbp), %rdi
addq $0x178, %rdi # imm = 0x178
callq 0x27ac30
movq -0x60(%rbp), %rax
addq $0x40, %rax
addq $0x18, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x25f4c0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x25f300
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x27ac50
testb $0x1, %al
jne 0x26e916
jmp 0x26e942
leaq -0x28(%rbp), %rdi
callq 0x27ac90
movq -0x60(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0x160, %rdi # imm = 0x160
movq -0x38(%rbp), %rsi
callq 0x27acb0
leaq -0x28(%rbp), %rdi
callq 0x27ad20
jmp 0x26e903
movq -0x60(%rbp), %rax
addq $0x40, %rax
addq $0xa8, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x2640a0
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x263ed0
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x27ad40
testb $0x1, %al
jne 0x26e981
jmp 0x26e9ad
leaq -0x48(%rbp), %rdi
callq 0x27ad80
movq -0x60(%rbp), %rdi
movq %rax, -0x58(%rbp)
addq $0x178, %rdi # imm = 0x178
movq -0x58(%rbp), %rsi
callq 0x27ada0
leaq -0x48(%rbp), %rdi
callq 0x27ae10
jmp 0x26e96e
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::Instance::Instantiate(wabt::interp::Store&, wabt::interp::Ref, std::vector<wabt::interp::Ref, std::allocator<wabt::interp::Ref>> const&, wabt::interp::RefPtr<wabt::interp::Trap>*) | Instance::Ptr Instance::Instantiate(Store& store,
Ref module,
const RefVec& imports,
Trap::Ptr* out_trap) {
Module::Ptr mod{store, module};
Instance::Ptr inst = store.Alloc<Instance>(store, module);
size_t import_desc_count = mod->desc().imports.size();
if (imports.size() < import_desc_count) {
*out_trap = Trap::New(store, "not enough imports!");
return {};
}
// Imports.
for (size_t i = 0; i < import_desc_count; ++i) {
auto&& import_desc = mod->desc().imports[i];
Ref extern_ref = imports[i];
if (extern_ref == Ref::Null) {
*out_trap = Trap::New(store, StringPrintf("invalid import \"%s.%s\"",
import_desc.type.module.c_str(),
import_desc.type.name.c_str()));
return {};
}
Extern::Ptr extern_{store, extern_ref};
if (Failed(extern_->Match(store, import_desc.type, out_trap))) {
return {};
}
inst->imports_.push_back(extern_ref);
switch (import_desc.type.type->kind) {
case ExternKind::Func: inst->funcs_.push_back(extern_ref); break;
case ExternKind::Table: inst->tables_.push_back(extern_ref); break;
case ExternKind::Memory: inst->memories_.push_back(extern_ref); break;
case ExternKind::Global: inst->globals_.push_back(extern_ref); break;
case ExternKind::Event: inst->events_.push_back(extern_ref); break;
}
}
// Funcs.
for (auto&& desc : mod->desc().funcs) {
inst->funcs_.push_back(DefinedFunc::New(store, inst.ref(), desc).ref());
}
// Tables.
for (auto&& desc : mod->desc().tables) {
inst->tables_.push_back(Table::New(store, desc.type).ref());
}
// Memories.
for (auto&& desc : mod->desc().memories) {
inst->memories_.push_back(Memory::New(store, desc.type).ref());
}
// Globals.
for (auto&& desc : mod->desc().globals) {
inst->globals_.push_back(
Global::New(store, desc.type, inst->ResolveInitExpr(store, desc.init))
.ref());
}
// Events.
for (auto&& desc : mod->desc().events) {
inst->events_.push_back(Event::New(store, desc.type).ref());
}
// Exports.
for (auto&& desc : mod->desc().exports){
Ref ref;
switch (desc.type.type->kind) {
case ExternKind::Func: ref = inst->funcs_[desc.index]; break;
case ExternKind::Table: ref = inst->tables_[desc.index]; break;
case ExternKind::Memory: ref = inst->memories_[desc.index]; break;
case ExternKind::Global: ref = inst->globals_[desc.index]; break;
case ExternKind::Event: ref = inst->events_[desc.index]; break;
}
inst->exports_.push_back(ref);
}
// Elems.
for (auto&& desc : mod->desc().elems) {
inst->elems_.emplace_back(&desc, inst);
}
// Datas.
for (auto&& desc : mod->desc().datas) {
inst->datas_.emplace_back(&desc);
}
// Initialization.
enum Pass { Check, Init };
int pass = store.features().bulk_memory_enabled() ? Init : Check;
for (; pass <= Init; ++pass) {
// Elems.
for (auto&& segment : inst->elems_) {
auto&& desc = segment.desc();
if (desc.mode == SegmentMode::Active) {
Result result;
Table::Ptr table{store, inst->tables_[desc.table_index]};
u32 offset = inst->ResolveInitExpr(store, desc.offset).Get<u32>();
if (pass == Check) {
result = table->IsValidRange(offset, segment.size()) ? Result::Ok
: Result::Error;
} else {
result = table->Init(store, offset, segment, 0, segment.size());
segment.Drop();
}
if (Failed(result)) {
*out_trap = Trap::New(
store, StringPrintf(
"out of bounds table access: elem segment is "
"out of bounds: [%u, %" PRIu64 ") >= max value %u",
offset, u64{offset} + segment.size(), table->size()));
return {};
}
} else if (desc.mode == SegmentMode::Declared) {
segment.Drop();
}
}
// Data.
for (auto&& segment : inst->datas_) {
auto&& desc = segment.desc();
if (desc.mode == SegmentMode::Active) {
Result result;
Memory::Ptr memory{store, inst->memories_[desc.memory_index]};
u32 offset = inst->ResolveInitExpr(store, desc.offset).Get<u32>();
if (pass == Check) {
result = memory->IsValidAccess(offset, 0, segment.size())
? Result::Ok
: Result::Error;
} else {
result = memory->Init(offset, segment, 0, segment.size());
segment.Drop();
}
if (Failed(result)) {
*out_trap = Trap::New(
store,
StringPrintf("out of bounds memory access: data segment is "
"out of bounds: [%u, %" PRIu64 ") >= max value %"
PRIu64, offset, u64{offset} + segment.size(),
memory->ByteSize()));
return {};
}
} else if (desc.mode == SegmentMode::Declared) {
segment.Drop();
}
}
}
// Start.
for (auto&& start : mod->desc().starts) {
Func::Ptr func{store, inst->funcs_[start.func_index]};
Values results;
if (Failed(func->Call(store, {}, results, out_trap))) {
return {};
}
}
return inst;
} | pushq %rbp
movq %rsp, %rbp
subq $0x800, %rsp # imm = 0x800
movq %rdi, -0x6a8(%rbp)
movq %rdi, %rax
movq %rax, -0x6a0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x1cf070
movq -0x18(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x60(%rbp), %rdi
leaq -0x10(%rbp), %rcx
callq 0x27ae70
leaq -0x40(%rbp), %rdi
callq 0x1cee20
movq %rax, %rdi
callq 0x1cee40
movq %rax, %rdi
addq $0x18, %rdi
callq 0x1d9430
movq %rax, -0x68(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1ed7c0
cmpq -0x68(%rbp), %rax
jae 0x26ec65
movq -0x18(%rbp), %rax
movq %rax, -0x6b0(%rbp)
leaq -0xa1(%rbp), %rdi
callq 0x1a6650
leaq -0xa0(%rbp), %rdi
leaq 0x9c868(%rip), %rsi # 0x30b42f
leaq -0xa1(%rbp), %rdx
callq 0x1a6550
leaq -0xc0(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x1a61d0
leaq -0xc0(%rbp), %rdi
callq 0x27af80
movq -0x6b0(%rbp), %rsi
leaq -0x80(%rbp), %rdi
leaq -0xa0(%rbp), %rdx
leaq -0xc0(%rbp), %rcx
callq 0x27af40
movq -0x28(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x27afa0
leaq -0x80(%rbp), %rdi
callq 0x1cf440
leaq -0xc0(%rbp), %rdi
callq 0x27b000
leaq -0xa0(%rbp), %rdi
callq 0x1a6250
leaq -0xa1(%rbp), %rdi
callq 0x1a6440
movq -0x6a8(%rbp), %rdi
callq 0x27b050
movl $0x1, -0xc4(%rbp)
jmp 0x27025e
movq $0x0, -0xd0(%rbp)
movq -0xd0(%rbp), %rax
cmpq -0x68(%rbp), %rax
jae 0x26ef88
leaq -0x40(%rbp), %rdi
callq 0x1cee20
movq %rax, %rdi
callq 0x1cee40
movq %rax, %rdi
addq $0x18, %rdi
movq -0xd0(%rbp), %rsi
callq 0x27b080
movq %rax, -0xd8(%rbp)
movq -0x20(%rbp), %rdi
movq -0xd0(%rbp), %rsi
callq 0x1cf260
movq (%rax), %rax
movq %rax, -0xe0(%rbp)
movq -0xe0(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq 0x19065d(%rip), %rax # 0x3ff338
movq %rax, -0xf0(%rbp)
movq -0xe8(%rbp), %rdi
movq -0xf0(%rbp), %rsi
callq 0x1cf640
testb $0x1, %al
jne 0x26ecfe
jmp 0x26edda
movq -0x18(%rbp), %rax
movq %rax, -0x6b8(%rbp)
movq -0xd8(%rbp), %rdi
callq 0x1a6170
movq %rax, -0x6c0(%rbp)
movq -0xd8(%rbp), %rdi
addq $0x20, %rdi
callq 0x1a6170
movq -0x6c0(%rbp), %rdx
movq %rax, %rcx
leaq -0x128(%rbp), %rdi
leaq 0x9c6ff(%rip), %rsi # 0x30b443
movb $0x0, %al
callq 0x1cd050
leaq -0x140(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x1a61d0
leaq -0x140(%rbp), %rdi
callq 0x27af80
movq -0x6b8(%rbp), %rsi
leaq -0x108(%rbp), %rdi
leaq -0x128(%rbp), %rdx
leaq -0x140(%rbp), %rcx
callq 0x27af40
movq -0x28(%rbp), %rdi
leaq -0x108(%rbp), %rsi
callq 0x27afa0
leaq -0x108(%rbp), %rdi
callq 0x1cf440
leaq -0x140(%rbp), %rdi
callq 0x27b000
leaq -0x128(%rbp), %rdi
callq 0x1a6250
movq -0x6a8(%rbp), %rdi
callq 0x27b050
movl $0x1, -0xc4(%rbp)
jmp 0x27025e
movq -0x18(%rbp), %rsi
movq -0xe0(%rbp), %rax
movq %rax, -0x160(%rbp)
movq -0x160(%rbp), %rdx
leaq -0x158(%rbp), %rdi
callq 0x1edf80
leaq -0x158(%rbp), %rdi
callq 0x27b0a0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0xd8(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, -0x164(%rbp)
movl -0x164(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x26ee3a
jmp 0x26ee55
movq -0x6a8(%rbp), %rdi
callq 0x27b050
movl $0x1, -0xc4(%rbp)
jmp 0x26ef53
leaq -0x60(%rbp), %rdi
callq 0x1cf030
movq %rax, %rdi
addq $0x48, %rdi
leaq -0xe0(%rbp), %rsi
callq 0x1cef20
movq -0xd8(%rbp), %rdi
addq $0x40, %rdi
callq 0x1d98c0
movl 0x8(%rax), %eax
movq %rax, -0x6c8(%rbp)
subq $0x4, %rax
ja 0x26ef49
movq -0x6c8(%rbp), %rax
leaq 0x9b7b5(%rip), %rcx # 0x30a658
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq -0x60(%rbp), %rdi
callq 0x1cf030
movq %rax, %rdi
addq $0x60, %rdi
leaq -0xe0(%rbp), %rsi
callq 0x1cef20
jmp 0x26ef49
leaq -0x60(%rbp), %rdi
callq 0x1cf030
movq %rax, %rdi
addq $0x78, %rdi
leaq -0xe0(%rbp), %rsi
callq 0x1cef20
jmp 0x26ef49
leaq -0x60(%rbp), %rdi
callq 0x1cf030
movq %rax, %rdi
addq $0x90, %rdi
leaq -0xe0(%rbp), %rsi
callq 0x1cef20
jmp 0x26ef49
leaq -0x60(%rbp), %rdi
callq 0x1cf030
movq %rax, %rdi
addq $0xa8, %rdi
leaq -0xe0(%rbp), %rsi
callq 0x1cef20
jmp 0x26ef49
leaq -0x60(%rbp), %rdi
callq 0x1cf030
movq %rax, %rdi
addq $0xc0, %rdi
leaq -0xe0(%rbp), %rsi
callq 0x1cef20
movl $0x0, -0xc4(%rbp)
leaq -0x158(%rbp), %rdi
callq 0x1ce540
movl -0xc4(%rbp), %eax
testl %eax, %eax
jne 0x27025e
jmp 0x26ef6f
jmp 0x26ef71
movq -0xd0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xd0(%rbp)
jmp 0x26ec70
leaq -0x40(%rbp), %rdi
callq 0x1cee20
movq %rax, %rdi
callq 0x1cee40
addq $0x30, %rax
movq %rax, -0x170(%rbp)
movq -0x170(%rbp), %rdi
callq 0x1d9aa0
movq %rax, -0x178(%rbp)
movq -0x170(%rbp), %rdi
callq 0x1d9ad0
movq %rax, -0x180(%rbp)
leaq -0x178(%rbp), %rdi
leaq -0x180(%rbp), %rsi
callq 0x1d9db0
testb $0x1, %al
jne 0x26efe6
jmp 0x26f0ab
leaq -0x178(%rbp), %rdi
callq 0x1d9e20
movq %rax, -0x188(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1cf030
addq $0x60, %rax
movq %rax, -0x6d0(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x6d8(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x27b130
movq %rax, -0x1b0(%rbp)
movq -0x188(%rbp), %rsi
leaq -0x210(%rbp), %rdi
callq 0x1d9e70
movq -0x6d8(%rbp), %rsi
movq -0x1b0(%rbp), %rdx
leaq -0x1a8(%rbp), %rdi
leaq -0x210(%rbp), %rcx
callq 0x27b0f0
leaq -0x1a8(%rbp), %rdi
callq 0x27b190
movq -0x6d0(%rbp), %rdi
movq %rax, -0x190(%rbp)
leaq -0x190(%rbp), %rsi
callq 0x27b0c0
leaq -0x1a8(%rbp), %rdi
callq 0x27b1f0
leaq -0x210(%rbp), %rdi
callq 0x1df670
leaq -0x178(%rbp), %rdi
callq 0x1d9e40
jmp 0x26efca
leaq -0x40(%rbp), %rdi
callq 0x1cee20
movq %rax, %rdi
callq 0x1cee40
addq $0x48, %rax
movq %rax, -0x218(%rbp)
movq -0x218(%rbp), %rdi
callq 0x1da700
movq %rax, -0x220(%rbp)
movq -0x218(%rbp), %rdi
callq 0x1da730
movq %rax, -0x228(%rbp)
leaq -0x220(%rbp), %rdi
leaq -0x228(%rbp), %rsi
callq 0x1daa10
testb $0x1, %al
jne 0x26f109
jmp 0x26f1b7
leaq -0x220(%rbp), %rdi
callq 0x1daa80
movq %rax, -0x230(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1cf030
addq $0x78, %rax
movq %rax, -0x6e0(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x6e8(%rbp)
movq -0x230(%rbp), %rsi
leaq -0x278(%rbp), %rdi
callq 0x1d4cc0
movq -0x6e8(%rbp), %rsi
leaq -0x250(%rbp), %rdi
leaq -0x278(%rbp), %rdx
callq 0x1cd480
leaq -0x250(%rbp), %rdi
callq 0x27b210
movq -0x6e0(%rbp), %rdi
movq %rax, -0x238(%rbp)
leaq -0x238(%rbp), %rsi
callq 0x27b0c0
leaq -0x250(%rbp), %rdi
callq 0x1cd5f0
leaq -0x278(%rbp), %rdi
callq 0x1cd610
leaq -0x220(%rbp), %rdi
callq 0x1daaa0
jmp 0x26f0ed
leaq -0x40(%rbp), %rdi
callq 0x1cee20
movq %rax, %rdi
callq 0x1cee40
addq $0x60, %rax
movq %rax, -0x280(%rbp)
movq -0x280(%rbp), %rdi
callq 0x1dac30
movq %rax, -0x288(%rbp)
movq -0x280(%rbp), %rdi
callq 0x1dac60
movq %rax, -0x290(%rbp)
leaq -0x288(%rbp), %rdi
leaq -0x290(%rbp), %rsi
callq 0x1daf40
testb $0x1, %al
jne 0x26f215
jmp 0x26f2c5
leaq -0x288(%rbp), %rdi
callq 0x1dafb0
movq %rax, -0x298(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1cf030
addq $0x90, %rax
movq %rax, -0x6f0(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x6f8(%rbp)
movq -0x298(%rbp), %rsi
leaq -0x2e0(%rbp), %rdi
callq 0x1d5420
movq -0x6f8(%rbp), %rsi
leaq -0x2b8(%rbp), %rdi
leaq -0x2e0(%rbp), %rdx
callq 0x1cd630
leaq -0x2b8(%rbp), %rdi
callq 0x27b270
movq -0x6f0(%rbp), %rdi
movq %rax, -0x2a0(%rbp)
leaq -0x2a0(%rbp), %rsi
callq 0x27b0c0
leaq -0x2b8(%rbp), %rdi
callq 0x1cd750
leaq -0x2e0(%rbp), %rdi
callq 0x1cd770
leaq -0x288(%rbp), %rdi
callq 0x1dafd0
jmp 0x26f1f9
leaq -0x40(%rbp), %rdi
callq 0x1cee20
movq %rax, %rdi
callq 0x1cee40
addq $0x78, %rax
movq %rax, -0x2e8(%rbp)
movq -0x2e8(%rbp), %rdi
callq 0x1db160
movq %rax, -0x2f0(%rbp)
movq -0x2e8(%rbp), %rdi
callq 0x1db190
movq %rax, -0x2f8(%rbp)
leaq -0x2f0(%rbp), %rdi
leaq -0x2f8(%rbp), %rsi
callq 0x1db470
testb $0x1, %al
jne 0x26f323
jmp 0x26f457
leaq -0x2f0(%rbp), %rdi
callq 0x1db4e0
movq %rax, -0x300(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1cf030
addq $0xa8, %rax
movq %rax, -0x700(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x708(%rbp)
movq -0x300(%rbp), %rsi
leaq -0x338(%rbp), %rdi
callq 0x1d5ba0
leaq -0x60(%rbp), %rdi
callq 0x1cf030
movq %rax, %rsi
movq -0x18(%rbp), %rdx
movq -0x300(%rbp), %rax
movq 0x18(%rax), %rcx
movq %rcx, -0x368(%rbp)
movq 0x20(%rax), %rcx
movq %rcx, -0x360(%rbp)
movq 0x28(%rax), %rax
movq %rax, -0x358(%rbp)
leaq -0x350(%rbp), %rdi
leaq -0x368(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x26e2e0
movq -0x708(%rbp), %rsi
leaq -0x320(%rbp), %rdi
leaq -0x338(%rbp), %rdx
leaq -0x350(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x1cd790
leaq -0x320(%rbp), %rdi
callq 0x27b2d0
movq -0x700(%rbp), %rdi
movq %rax, -0x308(%rbp)
leaq -0x308(%rbp), %rsi
callq 0x27b0c0
leaq -0x320(%rbp), %rdi
callq 0x1cd8e0
leaq -0x338(%rbp), %rdi
callq 0x1cd900
leaq -0x2f0(%rbp), %rdi
callq 0x1db500
jmp 0x26f307
leaq -0x40(%rbp), %rdi
callq 0x1cee20
movq %rax, %rdi
callq 0x1cee40
addq $0x90, %rax
movq %rax, -0x370(%rbp)
movq -0x370(%rbp), %rdi
callq 0x1db6b0
movq %rax, -0x378(%rbp)
movq -0x370(%rbp), %rdi
callq 0x1db6e0
movq %rax, -0x380(%rbp)
leaq -0x378(%rbp), %rdi
leaq -0x380(%rbp), %rsi
callq 0x1db9c0
testb $0x1, %al
jne 0x26f4b7
jmp 0x26f567
leaq -0x378(%rbp), %rdi
callq 0x1dba30
movq %rax, -0x388(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1cf030
addq $0xc0, %rax
movq %rax, -0x710(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x718(%rbp)
movq -0x388(%rbp), %rsi
leaq -0x3d0(%rbp), %rdi
callq 0x1dbab0
movq -0x718(%rbp), %rsi
leaq -0x3a8(%rbp), %rdi
leaq -0x3d0(%rbp), %rdx
callq 0x27b330
leaq -0x3a8(%rbp), %rdi
callq 0x27b370
movq -0x710(%rbp), %rdi
movq %rax, -0x390(%rbp)
leaq -0x390(%rbp), %rsi
callq 0x27b0c0
leaq -0x3a8(%rbp), %rdi
callq 0x27b3d0
leaq -0x3d0(%rbp), %rdi
callq 0x1dee90
leaq -0x378(%rbp), %rdi
callq 0x1dba50
jmp 0x26f49b
leaq -0x40(%rbp), %rdi
callq 0x1cee20
movq %rax, %rdi
callq 0x1cee40
addq $0xa8, %rax
movq %rax, -0x3d8(%rbp)
movq -0x3d8(%rbp), %rdi
callq 0x1dbc40
movq %rax, -0x3e0(%rbp)
movq -0x3d8(%rbp), %rdi
callq 0x1dbc70
movq %rax, -0x3e8(%rbp)
leaq -0x3e0(%rbp), %rdi
leaq -0x3e8(%rbp), %rsi
callq 0x1dbf50
testb $0x1, %al
jne 0x26f5c7
jmp 0x26f733
leaq -0x3e0(%rbp), %rdi
callq 0x1dbfc0
movq %rax, -0x3f0(%rbp)
movq -0x3f0(%rbp), %rdi
addq $0x20, %rdi
callq 0x1d98c0
movl 0x8(%rax), %eax
movq %rax, -0x720(%rbp)
subq $0x4, %rax
ja 0x26f703
movq -0x720(%rbp), %rax
leaq 0x9b038(%rip), %rcx # 0x30a644
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq -0x60(%rbp), %rdi
callq 0x1cf030
movq %rax, %rdi
addq $0x60, %rdi
movq -0x3f0(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, %esi
callq 0x1ed7a0
movq (%rax), %rax
movq %rax, -0x3f8(%rbp)
jmp 0x26f703
leaq -0x60(%rbp), %rdi
callq 0x1cf030
movq %rax, %rdi
addq $0x78, %rdi
movq -0x3f0(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, %esi
callq 0x1ed7a0
movq (%rax), %rax
movq %rax, -0x3f8(%rbp)
jmp 0x26f703
leaq -0x60(%rbp), %rdi
callq 0x1cf030
movq %rax, %rdi
addq $0x90, %rdi
movq -0x3f0(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, %esi
callq 0x1ed7a0
movq (%rax), %rax
movq %rax, -0x3f8(%rbp)
jmp 0x26f703
leaq -0x60(%rbp), %rdi
callq 0x1cf030
movq %rax, %rdi
addq $0xa8, %rdi
movq -0x3f0(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, %esi
callq 0x1ed7a0
movq (%rax), %rax
movq %rax, -0x3f8(%rbp)
jmp 0x26f703
leaq -0x60(%rbp), %rdi
callq 0x1cf030
movq %rax, %rdi
addq $0xc0, %rdi
movq -0x3f0(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, %esi
callq 0x1ed7a0
movq (%rax), %rax
movq %rax, -0x3f8(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1cf030
movq %rax, %rdi
addq $0xd8, %rdi
leaq -0x3f8(%rbp), %rsi
callq 0x1cef20
leaq -0x3e0(%rbp), %rdi
callq 0x1dbfe0
jmp 0x26f5ab
leaq -0x40(%rbp), %rdi
callq 0x1cee20
movq %rax, %rdi
callq 0x1cee40
addq $0xd8, %rax
movq %rax, -0x400(%rbp)
movq -0x400(%rbp), %rdi
callq 0x1dc7d0
movq %rax, -0x408(%rbp)
movq -0x400(%rbp), %rdi
callq 0x1dc800
movq %rax, -0x410(%rbp)
leaq -0x408(%rbp), %rdi
leaq -0x410(%rbp), %rsi
callq 0x1dcae0
testb $0x1, %al
jne 0x26f790
jmp 0x26f7e2
leaq -0x408(%rbp), %rdi
callq 0x1dcb50
movq %rax, -0x418(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1cf030
movq %rax, %rdi
addq $0xf0, %rdi
movq -0x418(%rbp), %rax
movq %rax, -0x420(%rbp)
leaq -0x420(%rbp), %rsi
leaq -0x60(%rbp), %rdx
callq 0x27b3f0
leaq -0x408(%rbp), %rdi
callq 0x1dcb70
jmp 0x26f777
leaq -0x40(%rbp), %rdi
callq 0x1cee20
movq %rax, %rdi
callq 0x1cee40
addq $0xf0, %rax
movq %rax, -0x428(%rbp)
movq -0x428(%rbp), %rdi
callq 0x1dd420
movq %rax, -0x430(%rbp)
movq -0x428(%rbp), %rdi
callq 0x1dd450
movq %rax, -0x438(%rbp)
leaq -0x430(%rbp), %rdi
leaq -0x438(%rbp), %rsi
callq 0x1dd730
testb $0x1, %al
jne 0x26f83f
jmp 0x26f88d
leaq -0x430(%rbp), %rdi
callq 0x1dd7a0
movq %rax, -0x440(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1cf030
movq %rax, %rdi
addq $0x108, %rdi # imm = 0x108
movq -0x440(%rbp), %rax
movq %rax, -0x448(%rbp)
leaq -0x448(%rbp), %rsi
callq 0x27b470
leaq -0x430(%rbp), %rdi
callq 0x1dd7c0
jmp 0x26f826
movq -0x18(%rbp), %rdi
callq 0x27b4e0
movq %rax, %rdi
callq 0x22b1d0
movb %al, %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x44c(%rbp)
cmpl $0x1, -0x44c(%rbp)
jg 0x270087
leaq -0x60(%rbp), %rdi
callq 0x1cf030
addq $0xf0, %rax
movq %rax, -0x458(%rbp)
movq -0x458(%rbp), %rdi
callq 0x27b4f0
movq %rax, -0x460(%rbp)
movq -0x458(%rbp), %rdi
callq 0x27b520
movq %rax, -0x468(%rbp)
leaq -0x460(%rbp), %rdi
leaq -0x468(%rbp), %rsi
callq 0x27b550
testb $0x1, %al
jne 0x26f918
jmp 0x26fc9d
leaq -0x460(%rbp), %rdi
callq 0x27b590
movq %rax, -0x470(%rbp)
movq -0x470(%rbp), %rdi
callq 0x279d30
movq %rax, -0x478(%rbp)
movq -0x478(%rbp), %rax
cmpl $0x0, 0x1c(%rax)
jne 0x26fc6f
leaq -0x47c(%rbp), %rdi
callq 0x2301b0
movq -0x18(%rbp), %rax
movq %rax, -0x728(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1cf030
movq %rax, %rdi
addq $0x78, %rdi
movq -0x478(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, %esi
callq 0x1ed7a0
movq -0x728(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0x4a0(%rbp)
movq -0x4a0(%rbp), %rdx
leaq -0x498(%rbp), %rdi
callq 0x1d4d30
leaq -0x60(%rbp), %rdi
callq 0x1cf030
movq %rax, %rsi
movq -0x18(%rbp), %rdx
movq -0x478(%rbp), %rax
movq 0x28(%rax), %rcx
movq %rcx, -0x4d8(%rbp)
movq 0x30(%rax), %rcx
movq %rcx, -0x4d0(%rbp)
movq 0x38(%rax), %rax
movq %rax, -0x4c8(%rbp)
leaq -0x4c0(%rbp), %rdi
leaq -0x4d8(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x26e2e0
leaq -0x4c0(%rbp), %rdi
callq 0x1cf500
movl %eax, -0x4a4(%rbp)
cmpl $0x0, -0x44c(%rbp)
jne 0x26fa95
leaq -0x498(%rbp), %rdi
callq 0x1d4e50
movq %rax, -0x738(%rbp)
movl -0x4a4(%rbp), %eax
movl %eax, -0x72c(%rbp)
movq -0x470(%rbp), %rdi
callq 0x27abf0
movq -0x738(%rbp), %rdi
movl -0x72c(%rbp), %esi
movl %eax, %edx
callq 0x26d620
movb %al, %cl
movl $0x1, %esi
xorl %eax, %eax
testb $0x1, %cl
cmovnel %eax, %esi
leaq -0x4dc(%rbp), %rdi
callq 0x1cba40
movl -0x4dc(%rbp), %eax
movl %eax, -0x47c(%rbp)
jmp 0x26fb1d
leaq -0x498(%rbp), %rdi
callq 0x1d4e50
movq %rax, -0x758(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x750(%rbp)
movl -0x4a4(%rbp), %eax
movl %eax, -0x744(%rbp)
movq -0x470(%rbp), %rax
movq %rax, -0x740(%rbp)
movq -0x470(%rbp), %rdi
callq 0x27abf0
movq -0x758(%rbp), %rdi
movq -0x750(%rbp), %rsi
movl -0x744(%rbp), %edx
movq -0x740(%rbp), %rcx
movl %eax, %r9d
xorl %r8d, %r8d
callq 0x26d9e0
movl %eax, -0x4e0(%rbp)
movl -0x4e0(%rbp), %eax
movl %eax, -0x47c(%rbp)
movq -0x470(%rbp), %rdi
callq 0x27b5b0
movl -0x47c(%rbp), %eax
movl %eax, -0x4e4(%rbp)
movl -0x4e4(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x26fb3d
jmp 0x26fc47
movq -0x18(%rbp), %rax
movq %rax, -0x760(%rbp)
movl -0x4a4(%rbp), %eax
movl %eax, -0x76c(%rbp)
movl -0x4a4(%rbp), %eax
movq %rax, -0x778(%rbp)
movq -0x470(%rbp), %rdi
callq 0x27abf0
movl %eax, %ecx
movq -0x778(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x768(%rbp)
leaq -0x498(%rbp), %rdi
callq 0x1d4e50
movq %rax, %rdi
callq 0x27b5d0
movl -0x76c(%rbp), %edx
movq -0x768(%rbp), %rcx
movl %eax, %r8d
leaq -0x520(%rbp), %rdi
leaq 0x9b8a6(%rip), %rsi # 0x30b45a
movb $0x0, %al
callq 0x1cd050
leaq -0x538(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x1a61d0
leaq -0x538(%rbp), %rdi
callq 0x27af80
movq -0x760(%rbp), %rsi
leaq -0x500(%rbp), %rdi
leaq -0x520(%rbp), %rdx
leaq -0x538(%rbp), %rcx
callq 0x27af40
movq -0x28(%rbp), %rdi
leaq -0x500(%rbp), %rsi
callq 0x27afa0
leaq -0x500(%rbp), %rdi
callq 0x1cf440
leaq -0x538(%rbp), %rdi
callq 0x27b000
leaq -0x520(%rbp), %rdi
callq 0x1a6250
movq -0x6a8(%rbp), %rdi
callq 0x27b050
movl $0x1, -0xc4(%rbp)
jmp 0x26fc51
movl $0x0, -0xc4(%rbp)
leaq -0x498(%rbp), %rdi
callq 0x1cd5f0
movl -0xc4(%rbp), %eax
testl %eax, %eax
jne 0x27025e
jmp 0x26fc6d
jmp 0x26fc8a
movq -0x478(%rbp), %rax
cmpl $0x2, 0x1c(%rax)
jne 0x26fc88
movq -0x470(%rbp), %rdi
callq 0x27b5b0
jmp 0x26fc8a
jmp 0x26fc8c
leaq -0x460(%rbp), %rdi
callq 0x27b5f0
jmp 0x26f8fc
leaq -0x60(%rbp), %rdi
callq 0x1cf030
addq $0x108, %rax # imm = 0x108
movq %rax, -0x540(%rbp)
movq -0x540(%rbp), %rdi
callq 0x27b610
movq %rax, -0x548(%rbp)
movq -0x540(%rbp), %rdi
callq 0x27b640
movq %rax, -0x550(%rbp)
leaq -0x548(%rbp), %rdi
leaq -0x550(%rbp), %rsi
callq 0x27b670
testb $0x1, %al
jne 0x26fcf5
jmp 0x270071
leaq -0x548(%rbp), %rdi
callq 0x27b6b0
movq %rax, -0x558(%rbp)
movq -0x558(%rbp), %rdi
callq 0x27a3b0
movq %rax, -0x560(%rbp)
movq -0x560(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x270043
leaq -0x564(%rbp), %rdi
callq 0x2301b0
movq -0x18(%rbp), %rax
movq %rax, -0x780(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1cf030
movq %rax, %rdi
addq $0x90, %rdi
movq -0x560(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, %esi
callq 0x1ed7a0
movq -0x780(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0x588(%rbp)
movq -0x588(%rbp), %rdx
leaq -0x580(%rbp), %rdi
callq 0x1d5480
leaq -0x60(%rbp), %rdi
callq 0x1cf030
movq %rax, %rsi
movq -0x18(%rbp), %rdx
movq -0x560(%rbp), %rax
movq 0x20(%rax), %rcx
movq %rcx, -0x5c0(%rbp)
movq 0x28(%rax), %rcx
movq %rcx, -0x5b8(%rbp)
movq 0x30(%rax), %rax
movq %rax, -0x5b0(%rbp)
leaq -0x5a8(%rbp), %rdi
leaq -0x5c0(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x26e2e0
leaq -0x5a8(%rbp), %rdi
callq 0x1cf500
movl %eax, -0x58c(%rbp)
cmpl $0x0, -0x44c(%rbp)
jne 0x26fe79
leaq -0x580(%rbp), %rdi
callq 0x1d55a0
movq %rax, -0x790(%rbp)
movl -0x58c(%rbp), %eax
movq %rax, -0x788(%rbp)
movq -0x558(%rbp), %rdi
callq 0x27b6d0
movq -0x790(%rbp), %rdi
movq -0x788(%rbp), %rsi
movq %rax, %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0x27a1f0
movb %al, %cl
movl $0x1, %esi
xorl %eax, %eax
testb $0x1, %cl
cmovnel %eax, %esi
leaq -0x5c4(%rbp), %rdi
callq 0x1cba40
movl -0x5c4(%rbp), %eax
movl %eax, -0x564(%rbp)
jmp 0x26fef2
leaq -0x580(%rbp), %rdi
callq 0x1d55a0
movq %rax, -0x7a8(%rbp)
movl -0x58c(%rbp), %eax
movq %rax, -0x7a0(%rbp)
movq -0x558(%rbp), %rax
movq %rax, -0x798(%rbp)
movq -0x558(%rbp), %rdi
callq 0x27b6d0
movq -0x7a8(%rbp), %rdi
movq -0x7a0(%rbp), %rsi
movq -0x798(%rbp), %rdx
movq %rax, %r8
xorl %eax, %eax
movl %eax, %ecx
callq 0x26dfb0
movl %eax, -0x5c8(%rbp)
movl -0x5c8(%rbp), %eax
movl %eax, -0x564(%rbp)
movq -0x558(%rbp), %rdi
callq 0x27b6f0
movl -0x564(%rbp), %eax
movl %eax, -0x5cc(%rbp)
movl -0x5cc(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x26ff12
jmp 0x27001b
movq -0x18(%rbp), %rax
movq %rax, -0x7b0(%rbp)
movl -0x58c(%rbp), %eax
movl %eax, -0x7bc(%rbp)
movl -0x58c(%rbp), %eax
movq %rax, -0x7c8(%rbp)
movq -0x558(%rbp), %rdi
callq 0x27b6d0
movq %rax, %rcx
movq -0x7c8(%rbp), %rax
addq %rcx, %rax
movq %rax, -0x7b8(%rbp)
leaq -0x580(%rbp), %rdi
callq 0x1d55a0
movq %rax, %rdi
callq 0x27b710
movl -0x7bc(%rbp), %edx
movq -0x7b8(%rbp), %rcx
movq %rax, %r8
leaq -0x608(%rbp), %rdi
leaq 0x9b527(%rip), %rsi # 0x30b4af
movb $0x0, %al
callq 0x1cd050
leaq -0x620(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x1a61d0
leaq -0x620(%rbp), %rdi
callq 0x27af80
movq -0x7b0(%rbp), %rsi
leaq -0x5e8(%rbp), %rdi
leaq -0x608(%rbp), %rdx
leaq -0x620(%rbp), %rcx
callq 0x27af40
movq -0x28(%rbp), %rdi
leaq -0x5e8(%rbp), %rsi
callq 0x27afa0
leaq -0x5e8(%rbp), %rdi
callq 0x1cf440
leaq -0x620(%rbp), %rdi
callq 0x27b000
leaq -0x608(%rbp), %rdi
callq 0x1a6250
movq -0x6a8(%rbp), %rdi
callq 0x27b050
movl $0x1, -0xc4(%rbp)
jmp 0x270025
movl $0x0, -0xc4(%rbp)
leaq -0x580(%rbp), %rdi
callq 0x1cd750
movl -0xc4(%rbp), %eax
testl %eax, %eax
jne 0x27025e
jmp 0x270041
jmp 0x27005e
movq -0x560(%rbp), %rax
cmpl $0x2, 0x18(%rax)
jne 0x27005c
movq -0x558(%rbp), %rdi
callq 0x27b6f0
jmp 0x27005e
jmp 0x270060
leaq -0x548(%rbp), %rdi
callq 0x27b730
jmp 0x26fcd9
jmp 0x270073
movl -0x44c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44c(%rbp)
jmp 0x26f8b3
leaq -0x40(%rbp), %rdi
callq 0x1cee20
movq %rax, %rdi
callq 0x1cee40
addq $0xc0, %rax
movq %rax, -0x628(%rbp)
movq -0x628(%rbp), %rdi
callq 0x1dc1c0
movq %rax, -0x630(%rbp)
movq -0x628(%rbp), %rdi
callq 0x1dc1f0
movq %rax, -0x638(%rbp)
leaq -0x630(%rbp), %rdi
leaq -0x638(%rbp), %rsi
callq 0x27b750
testb $0x1, %al
jne 0x2700e7
jmp 0x270244
leaq -0x630(%rbp), %rdi
callq 0x27b790
movq %rax, -0x640(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x7e8(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1cf030
movq %rax, %rdi
addq $0x60, %rdi
movq -0x640(%rbp), %rax
movl (%rax), %eax
movl %eax, %esi
callq 0x1ed7a0
movq -0x7e8(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0x660(%rbp)
movq -0x660(%rbp), %rdx
leaq -0x658(%rbp), %rdi
callq 0x27b7b0
leaq -0x678(%rbp), %rdi
callq 0x1ce0a0
leaq -0x658(%rbp), %rdi
callq 0x27b8d0
movq %rax, -0x7e0(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x7d8(%rbp)
leaq -0x698(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x1a61d0
leaq -0x698(%rbp), %rdi
callq 0x1ce0a0
movq -0x7e0(%rbp), %rdi
movq -0x7d8(%rbp), %rsi
movq -0x28(%rbp), %r8
leaq -0x698(%rbp), %rdx
leaq -0x678(%rbp), %rcx
xorl %eax, %eax
movl %eax, %r9d
callq 0x26cc40
movl %eax, -0x67c(%rbp)
movl -0x67c(%rbp), %edi
callq 0x1cba60
movb %al, -0x7c9(%rbp)
leaq -0x698(%rbp), %rdi
callq 0x1d6100
movb -0x7c9(%rbp), %al
testb $0x1, %al
jne 0x2701eb
jmp 0x270203
movq -0x6a8(%rbp), %rdi
callq 0x27b050
movl $0x1, -0xc4(%rbp)
jmp 0x27020d
movl $0x0, -0xc4(%rbp)
leaq -0x678(%rbp), %rdi
callq 0x1d6100
leaq -0x658(%rbp), %rdi
callq 0x27b8f0
movl -0xc4(%rbp), %eax
testl %eax, %eax
jne 0x27025e
jmp 0x270231
jmp 0x270233
leaq -0x630(%rbp), %rdi
callq 0x27b910
jmp 0x2700cb
movq -0x6a8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x27b930
movl $0x1, -0xc4(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1cf420
leaq -0x40(%rbp), %rdi
callq 0x1cec70
movq -0x6a0(%rbp), %rax
addq $0x800, %rsp # imm = 0x800
popq %rbp
retq
| /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::Instance::Mark(wabt::interp::Store&) | void Instance::Mark(Store& store) {
store.Mark(module_);
store.Mark(imports_);
store.Mark(funcs_);
store.Mark(memories_);
store.Mark(tables_);
store.Mark(globals_);
store.Mark(events_);
store.Mark(exports_);
for (auto&& elem : elems_) {
elem.Mark(store);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
movq 0x40(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
callq 0x26c920
movq -0x40(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x48, %rsi
callq 0x26c960
movq -0x40(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x60, %rsi
callq 0x26c960
movq -0x40(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x90, %rsi
callq 0x26c960
movq -0x40(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x78, %rsi
callq 0x26c960
movq -0x40(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xa8, %rsi
callq 0x26c960
movq -0x40(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xc0, %rsi
callq 0x26c960
movq -0x40(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0xd8, %rsi
callq 0x26c960
movq -0x40(%rbp), %rax
addq $0xf0, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x27b4f0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x27b520
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x27b550
testb $0x1, %al
jne 0x27036b
jmp 0x270390
leaq -0x28(%rbp), %rdi
callq 0x27b590
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x26e9d0
leaq -0x28(%rbp), %rdi
callq 0x27b5f0
jmp 0x270358
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::Thread::Thread(wabt::interp::Store&, wabt::interp::Thread::Options const&) | Thread::Thread(Store& store, const Options& options)
: Object(skind), store_(store) {
frames_.reserve(options.call_stack_size);
values_.reserve(options.value_stack_size);
trace_stream_ = options.trace_stream;
if (options.trace_stream) {
trace_source_ = MakeUnique<TraceSource>(this);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl $0xb, %esi
callq 0x278da0
movq -0x30(%rbp), %rdi
leaq 0x142607(%rip), %rax # 0x3b29d8
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x40, %rdi
callq 0x27af80
movq -0x30(%rbp), %rdi
addq $0x58, %rdi
callq 0x1ce0a0
movq -0x30(%rbp), %rdi
addq $0x70, %rdi
callq 0x266780
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, 0x88(%rdi)
movq $0x0, 0x90(%rdi)
movq $0x0, 0x98(%rdi)
addq $0xa8, %rdi
callq 0x27b990
movq -0x30(%rbp), %rdi
addq $0x40, %rdi
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %esi
callq 0x27b9c0
movq -0x30(%rbp), %rdi
addq $0x58, %rdi
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %esi
callq 0x27bac0
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0xa0(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2704a7
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x27bbc0
movq -0x30(%rbp), %rdi
addq $0xa8, %rdi
leaq -0x20(%rbp), %rsi
callq 0x27bc10
leaq -0x20(%rbp), %rdi
callq 0x27bc40
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::Thread::Mark(wabt::interp::Store&) | void Thread::Mark(Store& store) {
for (auto&& frame : frames_) {
frame.Mark(store);
}
for (auto index: refs_) {
store.Mark(values_[index].Get<Ref>());
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
addq $0x40, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x279530
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x279560
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x279590
testb $0x1, %al
jne 0x2704fd
jmp 0x270522
leaq -0x20(%rbp), %rdi
callq 0x2795d0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x26cae0
leaq -0x20(%rbp), %rdi
callq 0x2795f0
jmp 0x2704ea
movq -0x60(%rbp), %rax
addq $0x70, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x264ed0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x264f00
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x264f30
testb $0x1, %al
jne 0x27055b
jmp 0x2705a7
leaq -0x40(%rbp), %rdi
callq 0x264f70
movq -0x60(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x4c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
addq $0x58, %rdi
movl -0x4c(%rbp), %eax
movl %eax, %esi
callq 0x1cf750
movq %rax, %rdi
callq 0x1cf660
movq -0x68(%rbp), %rdi
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rsi
callq 0x26c920
leaq -0x40(%rbp), %rdi
callq 0x264f90
jmp 0x270548
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
| /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::RunResult wabt::interp::Thread::DoStore<unsigned long, unsigned char>(wabt::interp::Instr, wabt::interp::RefPtr<wabt::interp::Trap>*) | RunResult Thread::DoStore(Instr instr, Trap::Ptr* out_trap) {
Memory::Ptr memory{store_, inst_->memories()[instr.imm_u32x2.fst]};
V val = static_cast<V>(Pop<T>());
u64 offset = PopPtr(memory);
TRAP_IF(Failed(memory->Store(offset, instr.imm_u32x2.snd, val)),
StringPrintf("out of bounds memory access: access at %" PRIu64
"+%" PRIzd " >= max value %" PRIu64,
offset + instr.imm_u32x2.snd, sizeof(V),
memory->ByteSize()));
return RunResult::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq 0x88(%rax), %rcx
movq %rcx, -0xa8(%rbp)
movq 0x90(%rax), %rdi
callq 0x27ddb0
movq %rax, %rdi
movq -0x98(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %esi
callq 0x1cf260
movq -0xa8(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x1d5480
movq -0xa0(%rbp), %rdi
callq 0x27c4a0
movq -0xa0(%rbp), %rdi
movb %al, -0x39(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x276990
movq %rax, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1d55a0
movq %rax, %rdi
movq -0x98(%rbp), %rax
movq -0x48(%rbp), %rsi
movl 0xc(%rax), %eax
movl %eax, %edx
movzbl -0x39(%rbp), %ecx
callq 0x296bf0
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %edi
callq 0x1cba60
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x27d952
jmp 0x27da0b
movq -0xa0(%rbp), %rax
movq -0x98(%rbp), %rcx
movq 0x88(%rax), %rax
movq %rax, -0xb0(%rbp)
movq -0x48(%rbp), %rax
movl 0xc(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0xb8(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1d55a0
movq %rax, %rdi
callq 0x27b710
movq -0xb8(%rbp), %rdx
movq %rax, %r8
leaq -0x88(%rbp), %rdi
leaq 0x8e370(%rip), %rsi # 0x30bd18
movl $0x1, %ecx
movb $0x0, %al
callq 0x1cd050
movq -0xa0(%rbp), %rcx
movq -0xb0(%rbp), %rsi
addq $0x40, %rcx
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rdx
callq 0x27af40
movq -0x18(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x27afa0
movl $0x2, -0x4(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1cf440
leaq -0x88(%rbp), %rdi
callq 0x1a6250
movl $0x1, -0x8c(%rbp)
jmp 0x27da1c
movl $0x0, -0x4(%rbp)
movl $0x1, -0x8c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1cd750
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::RunResult wabt::interp::Thread::DoStore<unsigned long, unsigned short>(wabt::interp::Instr, wabt::interp::RefPtr<wabt::interp::Trap>*) | RunResult Thread::DoStore(Instr instr, Trap::Ptr* out_trap) {
Memory::Ptr memory{store_, inst_->memories()[instr.imm_u32x2.fst]};
V val = static_cast<V>(Pop<T>());
u64 offset = PopPtr(memory);
TRAP_IF(Failed(memory->Store(offset, instr.imm_u32x2.snd, val)),
StringPrintf("out of bounds memory access: access at %" PRIu64
"+%" PRIzd " >= max value %" PRIu64,
offset + instr.imm_u32x2.snd, sizeof(V),
memory->ByteSize()));
return RunResult::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq 0x88(%rax), %rcx
movq %rcx, -0xa8(%rbp)
movq 0x90(%rax), %rdi
callq 0x27ddb0
movq %rax, %rdi
movq -0x98(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %esi
callq 0x1cf260
movq -0xa8(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x1d5480
movq -0xa0(%rbp), %rdi
callq 0x27c4a0
movq -0xa0(%rbp), %rdi
movw %ax, -0x3a(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x276990
movq %rax, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1d55a0
movq %rax, %rdi
movq -0x98(%rbp), %rax
movq -0x48(%rbp), %rsi
movl 0xc(%rax), %eax
movl %eax, %edx
movzwl -0x3a(%rbp), %ecx
callq 0x296ca0
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %edi
callq 0x1cba60
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x27db13
jmp 0x27dbcc
movq -0xa0(%rbp), %rax
movq -0x98(%rbp), %rcx
movq 0x88(%rax), %rax
movq %rax, -0xb0(%rbp)
movq -0x48(%rbp), %rax
movl 0xc(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0xb8(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1d55a0
movq %rax, %rdi
callq 0x27b710
movq -0xb8(%rbp), %rdx
movq %rax, %r8
leaq -0x88(%rbp), %rdi
leaq 0x8e1af(%rip), %rsi # 0x30bd18
movl $0x2, %ecx
movb $0x0, %al
callq 0x1cd050
movq -0xa0(%rbp), %rcx
movq -0xb0(%rbp), %rsi
addq $0x40, %rcx
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rdx
callq 0x27af40
movq -0x18(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x27afa0
movl $0x2, -0x4(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1cf440
leaq -0x88(%rbp), %rdi
callq 0x1a6250
movl $0x1, -0x8c(%rbp)
jmp 0x27dbdd
movl $0x0, -0x4(%rbp)
movl $0x1, -0x8c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1cd750
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::RunResult wabt::interp::Thread::DoBinop<int, int>(wabt::interp::RunResult (*)(int, int, int*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*), wabt::interp::RefPtr<wabt::interp::Trap>*) | RunResult Thread::DoBinop(BinopTrapFunc<R, T> f, Trap::Ptr* out_trap) {
auto rhs = Pop<T>();
auto lhs = Pop<T>();
T out;
std::string msg;
TRAP_IF(f(lhs, rhs, &out, &msg) == RunResult::Trap, msg);
Push<R>(out);
return RunResult::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x296df0
movq -0x78(%rbp), %rdi
movl %eax, -0x24(%rbp)
callq 0x296df0
movl %eax, -0x28(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1a6560
movq -0x18(%rbp), %rax
movl -0x28(%rbp), %edi
movl -0x24(%rbp), %esi
leaq -0x2c(%rbp), %rdx
leaq -0x50(%rbp), %rcx
callq *%rax
cmpl $0x2, %eax
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x27e940
jmp 0x27e982
movq -0x78(%rbp), %rcx
movq 0x88(%rcx), %rsi
addq $0x40, %rcx
leaq -0x68(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0x27af40
movq -0x20(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x27afa0
movl $0x2, -0x4(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1cf440
movl $0x1, -0x6c(%rbp)
jmp 0x27e99c
movq -0x78(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x27df00
movl $0x0, -0x4(%rbp)
movl $0x1, -0x6c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1a6250
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::RunResult wabt::interp::IntRem<unsigned int>(unsigned int, unsigned int, unsigned int*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | RunResult WABT_VECTORCALL IntRem(T lhs, T rhs, T* out, std::string* out_msg) {
if (WABT_UNLIKELY(rhs == 0)) {
*out_msg = "integer divide by zero";
return RunResult::Trap;
}
if (WABT_LIKELY(IsNormalDivRem(lhs, rhs))) {
*out = lhs % rhs;
} else {
*out = 0;
}
return RunResult::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpl $0x0, -0xc(%rbp)
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x27ec67
jmp 0x27ec80
movq -0x20(%rbp), %rdi
leaq 0x8d0e6(%rip), %rsi # 0x30bd58
callq 0x1a6540
movl $0x2, -0x4(%rbp)
jmp 0x27ecb6
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
callq 0x296fa0
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x27ec95
jmp 0x27eca5
movl -0x8(%rbp), %eax
xorl %edx, %edx
divl -0xc(%rbp)
movq -0x18(%rbp), %rax
movl %edx, (%rax)
jmp 0x27ecaf
movq -0x18(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
| /dcodeIO[P]wabt/src/interp/interp-math.h |
wabt::interp::RunResult wabt::interp::IntDiv<long>(long, long, long*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | RunResult WABT_VECTORCALL IntDiv(T lhs, T rhs, T* out, std::string* out_msg) {
if (WABT_UNLIKELY(rhs == 0)) {
*out_msg = "integer divide by zero";
return RunResult::Trap;
}
if (WABT_LIKELY(IsNormalDivRem(lhs, rhs))) {
*out = lhs / rhs;
return RunResult::Ok;
} else {
*out_msg = "integer overflow";
return RunResult::Trap;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x27f13a
jmp 0x27f153
movq -0x28(%rbp), %rdi
leaq 0x8cc13(%rip), %rsi # 0x30bd58
callq 0x1a6540
movl $0x2, -0x4(%rbp)
jmp 0x27f19e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x2970a0
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x27f16a
jmp 0x27f187
movq -0x10(%rbp), %rax
cqto
idivq -0x18(%rbp)
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x27f19e
movq -0x28(%rbp), %rdi
leaq 0x8cbdd(%rip), %rsi # 0x30bd6f
callq 0x1a6540
movl $0x2, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /dcodeIO[P]wabt/src/interp/interp-math.h |
wabt::interp::RunResult wabt::interp::IntRem<unsigned long>(unsigned long, unsigned long, unsigned long*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | RunResult WABT_VECTORCALL IntRem(T lhs, T rhs, T* out, std::string* out_msg) {
if (WABT_UNLIKELY(rhs == 0)) {
*out_msg = "integer divide by zero";
return RunResult::Trap;
}
if (WABT_LIKELY(IsNormalDivRem(lhs, rhs))) {
*out = lhs % rhs;
} else {
*out = 0;
}
return RunResult::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
sete %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x27f3ea
jmp 0x27f403
movq -0x28(%rbp), %rdi
leaq 0x8c963(%rip), %rsi # 0x30bd58
callq 0x1a6540
movl $0x2, -0x4(%rbp)
jmp 0x27f441
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x297100
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x27f41a
jmp 0x27f42f
movq -0x10(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %rdx, (%rax)
jmp 0x27f43a
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /dcodeIO[P]wabt/src/interp/interp-math.h |
double wabt::interp::FloatDiv<double>(double, double) | T WABT_VECTORCALL FloatDiv(T lhs, T rhs) {
// IEE754 specifies what should happen when dividing a float by zero, but
// C/C++ says it is undefined behavior.
if (WABT_UNLIKELY(rhs == 0)) {
return std::isnan(lhs) || lhs == 0
? std::numeric_limits<T>::quiet_NaN()
: ((std::signbit(lhs) ^ std::signbit(rhs))
? -std::numeric_limits<T>::infinity()
: std::numeric_limits<T>::infinity());
}
return CanonNaN(lhs / rhs);
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
sete %al
setnp %cl
andb %cl, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x27fe73
jmp 0x27ff2c
movsd -0x10(%rbp), %xmm0
callq 0x297400
testb $0x1, %al
jne 0x27fe91
movsd -0x10(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x27fea0
jp 0x27fea0
callq 0x297420
movsd %xmm0, -0x20(%rbp)
jmp 0x27ff20
movsd -0x10(%rbp), %xmm0
callq 0x297430
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x40(%rbp)
movsd -0x18(%rbp), %xmm0
callq 0x297430
movb %al, %cl
movl -0x40(%rbp), %eax
andb $0x1, %cl
movzbl %cl, %ecx
xorl %ecx, %eax
movl %eax, -0x3c(%rbp)
callq 0x297450
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, -0x38(%rbp)
callq 0x297450
movl -0x3c(%rbp), %eax
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
movsd %xmm1, -0x30(%rbp)
cmpl $0x0, %eax
movsd %xmm0, -0x28(%rbp)
jne 0x27ff16
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x27ff40
movsd -0x10(%rbp), %xmm0
divsd -0x18(%rbp), %xmm0
callq 0x2973b0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /dcodeIO[P]wabt/src/interp/interp-math.h |
double wabt::interp::FloatMin<double>(double, double) | T WABT_VECTORCALL FloatMin(T lhs, T rhs) {
if (WABT_UNLIKELY(std::isnan(lhs) || std::isnan(rhs))) {
return std::numeric_limits<T>::quiet_NaN();
} else if (WABT_UNLIKELY(lhs == 0 && rhs == 0)) {
return std::signbit(lhs) ? lhs : rhs;
} else {
return std::min(lhs, rhs);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x297400
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x19(%rbp)
jne 0x27ff85
movsd -0x18(%rbp), %xmm0
callq 0x297400
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x27ff92
jmp 0x27ffa1
callq 0x297420
movsd %xmm0, -0x8(%rbp)
jmp 0x280022
movsd -0x10(%rbp), %xmm0
xorl %eax, %eax
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movb %al, -0x1a(%rbp)
jne 0x27ffcd
jp 0x27ffcd
movsd -0x18(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
sete %al
setnp %cl
andb %cl, %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x27ffda
jmp 0x28000c
movsd -0x10(%rbp), %xmm0
callq 0x297430
testb $0x1, %al
jne 0x27ffea
jmp 0x27fff6
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
jmp 0x280000
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x280022
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x297460
movsd (%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| /dcodeIO[P]wabt/src/interp/interp-math.h |
wabt::interp::RunResult wabt::interp::Thread::DoConvert<long, int>(wabt::interp::RefPtr<wabt::interp::Trap>*) | RunResult Thread::DoConvert(Trap::Ptr* out_trap) {
auto val = Pop<T>();
if (std::is_integral<R>::value && std::is_floating_point<T>::value) {
// Don't use std::isnan here because T may be a non-floating-point type.
TRAP_IF(IsNaN(val), "invalid conversion to integer");
}
TRAP_UNLESS(CanConvert<R>(val), "integer overflow");
Push<R>(Convert<R>(val));
return RunResult::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x296df0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
callq 0x2977c0
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2808d4
jmp 0x28094a
movq -0x68(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x70(%rbp)
leaq -0x59(%rbp), %rdi
callq 0x1a6650
leaq -0x58(%rbp), %rdi
leaq 0x8b478(%rip), %rsi # 0x30bd6f
leaq -0x59(%rbp), %rdx
callq 0x1a6550
movq -0x68(%rbp), %rcx
movq -0x70(%rbp), %rsi
addq $0x40, %rcx
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x27af40
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x27afa0
movl $0x2, -0x4(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1cf440
leaq -0x58(%rbp), %rdi
callq 0x1a6250
leaq -0x59(%rbp), %rdi
callq 0x1a6440
jmp 0x280965
movl -0x1c(%rbp), %edi
callq 0x2977d0
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x27dea0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nop
| /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::RunResult wabt::interp::Thread::DoConvert<unsigned long, double>(wabt::interp::RefPtr<wabt::interp::Trap>*) | RunResult Thread::DoConvert(Trap::Ptr* out_trap) {
auto val = Pop<T>();
if (std::is_integral<R>::value && std::is_floating_point<T>::value) {
// Don't use std::isnan here because T may be a non-floating-point type.
TRAP_IF(IsNaN(val), "invalid conversion to integer");
}
TRAP_UNLESS(CanConvert<R>(val), "integer overflow");
Push<R>(Convert<R>(val));
return RunResult::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x296b10
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
callq 0x297680
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x280f5f
jmp 0x280fe4
movq -0xa8(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0xb0(%rbp)
leaq -0x59(%rbp), %rdi
callq 0x1a6650
leaq -0x58(%rbp), %rdi
leaq 0x8aeb0(%rip), %rsi # 0x30be38
leaq -0x59(%rbp), %rdx
callq 0x1a6550
movq -0xa8(%rbp), %rcx
movq -0xb0(%rbp), %rsi
addq $0x40, %rcx
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x27af40
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x27afa0
movl $0x2, -0x4(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1cf440
leaq -0x58(%rbp), %rdi
callq 0x1a6250
leaq -0x59(%rbp), %rdi
callq 0x1a6440
jmp 0x2810b1
movsd -0x20(%rbp), %xmm0
callq 0x297a50
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x280ffd
jmp 0x281091
movq -0xa8(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0xb8(%rbp)
leaq -0x99(%rbp), %rdi
callq 0x1a6650
leaq -0x98(%rbp), %rdi
leaq 0x8ad43(%rip), %rsi # 0x30bd6f
leaq -0x99(%rbp), %rdx
callq 0x1a6550
movq -0xa8(%rbp), %rcx
movq -0xb8(%rbp), %rsi
addq $0x40, %rcx
leaq -0x78(%rbp), %rdi
leaq -0x98(%rbp), %rdx
callq 0x27af40
movq -0x18(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x27afa0
movl $0x2, -0x4(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x1cf440
leaq -0x98(%rbp), %rdi
callq 0x1a6250
leaq -0x99(%rbp), %rdi
callq 0x1a6440
jmp 0x2810b1
movsd -0x20(%rbp), %xmm0
callq 0x297a90
movq -0xa8(%rbp), %rdi
movq %rax, %rsi
callq 0x27ddd0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax)
| /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::RunResult wabt::interp::Thread::DoConvert<float, unsigned long>(wabt::interp::RefPtr<wabt::interp::Trap>*) | RunResult Thread::DoConvert(Trap::Ptr* out_trap) {
auto val = Pop<T>();
if (std::is_integral<R>::value && std::is_floating_point<T>::value) {
// Don't use std::isnan here because T may be a non-floating-point type.
TRAP_IF(IsNaN(val), "invalid conversion to integer");
}
TRAP_UNLESS(CanConvert<R>(val), "integer overflow");
Push<R>(Convert<R>(val));
return RunResult::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x27c4a0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x297b50
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x281366
jmp 0x2813dc
movq -0x68(%rbp), %rax
movq 0x88(%rax), %rax
movq %rax, -0x70(%rbp)
leaq -0x59(%rbp), %rdi
callq 0x1a6650
leaq -0x58(%rbp), %rdi
leaq 0x8a9e6(%rip), %rsi # 0x30bd6f
leaq -0x59(%rbp), %rdx
callq 0x1a6550
movq -0x68(%rbp), %rcx
movq -0x70(%rbp), %rsi
addq $0x40, %rcx
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x27af40
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x27afa0
movl $0x2, -0x4(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1cf440
leaq -0x58(%rbp), %rdi
callq 0x1a6250
leaq -0x59(%rbp), %rdi
callq 0x1a6440
jmp 0x2813f5
movq -0x20(%rbp), %rdi
callq 0x297b60
movq -0x68(%rbp), %rdi
callq 0x27df50
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nop
| /dcodeIO[P]wabt/src/interp/interp.cc |
unsigned int wabt::interp::IntTruncSat<unsigned int, float>(float) | R WABT_VECTORCALL IntTruncSat(T val) {
if (WABT_UNLIKELY(std::isnan(val))) {
return 0;
} else if (WABT_UNLIKELY(!CanConvert<R>(val))) {
return std::signbit(val) ? std::numeric_limits<R>::min()
: std::numeric_limits<R>::max();
} else {
return static_cast<R>(val);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movss %xmm0, -0x8(%rbp)
movss -0x8(%rbp), %xmm0
callq 0x2971f0
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x281dc1
jmp 0x281dca
movl $0x0, -0x4(%rbp)
jmp 0x281e14
movss -0x8(%rbp), %xmm0
callq 0x2975f0
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x281de0
jmp 0x281e0b
movss -0x8(%rbp), %xmm0
callq 0x2972a0
movb %al, -0xd(%rbp)
callq 0x2980e0
movl %eax, -0xc(%rbp)
callq 0x1d5190
movb -0xd(%rbp), %dl
movl -0xc(%rbp), %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x281e14
cvttss2si -0x8(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| /dcodeIO[P]wabt/src/interp/interp-math.h |
int wabt::interp::IntTruncSat<int, double>(double) | R WABT_VECTORCALL IntTruncSat(T val) {
if (WABT_UNLIKELY(std::isnan(val))) {
return 0;
} else if (WABT_UNLIKELY(!CanConvert<R>(val))) {
return std::signbit(val) ? std::numeric_limits<R>::min()
: std::numeric_limits<R>::max();
} else {
return static_cast<R>(val);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x297400
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x281e81
jmp 0x281e8a
movl $0x0, -0x4(%rbp)
jmp 0x281ed3
movsd -0x10(%rbp), %xmm0
callq 0x2976a0
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x281ea0
jmp 0x281ecb
movsd -0x10(%rbp), %xmm0
callq 0x297430
movb %al, -0x15(%rbp)
callq 0x296f90
movl %eax, -0x14(%rbp)
callq 0x1f90f0
movb -0x15(%rbp), %dl
movl -0x14(%rbp), %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x281ed3
cvttsd2si -0x10(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| /dcodeIO[P]wabt/src/interp/interp-math.h |
unsigned long wabt::interp::IntTruncSat<unsigned long, float>(float) | R WABT_VECTORCALL IntTruncSat(T val) {
if (WABT_UNLIKELY(std::isnan(val))) {
return 0;
} else if (WABT_UNLIKELY(!CanConvert<R>(val))) {
return std::signbit(val) ? std::numeric_limits<R>::min()
: std::numeric_limits<R>::max();
} else {
return static_cast<R>(val);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movss %xmm0, -0xc(%rbp)
movss -0xc(%rbp), %xmm0
callq 0x2971f0
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2820d1
jmp 0x2820db
movq $0x0, -0x8(%rbp)
jmp 0x28214f
movss -0xc(%rbp), %xmm0
callq 0x297910
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2820f1
jmp 0x282120
movss -0xc(%rbp), %xmm0
callq 0x2972a0
movb %al, -0x19(%rbp)
callq 0x298100
movq %rax, -0x18(%rbp)
callq 0x298110
movb -0x19(%rbp), %dl
movq -0x18(%rbp), %rcx
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x28214f
movss -0xc(%rbp), %xmm0
movss 0x88ef3(%rip), %xmm2 # 0x30b020
movaps %xmm0, %xmm1
subss %xmm2, %xmm1
cvttss2si %xmm1, %rcx
cvttss2si %xmm0, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| /dcodeIO[P]wabt/src/interp/interp-math.h |
long wabt::interp::IntTruncSat<long, double>(double) | R WABT_VECTORCALL IntTruncSat(T val) {
if (WABT_UNLIKELY(std::isnan(val))) {
return 0;
} else if (WABT_UNLIKELY(!CanConvert<R>(val))) {
return std::signbit(val) ? std::numeric_limits<R>::min()
: std::numeric_limits<R>::max();
} else {
return static_cast<R>(val);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x297400
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2821c1
jmp 0x2821cb
movq $0x0, -0x8(%rbp)
jmp 0x28221a
movsd -0x10(%rbp), %xmm0
callq 0x2979c0
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2821e1
jmp 0x282210
movsd -0x10(%rbp), %xmm0
callq 0x297430
movb %al, -0x19(%rbp)
callq 0x2970f0
movq %rax, -0x18(%rbp)
callq 0x2980f0
movb -0x19(%rbp), %dl
movq -0x18(%rbp), %rcx
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x28221a
cvttsd2si -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| /dcodeIO[P]wabt/src/interp/interp-math.h |
unsigned long wabt::interp::IntTruncSat<unsigned long, double>(double) | R WABT_VECTORCALL IntTruncSat(T val) {
if (WABT_UNLIKELY(std::isnan(val))) {
return 0;
} else if (WABT_UNLIKELY(!CanConvert<R>(val))) {
return std::signbit(val) ? std::numeric_limits<R>::min()
: std::numeric_limits<R>::max();
} else {
return static_cast<R>(val);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x10(%rbp)
movsd -0x10(%rbp), %xmm0
callq 0x297400
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x282291
jmp 0x28229b
movq $0x0, -0x8(%rbp)
jmp 0x28230f
movsd -0x10(%rbp), %xmm0
callq 0x297a50
xorb $-0x1, %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2822b1
jmp 0x2822e0
movsd -0x10(%rbp), %xmm0
callq 0x297430
movb %al, -0x19(%rbp)
callq 0x298100
movq %rax, -0x18(%rbp)
callq 0x298110
movb -0x19(%rbp), %dl
movq -0x18(%rbp), %rcx
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x28230f
movsd -0x10(%rbp), %xmm0
movsd 0x88d5b(%rip), %xmm2 # 0x30b048
movaps %xmm0, %xmm1
subsd %xmm2, %xmm1
cvttsd2si %xmm1, %rcx
cvttsd2si %xmm0, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| /dcodeIO[P]wabt/src/interp/interp-math.h |
wabt::interp::RunResult wabt::interp::Thread::DoSimdBinop<unsigned char, unsigned char>(unsigned char (*)(unsigned char, unsigned char)) | RunResult Thread::DoSimdBinop(BinopFunc<R, T> f) {
using ST = typename Simd128<T>::Type;
using SR = typename Simd128<R>::Type;
static_assert(ST::lanes == SR::lanes, "SIMD lanes don't match");
auto rhs = Pop<ST>();
auto lhs = Pop<ST>();
SR result;
for (u8 i = 0; i < SR::lanes; ++i) {
result[i] = f(lhs[i], rhs[i]);
}
Push(result);
return RunResult::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x289a90
movq -0x60(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x289a90
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movb $0x0, -0x41(%rbp)
movzbl -0x41(%rbp), %eax
cmpl $0x10, %eax
jge 0x282f7e
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x30(%rbp), %rdi
movzbl -0x41(%rbp), %esi
callq 0x289ad0
movb (%rax), %al
movb %al, -0x71(%rbp)
leaq -0x20(%rbp), %rdi
movzbl -0x41(%rbp), %esi
callq 0x289ad0
movb -0x71(%rbp), %dl
movq %rax, %rcx
movq -0x70(%rbp), %rax
movzbl %dl, %edi
movzbl (%rcx), %esi
callq *%rax
movb %al, -0x61(%rbp)
leaq -0x40(%rbp), %rdi
movzbl -0x41(%rbp), %esi
callq 0x289ad0
movb -0x61(%rbp), %cl
movb %cl, (%rax)
movb -0x41(%rbp), %al
addb $0x1, %al
movb %al, -0x41(%rbp)
jmp 0x282f1d
movq -0x60(%rbp), %rdi
movq -0x40(%rbp), %rax
movq %rax, -0x51(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x49(%rbp)
movq -0x51(%rbp), %rsi
movq -0x49(%rbp), %rdx
callq 0x289af0
xorl %eax, %eax
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::RunResult wabt::interp::Thread::DoSimdBinop<unsigned int, unsigned int>(unsigned int (*)(unsigned int, unsigned int)) | RunResult Thread::DoSimdBinop(BinopFunc<R, T> f) {
using ST = typename Simd128<T>::Type;
using SR = typename Simd128<R>::Type;
static_assert(ST::lanes == SR::lanes, "SIMD lanes don't match");
auto rhs = Pop<ST>();
auto lhs = Pop<ST>();
SR result;
for (u8 i = 0; i < SR::lanes; ++i) {
result[i] = f(lhs[i], rhs[i]);
}
Push(result);
return RunResult::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x298c50
movq -0x60(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x298c50
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movb $0x0, -0x41(%rbp)
movzbl -0x41(%rbp), %eax
cmpl $0x4, %eax
jge 0x28367a
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x30(%rbp), %rdi
movzbl -0x41(%rbp), %esi
callq 0x298c90
movl (%rax), %eax
movl %eax, -0x74(%rbp)
leaq -0x20(%rbp), %rdi
movzbl -0x41(%rbp), %esi
callq 0x298c90
movl -0x74(%rbp), %edi
movq %rax, %rcx
movq -0x70(%rbp), %rax
movl (%rcx), %esi
callq *%rax
movl %eax, -0x64(%rbp)
leaq -0x40(%rbp), %rdi
movzbl -0x41(%rbp), %esi
callq 0x298c90
movl -0x64(%rbp), %ecx
movl %ecx, (%rax)
movb -0x41(%rbp), %al
addb $0x1, %al
movb %al, -0x41(%rbp)
jmp 0x28361d
movq -0x60(%rbp), %rdi
movq -0x40(%rbp), %rax
movq %rax, -0x54(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x4c(%rbp)
movq -0x54(%rbp), %rsi
movq -0x4c(%rbp), %rdx
callq 0x298a10
xorl %eax, %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::RunResult wabt::interp::Thread::DoSimdBinop<unsigned int, float>(unsigned int (*)(float, float)) | RunResult Thread::DoSimdBinop(BinopFunc<R, T> f) {
using ST = typename Simd128<T>::Type;
using SR = typename Simd128<R>::Type;
static_assert(ST::lanes == SR::lanes, "SIMD lanes don't match");
auto rhs = Pop<ST>();
auto lhs = Pop<ST>();
SR result;
for (u8 i = 0; i < SR::lanes; ++i) {
result[i] = f(lhs[i], rhs[i]);
}
Push(result);
return RunResult::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x298fd0
movq -0x60(%rbp), %rdi
movlpd %xmm0, -0x20(%rbp)
movlpd %xmm1, -0x18(%rbp)
callq 0x298fd0
movlpd %xmm0, -0x30(%rbp)
movlpd %xmm1, -0x28(%rbp)
movb $0x0, -0x41(%rbp)
movzbl -0x41(%rbp), %eax
cmpl $0x4, %eax
jge 0x283966
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x30(%rbp), %rdi
movzbl -0x41(%rbp), %esi
callq 0x299010
movss (%rax), %xmm0
movss %xmm0, -0x74(%rbp)
leaq -0x20(%rbp), %rdi
movzbl -0x41(%rbp), %esi
callq 0x299010
movss -0x74(%rbp), %xmm0
movq %rax, %rcx
movq -0x70(%rbp), %rax
movss (%rcx), %xmm1
callq *%rax
movl %eax, -0x64(%rbp)
leaq -0x40(%rbp), %rdi
movzbl -0x41(%rbp), %esi
callq 0x298c90
movl -0x64(%rbp), %ecx
movl %ecx, (%rax)
movb -0x41(%rbp), %al
addb $0x1, %al
movb %al, -0x41(%rbp)
jmp 0x283901
movq -0x60(%rbp), %rdi
movq -0x40(%rbp), %rax
movq %rax, -0x54(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x4c(%rbp)
movq -0x54(%rbp), %rsi
movq -0x4c(%rbp), %rdx
callq 0x298a10
xorl %eax, %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::RunResult wabt::interp::Thread::DoSimdShift<signed char, signed char>(signed char (*)(signed char, signed char)) | RunResult Thread::DoSimdShift(BinopFunc<R, T> f) {
using ST = typename Simd128<T>::Type;
using SR = typename Simd128<R>::Type;
static_assert(ST::lanes == SR::lanes, "SIMD lanes don't match");
auto amount = Pop<u32>();
auto lhs = Pop<ST>();
SR result;
for (u8 i = 0; i < SR::lanes; ++i) {
result[i] = f(lhs[i], amount);
}
Push(result);
return RunResult::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x27c4d0
movq -0x50(%rbp), %rdi
movl %eax, -0x14(%rbp)
callq 0x298570
movq %rax, -0x24(%rbp)
movq %rdx, -0x1c(%rbp)
movb $0x0, -0x35(%rbp)
movzbl -0x35(%rbp), %eax
cmpl $0x10, %eax
jge 0x284206
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x24(%rbp), %rdi
movzbl -0x35(%rbp), %esi
callq 0x2985b0
movq %rax, %rcx
movq -0x60(%rbp), %rax
movb (%rcx), %dl
movl -0x14(%rbp), %ecx
movsbl %dl, %edi
movsbl %cl, %esi
callq *%rax
movb %al, -0x51(%rbp)
leaq -0x34(%rbp), %rdi
movzbl -0x35(%rbp), %esi
callq 0x2985b0
movb -0x51(%rbp), %cl
movb %cl, (%rax)
movb -0x35(%rbp), %al
addb $0x1, %al
movb %al, -0x35(%rbp)
jmp 0x2841b5
movq -0x50(%rbp), %rdi
movq -0x34(%rbp), %rax
movq %rax, -0x45(%rbp)
movq -0x2c(%rbp), %rax
movq %rax, -0x3d(%rbp)
movq -0x45(%rbp), %rsi
movq -0x3d(%rbp), %rdx
callq 0x299370
xorl %eax, %eax
addq $0x60, %rsp
popq %rbp
retq
nop
| /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::RunResult wabt::interp::Thread::DoSimdUnop<unsigned short, unsigned short>(unsigned short (*)(unsigned short)) | RunResult Thread::DoSimdUnop(UnopFunc<R, T> f) {
using ST = typename Simd128<T>::Type;
using SR = typename Simd128<R>::Type;
auto val = Pop<ST>();
SR result;
std::transform(std::begin(val.v), std::end(val.v), std::begin(result.v), f);
Push(result);
return RunResult::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x2988e0
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x298670
movq %rax, -0x58(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x298680
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x298670
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq %rax, %rdx
movq -0x10(%rbp), %rcx
callq 0x299b60
movq -0x48(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x2986a0
xorl %eax, %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::RunResult wabt::interp::Thread::DoSimdShift<int, int>(int (*)(int, int)) | RunResult Thread::DoSimdShift(BinopFunc<R, T> f) {
using ST = typename Simd128<T>::Type;
using SR = typename Simd128<R>::Type;
static_assert(ST::lanes == SR::lanes, "SIMD lanes don't match");
auto amount = Pop<u32>();
auto lhs = Pop<ST>();
SR result;
for (u8 i = 0; i < SR::lanes; ++i) {
result[i] = f(lhs[i], amount);
}
Push(result);
return RunResult::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x27c4d0
movq -0x50(%rbp), %rdi
movl %eax, -0x14(%rbp)
callq 0x298b80
movq %rax, -0x24(%rbp)
movq %rdx, -0x1c(%rbp)
movb $0x0, -0x35(%rbp)
movzbl -0x35(%rbp), %eax
cmpl $0x4, %eax
jge 0x284e30
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x24(%rbp), %rdi
movzbl -0x35(%rbp), %esi
callq 0x298bc0
movq %rax, %rcx
movq -0x60(%rbp), %rax
movl (%rcx), %edi
movl -0x14(%rbp), %esi
callq *%rax
movl %eax, -0x54(%rbp)
leaq -0x34(%rbp), %rdi
movzbl -0x35(%rbp), %esi
callq 0x298bc0
movl -0x54(%rbp), %ecx
movl %ecx, (%rax)
movb -0x35(%rbp), %al
addb $0x1, %al
movb %al, -0x35(%rbp)
jmp 0x284de5
movq -0x50(%rbp), %rdi
movq -0x34(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x2c(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
callq 0x299570
xorl %eax, %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
| /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::RunResult wabt::interp::Thread::DoSimdShift<long, long>(long (*)(long, long)) | RunResult Thread::DoSimdShift(BinopFunc<R, T> f) {
using ST = typename Simd128<T>::Type;
using SR = typename Simd128<R>::Type;
static_assert(ST::lanes == SR::lanes, "SIMD lanes don't match");
auto amount = Pop<u32>();
auto lhs = Pop<ST>();
SR result;
for (u8 i = 0; i < SR::lanes; ++i) {
result[i] = f(lhs[i], amount);
}
Push(result);
return RunResult::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x27c4d0
movq -0x58(%rbp), %rdi
movl %eax, -0x14(%rbp)
callq 0x29a340
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movb $0x0, -0x39(%rbp)
movzbl -0x39(%rbp), %eax
cmpl $0x2, %eax
jge 0x285076
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x28(%rbp), %rdi
movzbl -0x39(%rbp), %esi
callq 0x29a380
movq %rax, %rcx
movq -0x68(%rbp), %rax
movq (%rcx), %rdi
movl -0x14(%rbp), %ecx
movl %ecx, %esi
callq *%rax
movq %rax, -0x60(%rbp)
leaq -0x38(%rbp), %rdi
movzbl -0x39(%rbp), %esi
callq 0x29a380
movq -0x60(%rbp), %rcx
movq %rcx, (%rax)
movb -0x39(%rbp), %al
addb $0x1, %al
movb %al, -0x39(%rbp)
jmp 0x285025
movq -0x58(%rbp), %rdi
movq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x29a3a0
xorl %eax, %eax
addq $0x70, %rsp
popq %rbp
retq
nop
| /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::RunResult wabt::interp::Thread::DoSimdUnop<float, float>(float (*)(float)) | RunResult Thread::DoSimdUnop(UnopFunc<R, T> f) {
using ST = typename Simd128<T>::Type;
using SR = typename Simd128<R>::Type;
auto val = Pop<ST>();
SR result;
std::transform(std::begin(val.v), std::end(val.v), std::begin(result.v), f);
Push(result);
return RunResult::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x298fd0
movlpd %xmm0, -0x20(%rbp)
movlpd %xmm1, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x298e20
movq -0x60(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x298e30
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x298e20
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq %rax, %rdx
movq -0x10(%rbp), %rcx
callq 0x29a510
movq -0x48(%rbp), %rdi
movups -0x30(%rbp), %xmm0
movaps %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movsd -0x38(%rbp), %xmm1
callq 0x298e50
xorl %eax, %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::RunResult wabt::interp::Thread::DoSimdUnop<unsigned int, float>(unsigned int (*)(float)) | RunResult Thread::DoSimdUnop(UnopFunc<R, T> f) {
using ST = typename Simd128<T>::Type;
using SR = typename Simd128<R>::Type;
auto val = Pop<ST>();
SR result;
std::transform(std::begin(val.v), std::end(val.v), std::begin(result.v), f);
Push(result);
return RunResult::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x298fd0
movlpd %xmm0, -0x20(%rbp)
movlpd %xmm1, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x298e20
movq %rax, -0x58(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x298e30
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2989e0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq %rax, %rdx
movq -0x10(%rbp), %rcx
callq 0x29a640
movq -0x48(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0x298a10
xorl %eax, %eax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::RunResult wabt::interp::Thread::DoSimdNarrow<wabt::interp::Simd<signed char, (unsigned char)16>, wabt::interp::Simd<short, (unsigned char)8>>() | RunResult Thread::DoSimdNarrow() {
using SL = typename S::LaneType;
using TL = typename T::LaneType;
auto rhs = Pop<T>();
auto lhs = Pop<T>();
S result;
for (u8 i = 0; i < T::lanes; ++i) {
result[i] = Saturate<SL, TL>(lhs[i]);
}
for (u8 i = 0; i < T::lanes; ++i) {
result[T::lanes + i] = Saturate<SL, TL>(rhs[i]);
}
Push(result);
return RunResult::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x298810
movq -0x58(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
callq 0x298810
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movb $0x0, -0x39(%rbp)
movzbl -0x39(%rbp), %eax
cmpl $0x8, %eax
jge 0x285ad3
leaq -0x28(%rbp), %rdi
movzbl -0x39(%rbp), %esi
callq 0x298850
movswl (%rax), %edi
callq 0x29a850
movb %al, -0x59(%rbp)
leaq -0x38(%rbp), %rdi
movzbl -0x39(%rbp), %esi
callq 0x2985b0
movb -0x59(%rbp), %cl
movb %cl, (%rax)
movb -0x39(%rbp), %al
addb $0x1, %al
movb %al, -0x39(%rbp)
jmp 0x285a96
movb $0x0, -0x3a(%rbp)
movzbl -0x3a(%rbp), %eax
cmpl $0x8, %eax
jge 0x285b1a
leaq -0x18(%rbp), %rdi
movzbl -0x3a(%rbp), %esi
callq 0x298850
movswl (%rax), %edi
callq 0x29a850
movb %al, -0x5a(%rbp)
movzbl -0x3a(%rbp), %eax
addl $0x8, %eax
leaq -0x38(%rbp), %rdi
movzbl %al, %esi
callq 0x2985b0
movb -0x5a(%rbp), %cl
movb %cl, (%rax)
movb -0x3a(%rbp), %al
addb $0x1, %al
movb %al, -0x3a(%rbp)
jmp 0x285ad7
movq -0x58(%rbp), %rdi
movq -0x38(%rbp), %rax
movq %rax, -0x4a(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x42(%rbp)
movq -0x4a(%rbp), %rsi
movq -0x42(%rbp), %rdx
callq 0x299370
xorl %eax, %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::RunResult wabt::interp::Thread::DoSimdWiden<wabt::interp::Simd<unsigned short, (unsigned char)8>, wabt::interp::Simd<unsigned char, (unsigned char)16>, false>() | RunResult Thread::DoSimdWiden() {
auto val = Pop<T>();
S result;
for (u8 i = 0; i < S::lanes; ++i) {
result[i] = val[(low ? 0 : S::lanes) + i];
}
Push(result);
return RunResult::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x289a90
movq %rax, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movb $0x0, -0x29(%rbp)
movzbl -0x29(%rbp), %eax
cmpl $0x8, %eax
jge 0x286036
movzbl -0x29(%rbp), %eax
addl $0x8, %eax
leaq -0x18(%rbp), %rdi
movzbl %al, %esi
callq 0x289ad0
movzbl (%rax), %eax
movw %ax, -0x4a(%rbp)
leaq -0x28(%rbp), %rdi
movzbl -0x29(%rbp), %esi
callq 0x298920
movw -0x4a(%rbp), %cx
movw %cx, (%rax)
movb -0x29(%rbp), %al
addb $0x1, %al
movb %al, -0x29(%rbp)
jmp 0x285ff5
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x3a(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x32(%rbp)
movq -0x3a(%rbp), %rsi
movq -0x32(%rbp), %rdx
callq 0x2986a0
xorl %eax, %eax
addq $0x50, %rsp
popq %rbp
retq
nop
| /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::RunResult wabt::interp::Thread::DoSimdLoadExtend<wabt::interp::Simd<unsigned short, (unsigned char)8>, wabt::interp::Simd<unsigned char, (unsigned char)8>>(wabt::interp::Instr, wabt::interp::RefPtr<wabt::interp::Trap>*) | RunResult Thread::DoSimdLoadExtend(Instr instr, Trap::Ptr* out_trap) {
T val;
if (Load<T>(instr, &val, out_trap) != RunResult::Ok) {
return RunResult::Trap;
}
S result;
for (u8 i = 0; i < S::lanes; ++i) {
result[i] = val[i];
}
Push(result);
return RunResult::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
leaq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movq (%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdx
leaq -0x38(%rbp), %rax
leaq -0x20(%rbp), %rsi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x29ab90
cmpl $0x0, %eax
je 0x2863fe
movl $0x2, -0x4(%rbp)
jmp 0x286465
movb $0x0, -0x49(%rbp)
movzbl -0x49(%rbp), %eax
cmpl $0x8, %eax
jge 0x28643d
leaq -0x20(%rbp), %rdi
movzbl -0x49(%rbp), %esi
callq 0x29ad40
movzbl (%rax), %eax
movw %ax, -0x6a(%rbp)
leaq -0x48(%rbp), %rdi
movzbl -0x49(%rbp), %esi
callq 0x298920
movw -0x6a(%rbp), %cx
movw %cx, (%rax)
movb -0x49(%rbp), %al
addb $0x1, %al
movb %al, -0x49(%rbp)
jmp 0x286402
movq -0x68(%rbp), %rdi
movq -0x48(%rbp), %rax
movq %rax, -0x5a(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x52(%rbp)
movq -0x5a(%rbp), %rsi
movq -0x52(%rbp), %rdx
callq 0x2986a0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::RunResult wabt::interp::Thread::DoSimdLoadExtend<wabt::interp::Simd<unsigned int, (unsigned char)4>, wabt::interp::Simd<unsigned short, (unsigned char)4>>(wabt::interp::Instr, wabt::interp::RefPtr<wabt::interp::Trap>*) | RunResult Thread::DoSimdLoadExtend(Instr instr, Trap::Ptr* out_trap) {
T val;
if (Load<T>(instr, &val, out_trap) != RunResult::Ok) {
return RunResult::Trap;
}
S result;
for (u8 i = 0; i < S::lanes; ++i) {
result[i] = val[i];
}
Push(result);
return RunResult::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
leaq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movq (%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdx
leaq -0x38(%rbp), %rax
leaq -0x20(%rbp), %rsi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x29b090
cmpl $0x0, %eax
je 0x2865ce
movl $0x2, -0x4(%rbp)
jmp 0x286632
movb $0x0, -0x49(%rbp)
movzbl -0x49(%rbp), %eax
cmpl $0x4, %eax
jge 0x28660a
leaq -0x20(%rbp), %rdi
movzbl -0x49(%rbp), %esi
callq 0x29b240
movzwl (%rax), %eax
movl %eax, -0x6c(%rbp)
leaq -0x48(%rbp), %rdi
movzbl -0x49(%rbp), %esi
callq 0x298c90
movl -0x6c(%rbp), %ecx
movl %ecx, (%rax)
movb -0x49(%rbp), %al
addb $0x1, %al
movb %al, -0x49(%rbp)
jmp 0x2865d2
movq -0x68(%rbp), %rdi
movq -0x48(%rbp), %rax
movq %rax, -0x5c(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x54(%rbp)
movq -0x5c(%rbp), %rsi
movq -0x54(%rbp), %rdx
callq 0x298a10
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nop
| /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::RunResult wabt::interp::Thread::DoSimdLoadExtend<wabt::interp::Simd<unsigned long, (unsigned char)2>, wabt::interp::Simd<unsigned int, (unsigned char)2>>(wabt::interp::Instr, wabt::interp::RefPtr<wabt::interp::Trap>*) | RunResult Thread::DoSimdLoadExtend(Instr instr, Trap::Ptr* out_trap) {
T val;
if (Load<T>(instr, &val, out_trap) != RunResult::Ok) {
return RunResult::Trap;
}
S result;
for (u8 i = 0; i < S::lanes; ++i) {
result[i] = val[i];
}
Push(result);
return RunResult::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
leaq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movq (%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdx
leaq -0x38(%rbp), %rax
leaq -0x20(%rbp), %rsi
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x29b590
cmpl $0x0, %eax
je 0x28679e
movl $0x2, -0x4(%rbp)
jmp 0x286804
movb $0x0, -0x49(%rbp)
movzbl -0x49(%rbp), %eax
cmpl $0x2, %eax
jge 0x2867dc
leaq -0x20(%rbp), %rdi
movzbl -0x49(%rbp), %esi
callq 0x29b740
movl (%rax), %eax
movq %rax, -0x70(%rbp)
leaq -0x48(%rbp), %rdi
movzbl -0x49(%rbp), %esi
callq 0x289a00
movq -0x70(%rbp), %rcx
movq %rcx, (%rax)
movb -0x49(%rbp), %al
addb $0x1, %al
movb %al, -0x49(%rbp)
jmp 0x2867a2
movq -0x68(%rbp), %rdi
movq -0x48(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
callq 0x289a20
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
| /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::RunResult wabt::interp::Thread::DoAtomicLoad<unsigned long, unsigned short>(wabt::interp::Instr, wabt::interp::RefPtr<wabt::interp::Trap>*) | RunResult Thread::DoAtomicLoad(Instr instr, Trap::Ptr* out_trap) {
Memory::Ptr memory{store_, inst_->memories()[instr.imm_u32x2.fst]};
u64 offset = PopPtr(memory);
V val;
TRAP_IF(Failed(memory->AtomicLoad(offset, instr.imm_u32x2.snd, &val)),
StringPrintf("invalid atomic access at %" PRIaddress "+%u", offset,
instr.imm_u32x2.snd));
Push(static_cast<T>(val));
return RunResult::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movq 0x88(%rax), %rcx
movq %rcx, -0xa0(%rbp)
movq 0x90(%rax), %rdi
callq 0x27ddb0
movq %rax, %rdi
movq -0x90(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %esi
callq 0x1cf260
movq -0xa0(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x1d5480
movq -0x98(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x276990
movq %rax, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1d55a0
movq %rax, %rdi
movq -0x90(%rbp), %rax
movq -0x40(%rbp), %rsi
movl 0xc(%rax), %eax
movl %eax, %edx
leaq -0x42(%rbp), %rcx
callq 0x29ba90
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %edi
callq 0x1cba60
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2871b3
jmp 0x287239
movq -0x98(%rbp), %rcx
movq -0x90(%rbp), %rax
movq 0x88(%rcx), %rcx
movq %rcx, -0xa8(%rbp)
movq -0x40(%rbp), %rdx
movl 0xc(%rax), %ecx
leaq -0x80(%rbp), %rdi
leaq 0x84f98(%rip), %rsi # 0x30c179
movb $0x0, %al
callq 0x1cd050
movq -0x98(%rbp), %rcx
movq -0xa8(%rbp), %rsi
addq $0x40, %rcx
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rdx
callq 0x27af40
movq -0x18(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x27afa0
movl $0x2, -0x4(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1cf440
leaq -0x80(%rbp), %rdi
callq 0x1a6250
movl $0x1, -0x84(%rbp)
jmp 0x28725c
movq -0x98(%rbp), %rdi
movzwl -0x42(%rbp), %eax
movl %eax, %esi
callq 0x27ddd0
movl $0x0, -0x4(%rbp)
movl $0x1, -0x84(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1cd750
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::RunResult wabt::interp::Thread::DoAtomicStore<unsigned int, unsigned int>(wabt::interp::Instr, wabt::interp::RefPtr<wabt::interp::Trap>*) | RunResult Thread::DoAtomicStore(Instr instr, Trap::Ptr* out_trap) {
Memory::Ptr memory{store_, inst_->memories()[instr.imm_u32x2.fst]};
V val = static_cast<V>(Pop<T>());
u64 offset = PopPtr(memory);
TRAP_IF(Failed(memory->AtomicStore(offset, instr.imm_u32x2.snd, val)),
StringPrintf("invalid atomic access at %" PRIaddress "+%u", offset,
instr.imm_u32x2.snd));
return RunResult::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq 0x88(%rax), %rcx
movq %rcx, -0xa8(%rbp)
movq 0x90(%rax), %rdi
callq 0x27ddb0
movq %rax, %rdi
movq -0x98(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %esi
callq 0x1cf260
movq -0xa8(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x1d5480
movq -0xa0(%rbp), %rdi
callq 0x27c4d0
movq -0xa0(%rbp), %rdi
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x276990
movq %rax, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1d55a0
movq %rax, %rdi
movq -0x98(%rbp), %rax
movq -0x48(%rbp), %rsi
movl 0xc(%rax), %eax
movl %eax, %edx
movl -0x3c(%rbp), %ecx
callq 0x29bb40
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %edi
callq 0x1cba60
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2874d1
jmp 0x287560
movq -0xa0(%rbp), %rcx
movq -0x98(%rbp), %rax
movq 0x88(%rcx), %rcx
movq %rcx, -0xb0(%rbp)
movq -0x48(%rbp), %rdx
movl 0xc(%rax), %ecx
leaq -0x88(%rbp), %rdi
leaq 0x84c77(%rip), %rsi # 0x30c179
movb $0x0, %al
callq 0x1cd050
movq -0xa0(%rbp), %rcx
movq -0xb0(%rbp), %rsi
addq $0x40, %rcx
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rdx
callq 0x27af40
movq -0x18(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x27afa0
movl $0x2, -0x4(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1cf440
leaq -0x88(%rbp), %rdi
callq 0x1a6250
movl $0x1, -0x8c(%rbp)
jmp 0x287571
movl $0x0, -0x4(%rbp)
movl $0x1, -0x8c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1cd750
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::RunResult wabt::interp::Thread::DoAtomicStore<unsigned long, unsigned short>(wabt::interp::Instr, wabt::interp::RefPtr<wabt::interp::Trap>*) | RunResult Thread::DoAtomicStore(Instr instr, Trap::Ptr* out_trap) {
Memory::Ptr memory{store_, inst_->memories()[instr.imm_u32x2.fst]};
V val = static_cast<V>(Pop<T>());
u64 offset = PopPtr(memory);
TRAP_IF(Failed(memory->AtomicStore(offset, instr.imm_u32x2.snd, val)),
StringPrintf("invalid atomic access at %" PRIaddress "+%u", offset,
instr.imm_u32x2.snd));
return RunResult::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq 0x88(%rax), %rcx
movq %rcx, -0xa8(%rbp)
movq 0x90(%rax), %rdi
callq 0x27ddb0
movq %rax, %rdi
movq -0x98(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %esi
callq 0x1cf260
movq -0xa8(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x1d5480
movq -0xa0(%rbp), %rdi
callq 0x27c4a0
movq -0xa0(%rbp), %rdi
movw %ax, -0x3a(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x276990
movq %rax, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1d55a0
movq %rax, %rdi
movq -0x98(%rbp), %rax
movq -0x48(%rbp), %rsi
movl 0xc(%rax), %eax
movl %eax, %edx
movzwl -0x3a(%rbp), %ecx
callq 0x29bd50
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %edi
callq 0x1cba60
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x287ca3
jmp 0x287d32
movq -0xa0(%rbp), %rcx
movq -0x98(%rbp), %rax
movq 0x88(%rcx), %rcx
movq %rcx, -0xb0(%rbp)
movq -0x48(%rbp), %rdx
movl 0xc(%rax), %ecx
leaq -0x88(%rbp), %rdi
leaq 0x844a5(%rip), %rsi # 0x30c179
movb $0x0, %al
callq 0x1cd050
movq -0xa0(%rbp), %rcx
movq -0xb0(%rbp), %rsi
addq $0x40, %rcx
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rdx
callq 0x27af40
movq -0x18(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x27afa0
movl $0x2, -0x4(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1cf440
leaq -0x88(%rbp), %rdi
callq 0x1a6250
movl $0x1, -0x8c(%rbp)
jmp 0x287d43
movl $0x0, -0x4(%rbp)
movl $0x1, -0x8c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1cd750
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::RunResult wabt::interp::Thread::DoAtomicRmw<unsigned int, unsigned int>(unsigned int (*)(unsigned int, unsigned int), wabt::interp::Instr, wabt::interp::RefPtr<wabt::interp::Trap>*) | RunResult Thread::DoAtomicRmw(BinopFunc<T, T> f,
Instr instr,
Trap::Ptr* out_trap) {
Memory::Ptr memory{store_, inst_->memories()[instr.imm_u32x2.fst]};
T val = static_cast<T>(Pop<R>());
u64 offset = PopPtr(memory);
T old;
TRAP_IF(Failed(memory->AtomicRmw(offset, instr.imm_u32x2.snd, val, f, &old)),
StringPrintf("invalid atomic access at %" PRIaddress "+%u", offset,
instr.imm_u32x2.snd));
Push(static_cast<R>(old));
return RunResult::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq 0x88(%rax), %rcx
movq %rcx, -0xb0(%rbp)
movq 0x90(%rax), %rdi
callq 0x27ddb0
movq %rax, %rdi
movq -0xa0(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %esi
callq 0x1cf260
movq -0xb0(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x1d5480
movq -0xa8(%rbp), %rdi
callq 0x27c4d0
movq -0xa8(%rbp), %rdi
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x276990
movq %rax, -0x50(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1d55a0
movq %rax, %rdi
movq -0xa0(%rbp), %rax
movq -0x50(%rbp), %rsi
movl 0xc(%rax), %eax
movl %eax, %edx
movl -0x44(%rbp), %ecx
leaq -0x18(%rbp), %r8
leaq -0x54(%rbp), %r9
callq 0x29be00
movl %eax, -0x58(%rbp)
movl -0x58(%rbp), %edi
callq 0x1cba60
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x287fcd
jmp 0x28805c
movq -0xa8(%rbp), %rcx
movq -0xa0(%rbp), %rax
movq 0x88(%rcx), %rcx
movq %rcx, -0xb8(%rbp)
movq -0x50(%rbp), %rdx
movl 0xc(%rax), %ecx
leaq -0x90(%rbp), %rdi
leaq 0x8417b(%rip), %rsi # 0x30c179
movb $0x0, %al
callq 0x1cd050
movq -0xa8(%rbp), %rcx
movq -0xb8(%rbp), %rsi
addq $0x40, %rcx
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rdx
callq 0x27af40
movq -0x20(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x27afa0
movl $0x2, -0x4(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1cf440
leaq -0x90(%rbp), %rdi
callq 0x1a6250
movl $0x1, -0x94(%rbp)
jmp 0x28807c
movq -0xa8(%rbp), %rdi
movl -0x54(%rbp), %esi
callq 0x27de50
movl $0x0, -0x4(%rbp)
movl $0x1, -0x94(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1cd750
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::RunResult wabt::interp::Thread::DoAtomicRmw<unsigned int, unsigned char>(unsigned char (*)(unsigned char, unsigned char), wabt::interp::Instr, wabt::interp::RefPtr<wabt::interp::Trap>*) | RunResult Thread::DoAtomicRmw(BinopFunc<T, T> f,
Instr instr,
Trap::Ptr* out_trap) {
Memory::Ptr memory{store_, inst_->memories()[instr.imm_u32x2.fst]};
T val = static_cast<T>(Pop<R>());
u64 offset = PopPtr(memory);
T old;
TRAP_IF(Failed(memory->AtomicRmw(offset, instr.imm_u32x2.snd, val, f, &old)),
StringPrintf("invalid atomic access at %" PRIaddress "+%u", offset,
instr.imm_u32x2.snd));
Push(static_cast<R>(old));
return RunResult::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq 0x88(%rax), %rcx
movq %rcx, -0xb0(%rbp)
movq 0x90(%rax), %rdi
callq 0x27ddb0
movq %rax, %rdi
movq -0xa0(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %esi
callq 0x1cf260
movq -0xb0(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x1d5480
movq -0xa8(%rbp), %rdi
callq 0x27c4d0
movq -0xa8(%rbp), %rdi
movb %al, -0x41(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x276990
movq %rax, -0x50(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1d55a0
movq %rax, %rdi
movq -0xa0(%rbp), %rax
movq -0x50(%rbp), %rsi
movl 0xc(%rax), %eax
movl %eax, %edx
leaq -0x18(%rbp), %r8
leaq -0x51(%rbp), %r9
movzbl -0x41(%rbp), %ecx
callq 0x29bfc0
movl %eax, -0x58(%rbp)
movl -0x58(%rbp), %edi
callq 0x1cba60
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x28832e
jmp 0x2883bd
movq -0xa8(%rbp), %rcx
movq -0xa0(%rbp), %rax
movq 0x88(%rcx), %rcx
movq %rcx, -0xb8(%rbp)
movq -0x50(%rbp), %rdx
movl 0xc(%rax), %ecx
leaq -0x90(%rbp), %rdi
leaq 0x83e1a(%rip), %rsi # 0x30c179
movb $0x0, %al
callq 0x1cd050
movq -0xa8(%rbp), %rcx
movq -0xb8(%rbp), %rsi
addq $0x40, %rcx
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rdx
callq 0x27af40
movq -0x20(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x27afa0
movl $0x2, -0x4(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1cf440
leaq -0x90(%rbp), %rdi
callq 0x1a6250
movl $0x1, -0x94(%rbp)
jmp 0x2883de
movq -0xa8(%rbp), %rdi
movzbl -0x51(%rbp), %esi
callq 0x27de50
movl $0x0, -0x4(%rbp)
movl $0x1, -0x94(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1cd750
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::RunResult wabt::interp::Thread::DoAtomicRmw<unsigned long, unsigned int>(unsigned int (*)(unsigned int, unsigned int), wabt::interp::Instr, wabt::interp::RefPtr<wabt::interp::Trap>*) | RunResult Thread::DoAtomicRmw(BinopFunc<T, T> f,
Instr instr,
Trap::Ptr* out_trap) {
Memory::Ptr memory{store_, inst_->memories()[instr.imm_u32x2.fst]};
T val = static_cast<T>(Pop<R>());
u64 offset = PopPtr(memory);
T old;
TRAP_IF(Failed(memory->AtomicRmw(offset, instr.imm_u32x2.snd, val, f, &old)),
StringPrintf("invalid atomic access at %" PRIaddress "+%u", offset,
instr.imm_u32x2.snd));
Push(static_cast<R>(old));
return RunResult::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq 0x88(%rax), %rcx
movq %rcx, -0xb0(%rbp)
movq 0x90(%rax), %rdi
callq 0x27ddb0
movq %rax, %rdi
movq -0xa0(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %esi
callq 0x1cf260
movq -0xb0(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x1d5480
movq -0xa8(%rbp), %rdi
callq 0x27c4a0
movq -0xa8(%rbp), %rdi
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x276990
movq %rax, -0x50(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1d55a0
movq %rax, %rdi
movq -0xa0(%rbp), %rax
movq -0x50(%rbp), %rsi
movl 0xc(%rax), %eax
movl %eax, %edx
movl -0x44(%rbp), %ecx
leaq -0x18(%rbp), %r8
leaq -0x54(%rbp), %r9
callq 0x29be00
movl %eax, -0x58(%rbp)
movl -0x58(%rbp), %edi
callq 0x1cba60
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2889ed
jmp 0x288a7c
movq -0xa8(%rbp), %rcx
movq -0xa0(%rbp), %rax
movq 0x88(%rcx), %rcx
movq %rcx, -0xb8(%rbp)
movq -0x50(%rbp), %rdx
movl 0xc(%rax), %ecx
leaq -0x90(%rbp), %rdi
leaq 0x8375b(%rip), %rsi # 0x30c179
movb $0x0, %al
callq 0x1cd050
movq -0xa8(%rbp), %rcx
movq -0xb8(%rbp), %rsi
addq $0x40, %rcx
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rdx
callq 0x27af40
movq -0x20(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x27afa0
movl $0x2, -0x4(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1cf440
leaq -0x90(%rbp), %rdi
callq 0x1a6250
movl $0x1, -0x94(%rbp)
jmp 0x288a9e
movq -0xa8(%rbp), %rdi
movl -0x54(%rbp), %eax
movl %eax, %esi
callq 0x27ddd0
movl $0x0, -0x4(%rbp)
movl $0x1, -0x94(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1cd750
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::RunResult wabt::interp::Thread::DoAtomicRmwCmpxchg<unsigned int, unsigned int>(wabt::interp::Instr, wabt::interp::RefPtr<wabt::interp::Trap>*) | RunResult Thread::DoAtomicRmwCmpxchg(Instr instr, Trap::Ptr* out_trap) {
Memory::Ptr memory{store_, inst_->memories()[instr.imm_u32x2.fst]};
V replace = static_cast<V>(Pop<T>());
V expect = static_cast<V>(Pop<T>());
V old;
u64 offset = PopPtr(memory);
TRAP_IF(Failed(memory->AtomicRmwCmpxchg(offset, instr.imm_u32x2.snd, expect,
replace, &old)),
StringPrintf("invalid atomic access at %" PRIaddress "+%u", offset,
instr.imm_u32x2.snd));
Push(static_cast<T>(old));
return RunResult::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq 0x88(%rax), %rcx
movq %rcx, -0xb0(%rbp)
movq 0x90(%rax), %rdi
callq 0x27ddb0
movq %rax, %rdi
movq -0xa0(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %esi
callq 0x1cf260
movq -0xb0(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x1d5480
movq -0xa8(%rbp), %rdi
callq 0x27c4d0
movq -0xa8(%rbp), %rdi
movl %eax, -0x3c(%rbp)
callq 0x27c4d0
movq -0xa8(%rbp), %rdi
movl %eax, -0x40(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x276990
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1d55a0
movq %rax, %rdi
movq -0xa0(%rbp), %rax
movq -0x50(%rbp), %rsi
movl 0xc(%rax), %eax
movl %eax, %edx
movl -0x40(%rbp), %ecx
movl -0x3c(%rbp), %r8d
leaq -0x44(%rbp), %r9
callq 0x29c180
movl %eax, -0x54(%rbp)
movl -0x54(%rbp), %edi
callq 0x1cba60
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x288cd8
jmp 0x288d67
movq -0xa8(%rbp), %rcx
movq -0xa0(%rbp), %rax
movq 0x88(%rcx), %rcx
movq %rcx, -0xb8(%rbp)
movq -0x50(%rbp), %rdx
movl 0xc(%rax), %ecx
leaq -0x90(%rbp), %rdi
leaq 0x83470(%rip), %rsi # 0x30c179
movb $0x0, %al
callq 0x1cd050
movq -0xa8(%rbp), %rcx
movq -0xb8(%rbp), %rsi
addq $0x40, %rcx
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rdx
callq 0x27af40
movq -0x18(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x27afa0
movl $0x2, -0x4(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1cf440
leaq -0x90(%rbp), %rdi
callq 0x1a6250
movl $0x1, -0x94(%rbp)
jmp 0x288d87
movq -0xa8(%rbp), %rdi
movl -0x44(%rbp), %esi
callq 0x27de50
movl $0x0, -0x4(%rbp)
movl $0x1, -0x94(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1cd750
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nopl (%rax)
| /dcodeIO[P]wabt/src/interp/interp.cc |
unsigned long wabt::interp::FreeList<std::unique_ptr<wabt::interp::Object, std::default_delete<wabt::interp::Object>>>::New<wabt::interp::Thread*>(wabt::interp::Thread*&&) | auto FreeList<T>::New(Args&&... args) -> Index {
if (!free_.empty()) {
Index index = free_.back();
assert(is_free_[index]);
free_.pop_back();
is_free_[index] = false;
list_[index] = T(std::forward<Args>(args)...);
return index;
}
assert(list_.size() == is_free_.size());
is_free_.push_back(false);
list_.emplace_back(std::forward<Args>(args)...);
return list_.size() - 1;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x18, %rdi
callq 0x1d1690
testb $0x1, %al
jne 0x28a7a3
movq -0x50(%rbp), %rdi
addq $0x18, %rdi
callq 0x1d16d0
movq -0x50(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x20(%rbp)
addq $0x30, %rdi
movq -0x20(%rbp), %rsi
callq 0x1d1710
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1d1770
testb $0x1, %al
jne 0x28a715
jmp 0x28a717
jmp 0x28a736
leaq 0x77907(%rip), %rdi # 0x302025
leaq 0x77910(%rip), %rsi # 0x302035
movl $0x92, %edx
leaq 0x8114c(%rip), %rcx # 0x30b87d
callq 0x1a6290
movq -0x50(%rbp), %rdi
addq $0x18, %rdi
callq 0x1d17a0
movq -0x50(%rbp), %rdi
addq $0x30, %rdi
movq -0x20(%rbp), %rsi
callq 0x1d1710
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
callq 0x1d17d0
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq -0x48(%rbp), %rdi
callq 0x1d1820
movq -0x50(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1d1850
movq %rax, %rdi
leaq -0x48(%rbp), %rsi
callq 0x1d1870
leaq -0x48(%rbp), %rdi
callq 0x1d18a0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x28a817
movq -0x50(%rbp), %rdi
callq 0x1d18f0
movq -0x50(%rbp), %rdi
movq %rax, -0x58(%rbp)
addq $0x30, %rdi
callq 0x1d1910
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jne 0x28a7cb
jmp 0x28a7ea
leaq 0x77965(%rip), %rdi # 0x302137
leaq 0x7785c(%rip), %rsi # 0x302035
movl $0x98, %edx
leaq 0x81098(%rip), %rcx # 0x30b87d
callq 0x1a6290
movq -0x50(%rbp), %rdi
addq $0x30, %rdi
xorl %esi, %esi
callq 0x1d1970
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x28a970
movq -0x50(%rbp), %rdi
callq 0x1d18f0
subq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /dcodeIO[P]wabt/src/interp/interp-inl.h |
wabt::interp::RunResult wabt::interp::Thread::Load<unsigned long>(wabt::interp::Instr, unsigned long*, wabt::interp::RefPtr<wabt::interp::Trap>*) | RunResult Thread::Load(Instr instr, T* out, Trap::Ptr* out_trap) {
Memory::Ptr memory{store_, inst_->memories()[instr.imm_u32x2.fst]};
u64 offset = PopPtr(memory);
TRAP_IF(Failed(memory->Load(offset, instr.imm_u32x2.snd, out)),
StringPrintf("out of bounds memory access: access at %" PRIu64
"+%" PRIzd " >= max value %" PRIu64,
offset + instr.imm_u32x2.snd, sizeof(T),
memory->ByteSize()));
return RunResult::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq 0x88(%rax), %rcx
movq %rcx, -0xa8(%rbp)
movq 0x90(%rax), %rdi
callq 0x27ddb0
movq %rax, %rdi
movq -0x98(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %esi
callq 0x1cf260
movq -0xa8(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x1d5480
movq -0xa0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x276990
movq %rax, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1d55a0
movq %rax, %rdi
movq -0x98(%rbp), %rax
movq -0x48(%rbp), %rsi
movl 0xc(%rax), %eax
movl %eax, %edx
movq -0x18(%rbp), %rcx
callq 0x295780
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %edi
callq 0x1cba60
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x295697
jmp 0x295750
movq -0xa0(%rbp), %rax
movq -0x98(%rbp), %rcx
movq 0x88(%rax), %rax
movq %rax, -0xb0(%rbp)
movq -0x48(%rbp), %rax
movl 0xc(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0xb8(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1d55a0
movq %rax, %rdi
callq 0x27b710
movq -0xb8(%rbp), %rdx
movq %rax, %r8
leaq -0x88(%rbp), %rdi
leaq 0x7662b(%rip), %rsi # 0x30bd18
movl $0x8, %ecx
movb $0x0, %al
callq 0x1cd050
movq -0xa0(%rbp), %rcx
movq -0xb0(%rbp), %rsi
addq $0x40, %rcx
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rdx
callq 0x27af40
movq -0x20(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x27afa0
movl $0x2, -0x4(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1cf440
leaq -0x88(%rbp), %rdi
callq 0x1a6250
movl $0x1, -0x8c(%rbp)
jmp 0x295761
movl $0x0, -0x4(%rbp)
movl $0x1, -0x8c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1cd750
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::RunResult wabt::interp::Thread::Load<float>(wabt::interp::Instr, float*, wabt::interp::RefPtr<wabt::interp::Trap>*) | RunResult Thread::Load(Instr instr, T* out, Trap::Ptr* out_trap) {
Memory::Ptr memory{store_, inst_->memories()[instr.imm_u32x2.fst]};
u64 offset = PopPtr(memory);
TRAP_IF(Failed(memory->Load(offset, instr.imm_u32x2.snd, out)),
StringPrintf("out of bounds memory access: access at %" PRIu64
"+%" PRIzd " >= max value %" PRIu64,
offset + instr.imm_u32x2.snd, sizeof(T),
memory->ByteSize()));
return RunResult::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq 0x88(%rax), %rcx
movq %rcx, -0xa8(%rbp)
movq 0x90(%rax), %rdi
callq 0x27ddb0
movq %rax, %rdi
movq -0x98(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %esi
callq 0x1cf260
movq -0xa8(%rbp), %rsi
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x1d5480
movq -0xa0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x276990
movq %rax, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1d55a0
movq %rax, %rdi
movq -0x98(%rbp), %rax
movq -0x48(%rbp), %rsi
movl 0xc(%rax), %eax
movl %eax, %edx
movq -0x18(%rbp), %rcx
callq 0x2959e0
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %edi
callq 0x1cba60
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2958f7
jmp 0x2959b0
movq -0xa0(%rbp), %rax
movq -0x98(%rbp), %rcx
movq 0x88(%rax), %rax
movq %rax, -0xb0(%rbp)
movq -0x48(%rbp), %rax
movl 0xc(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0xb8(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1d55a0
movq %rax, %rdi
callq 0x27b710
movq -0xb8(%rbp), %rdx
movq %rax, %r8
leaq -0x88(%rbp), %rdi
leaq 0x763cb(%rip), %rsi # 0x30bd18
movl $0x4, %ecx
movb $0x0, %al
callq 0x1cd050
movq -0xa0(%rbp), %rcx
movq -0xb0(%rbp), %rsi
addq $0x40, %rcx
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rdx
callq 0x27af40
movq -0x20(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x27afa0
movl $0x2, -0x4(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1cf440
leaq -0x88(%rbp), %rdi
callq 0x1a6250
movl $0x1, -0x8c(%rbp)
jmp 0x2959c1
movl $0x0, -0x4(%rbp)
movl $0x1, -0x8c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1cd750
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::(anonymous namespace)::BinaryReader::ReadField(wabt::TypeMut*) | Result BinaryReader::ReadField(TypeMut* out_value) {
// TODO: Reuse for global header too?
Type field_type;
CHECK_RESULT(ReadType(&field_type, "field type"));
ERROR_UNLESS(IsConcreteType(field_type),
"expected valid field type (got " PRItypecode ")",
WABT_PRINTF_TYPE_CODE(field_type));
uint8_t mutable_ = 0;
CHECK_RESULT(ReadU8(&mutable_, "field mutability"));
ERROR_UNLESS(mutable_ <= 1, "field mutability must be 0 or 1");
out_value->type = field_type;
out_value->mutable_ = mutable_;
return Result::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
leaq 0x67554(%rip), %rdx # 0x30e4eb
callq 0x2a6e50
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2a6fad
jmp 0x2a6fc0
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2a70ca
jmp 0x2a6fc2
jmp 0x2a6fc4
movq -0x38(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %esi
callq 0x2a6ed0
testb $0x1, %al
jne 0x2a7039
leaq -0x1c(%rbp), %rdi
callq 0x1cb6e0
movl %eax, %edx
leaq 0x5d7e7(%rip), %rax # 0x3047d3
leaq 0x5d7ed(%rip), %rcx # 0x3047e0
cmpl $0x0, %edx
cmovlq %rcx, %rax
movq %rax, -0x40(%rbp)
leaq -0x1c(%rbp), %rdi
callq 0x1cb6e0
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rdx
movl %eax, %ecx
movl %ecx, %eax
negl %eax
cmovnsl %eax, %ecx
leaq 0x674d7(%rip), %rsi # 0x30e4f6
movb $0x0, %al
callq 0x29f5c0
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2a70ca
jmp 0x2a703b
movb $0x0, -0x25(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x25(%rbp), %rsi
leaq 0x674ce(%rip), %rdx # 0x30e51c
callq 0x2a0180
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2a7064
jmp 0x2a7074
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2a70ca
jmp 0x2a7076
jmp 0x2a7078
movzbl -0x25(%rbp), %eax
cmpl $0x1, %eax
jle 0x2a70a3
movq -0x38(%rbp), %rdi
leaq 0x674a1(%rip), %rsi # 0x30e52d
movb $0x0, %al
callq 0x29f5c0
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2a70ca
jmp 0x2a70a5
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
cmpb $0x0, -0x25(%rbp)
setne %cl
movq -0x18(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x4(%rax)
leaq -0x4(%rbp), %rdi
xorl %esi, %esi
callq 0x1cba40
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /dcodeIO[P]wabt/src/binary-reader.cc |
wabt::Result wabt::(anonymous namespace)::BinaryReader::ReadT<unsigned long>(unsigned long*, char const*, char const*) | Result BinaryReader::ReadT(T* out_value,
const char* type_name,
const char* desc) {
if (state_.offset + sizeof(T) > read_end_) {
PrintError("unable to read %s: %s", type_name, desc);
return Result::Error;
}
#if WABT_BIG_ENDIAN
uint8_t tmp[sizeof(T)];
memcpy(tmp, state_.data + state_.offset, sizeof(tmp));
SwapBytesSized(tmp, sizeof(tmp));
memcpy(out_value, tmp, sizeof(T));
#else
memcpy(out_value, state_.data + state_.offset, sizeof(T));
#endif
state_.offset += sizeof(T);
return Result::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq 0x18(%rcx), %rax
addq $0x8, %rax
cmpq (%rcx), %rax
jbe 0x2a8417
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
leaq 0x6551b(%rip), %rsi # 0x30d91b
movb $0x0, %al
callq 0x29f5c0
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2a8445
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq 0x8(%rax), %rdx
movq 0x18(%rax), %rsi
movq (%rdx,%rsi), %rdx
movq %rdx, (%rcx)
movq 0x18(%rax), %rcx
addq $0x8, %rcx
movq %rcx, 0x18(%rax)
leaq -0x4(%rbp), %rdi
xorl %esi, %esi
callq 0x1cba40
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
| /dcodeIO[P]wabt/src/binary-reader.cc |
wabt::(anonymous namespace)::BinaryReaderIR::OnImportGlobal(unsigned int, wabt::string_view, wabt::string_view, unsigned int, wabt::Type, bool) | Result BinaryReaderIR::OnImportGlobal(Index import_index,
string_view module_name,
string_view field_name,
Index global_index,
Type type,
bool mutable_) {
auto import = MakeUnique<GlobalImport>();
import->module_name = module_name.to_string();
import->field_name = field_name.to_string();
import->global.type = type;
import->global.mutable_ = mutable_;
module_->AppendField(
MakeUnique<ImportModuleField>(std::move(import), GetLocation()));
return Result::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rcx, -0xd0(%rbp)
movq %rdx, %r10
movq -0xd0(%rbp), %rdx
movb 0x20(%rbp), %al
movl 0x18(%rbp), %ecx
movl 0x10(%rbp), %r11d
movq %r10, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x20(%rbp)
movl %ecx, -0x2c(%rbp)
movq %rdi, -0x38(%rbp)
movl %esi, -0x3c(%rbp)
andb $0x1, %al
movb %al, -0x3d(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2b7f50
leaq -0x68(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1ff4a0
leaq -0x48(%rbp), %rdi
callq 0x22ca40
movq %rax, %rdi
addq $0x8, %rdi
leaq -0x68(%rbp), %rsi
callq 0x1a64e0
leaq -0x68(%rbp), %rdi
callq 0x1a6250
leaq -0x88(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1ff4a0
leaq -0x48(%rbp), %rdi
callq 0x22ca40
movq %rax, %rdi
addq $0x28, %rdi
leaq -0x88(%rbp), %rsi
callq 0x1a64e0
leaq -0x88(%rbp), %rdi
callq 0x1a6250
leaq -0x48(%rbp), %rdi
callq 0x22ca40
movl -0x2c(%rbp), %ecx
movl %ecx, 0x70(%rax)
movb -0x3d(%rbp), %al
movb %al, -0xc1(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x22ca40
movb -0xc1(%rbp), %cl
movq -0xc0(%rbp), %rsi
andb $0x1, %cl
movb %cl, 0x74(%rax)
movq 0x18(%rsi), %rax
movq %rax, -0xb8(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x2b5ab0
leaq -0x90(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0xb0(%rbp), %rdx
callq 0x22ca60
movq -0xb8(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x2dc1b0
leaq -0x90(%rbp), %rdi
callq 0x22c260
leaq -0x4(%rbp), %rdi
xorl %esi, %esi
callq 0x1cba40
leaq -0x48(%rbp), %rdi
callq 0x22cad0
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /dcodeIO[P]wabt/src/binary-reader-ir.cc |
wabt::(anonymous namespace)::BinaryReaderIR::OnElemSegmentElemExprCount(unsigned int, unsigned int) | Result BinaryReaderIR::OnElemSegmentElemExprCount(Index index, Index count) {
assert(index == module_->elem_segments.size() - 1);
ElemSegment* segment = module_->elem_segments[index];
WABT_TRY
segment->elem_exprs.reserve(count);
WABT_CATCH_BAD_ALLOC
return Result::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %ecx
movq %rcx, -0x28(%rbp)
movq 0x18(%rax), %rdi
addq $0x118, %rdi # imm = 0x118
callq 0x2cc740
movq %rax, %rcx
movq -0x28(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x2b4053
jmp 0x2b4072
leaq 0x5cb9f(%rip), %rdi # 0x310bf9
leaq 0x5c642(%rip), %rsi # 0x3106a3
movl $0x431, %edx # imm = 0x431
leaq 0x5cb1f(%rip), %rcx # 0x310b8c
callq 0x1a6290
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rdi
addq $0x118, %rdi # imm = 0x118
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x2ccaa0
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x90, %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x2ccac0
leaq -0x4(%rbp), %rdi
xorl %esi, %esi
callq 0x1cba40
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /dcodeIO[P]wabt/src/binary-reader-ir.cc |
wabt::(anonymous namespace)::BinaryReaderIR::OnLocalName(unsigned int, unsigned int, wabt::string_view) | Result BinaryReaderIR::OnLocalName(Index func_index,
Index local_index,
string_view name) {
if (name.empty()) {
return Result::Ok;
}
Func* func = module_->funcs[func_index];
func->bindings.emplace(GetUniqueName(&func->bindings, MakeDollarName(name)),
Binding(local_index));
return Result::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rcx, -0x18(%rbp)
movq %r8, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movl %esi, -0x24(%rbp)
movl %edx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1ef5d0
testb $0x1, %al
jne 0x2b4917
jmp 0x2b4927
leaq -0x4(%rbp), %rdi
xorl %esi, %esi
callq 0x1cba40
jmp 0x2b49f2
movq -0xb8(%rbp), %rax
movq 0x18(%rax), %rdi
addq $0x88, %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x2b97a0
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
addq $0xb8, %rax
movq %rax, -0xc0(%rbp)
movq -0x30(%rbp), %rax
addq $0xb8, %rax
movq %rax, -0xc8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
leaq -0x70(%rbp), %rdi
callq 0x2b6b10
movq -0xb8(%rbp), %rsi
movq -0xc8(%rbp), %rdx
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rcx
callq 0x2b6b90
movl -0x28(%rbp), %esi
leaq -0xa8(%rbp), %rdi
callq 0x2cd760
movq -0xc0(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0xa8(%rbp), %rdx
callq 0x2cdda0
movq %rax, -0xb0(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1a6250
leaq -0x70(%rbp), %rdi
callq 0x1a6250
leaq -0x4(%rbp), %rdi
xorl %esi, %esi
callq 0x1cba40
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
nop
| /dcodeIO[P]wabt/src/binary-reader-ir.cc |
wabt::(anonymous namespace)::BinaryReaderIR::OnFunctionSymbol(unsigned int, unsigned int, wabt::string_view, unsigned int) | Result BinaryReaderIR::OnFunctionSymbol(Index index, uint32_t flags,
string_view name, Index func_index) {
if (name.empty()) {
return Result::Ok;
}
if (func_index >= module_->funcs.size()) {
PrintError("invalid function index: %" PRIindex, func_index);
return Result::Error;
}
Func* func = module_->funcs[func_index];
if (!func->name.empty()) {
// The name section has already named this function.
return Result::Ok;
}
std::string dollar_name =
GetUniqueName(&module_->func_bindings, MakeDollarName(name));
func->name = dollar_name;
module_->func_bindings.emplace(dollar_name, Binding(func_index));
return Result::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rcx, -0x18(%rbp)
movq %r8, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movl %esi, -0x24(%rbp)
movl %edx, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0xc0(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1ef5d0
testb $0x1, %al
jne 0x2b4c1b
jmp 0x2b4c2b
leaq -0x4(%rbp), %rdi
xorl %esi, %esi
callq 0x1cba40
jmp 0x2b4d8f
movq -0xc0(%rbp), %rax
movl -0x2c(%rbp), %ecx
movq %rcx, -0xc8(%rbp)
movq 0x18(%rax), %rdi
addq $0x88, %rdi
callq 0x22c430
movq %rax, %rcx
movq -0xc8(%rbp), %rax
cmpq %rcx, %rax
jb 0x2b4c86
movq -0xc0(%rbp), %rdi
movl -0x2c(%rbp), %edx
leaq 0x58fff(%rip), %rsi # 0x30dc6b
movb $0x0, %al
callq 0x2b6710
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2b4d8f
movq -0xc0(%rbp), %rax
movq 0x18(%rax), %rdi
addq $0x88, %rdi
movl -0x2c(%rbp), %eax
movl %eax, %esi
callq 0x2b97a0
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x1a6610
testb $0x1, %al
jne 0x2b4cc6
leaq -0x4(%rbp), %rdi
xorl %esi, %esi
callq 0x1cba40
jmp 0x2b4d8f
movq -0xc0(%rbp), %rax
movq 0x18(%rax), %rax
addq $0x1b0, %rax # imm = 0x1B0
movq %rax, -0xd8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
leaq -0x78(%rbp), %rdi
callq 0x2b6b10
movq -0xd8(%rbp), %rdx
movq -0xc0(%rbp), %rsi
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rcx
callq 0x2b6b90
leaq -0x78(%rbp), %rdi
callq 0x1a6250
movq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x1a6060
movq -0xc0(%rbp), %rax
movq 0x18(%rax), %rax
addq $0x1b0, %rax # imm = 0x1B0
movq %rax, -0xd0(%rbp)
movl -0x2c(%rbp), %esi
leaq -0xb0(%rbp), %rdi
callq 0x2cd760
movq -0xd0(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0xb0(%rbp), %rdx
callq 0x22db70
movq %rax, -0xb8(%rbp)
leaq -0x4(%rbp), %rdi
xorl %esi, %esi
callq 0x1cba40
leaq -0x58(%rbp), %rdi
callq 0x1a6250
movl -0x4(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /dcodeIO[P]wabt/src/binary-reader-ir.cc |
wabt::(anonymous namespace)::BinaryReaderIR::GetUniqueName(wabt::BindingHash*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string BinaryReaderIR::GetUniqueName(BindingHash* bindings,
const std::string& orig_name) {
int counter = 1;
std::string unique_name = orig_name;
while (bindings->count(unique_name) != 0) {
unique_name = orig_name + "." + std::to_string(counter++);
}
return unique_name;
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
movb $0x0, -0x25(%rbp)
movq -0x20(%rbp), %rsi
callq 0x1a6180
movq -0x98(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0x2cd790
cmpq $0x0, %rax
je 0x2b6c58
movq -0x20(%rbp), %rsi
leaq -0x68(%rbp), %rdi
leaq 0x50ac5(%rip), %rdx # 0x3076ba
callq 0x2cd7c0
movl -0x24(%rbp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x2cd820
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0x88(%rbp), %rdx
callq 0x2cd690
movq -0x98(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x1a64e0
leaq -0x48(%rbp), %rdi
callq 0x1a6250
leaq -0x88(%rbp), %rdi
callq 0x1a6250
leaq -0x68(%rbp), %rdi
callq 0x1a6250
jmp 0x2b6bd0
movb $0x1, -0x25(%rbp)
testb $0x1, -0x25(%rbp)
jne 0x2b6c6e
movq -0x98(%rbp), %rdi
callq 0x1a6250
movq -0x90(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
nop
| /dcodeIO[P]wabt/src/binary-reader-ir.cc |
wabt::BinaryReaderLogging::WriteIndent() | void BinaryReaderLogging::WriteIndent() {
static char s_indent[] =
" "
" ";
static const size_t s_indent_len = sizeof(s_indent) - 1;
size_t i = indent_;
while (i > s_indent_len) {
stream_->WriteData(s_indent, s_indent_len);
i -= s_indent_len;
}
if (i > 0) {
stream_->WriteData(s_indent, indent_);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movslq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x8e, -0x10(%rbp)
jbe 0x2ce376
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0xe63cb(%rip), %rsi # 0x3b4720
movl $0x8e, %edx
xorl %eax, %eax
movl %eax, %ecx
xorl %r8d, %r8d
callq 0x1fdac0
movq -0x10(%rbp), %rax
subq $0x8e, %rax
movq %rax, -0x10(%rbp)
jmp 0x2ce33c
cmpq $0x0, -0x10(%rbp)
jbe 0x2ce39c
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movslq 0x20(%rax), %rdx
leaq 0xe6390(%rip), %rsi # 0x3b4720
xorl %eax, %eax
movl %eax, %ecx
xorl %r8d, %r8d
callq 0x1fdac0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /dcodeIO[P]wabt/src/binary-reader-logging.cc |
wabt::BinaryReaderLogging::LogTypes(unsigned int, wabt::Type*) | void BinaryReaderLogging::LogTypes(Index type_count, Type* types) {
LOGF_NOINDENT("[");
for (Index i = 0; i < type_count; ++i) {
LogType(types[i]);
if (i != type_count - 1) {
LOGF_NOINDENT(", ");
}
}
LOGF_NOINDENT("]");
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x10(%rax), %rdi
leaq 0x43077(%rip), %rsi # 0x3114dd
movb $0x0, %al
callq 0x1fdbc0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x2ce4c5
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %esi
callq 0x2ce3b0
movl -0x1c(%rbp), %eax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
je 0x2ce4b8
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x36331(%rip), %rsi # 0x3047e2
movb $0x0, %al
callq 0x1fdbc0
jmp 0x2ce4ba
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2ce474
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x39dc9(%rip), %rsi # 0x30829d
movb $0x0, %al
callq 0x1fdbc0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /dcodeIO[P]wabt/src/binary-reader-logging.cc |
wabt::BinaryReaderLogging::OnFuncType(unsigned int, unsigned int, wabt::Type*, unsigned int, wabt::Type*) | Result BinaryReaderLogging::OnFuncType(Index index,
Index param_count,
Type* param_types,
Index result_count,
Type* result_types) {
LOGF("OnFuncType(index: %" PRIindex ", params: ", index);
LogTypes(param_count, param_types);
LOGF_NOINDENT(", results: ");
LogTypes(result_count, result_types);
LOGF_NOINDENT(")\n");
return reader_->OnFuncType(index, param_count, param_types, result_count,
result_types);
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x2ce320
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0x14(%rbp), %edx
leaq 0x429d8(%rip), %rsi # 0x311189
movb $0x0, %al
callq 0x1fdbc0
movq -0x38(%rbp), %rdi
movl -0x18(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x2ce440
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x429d1(%rip), %rsi # 0x3111a8
movb $0x0, %al
callq 0x1fdbc0
movq -0x38(%rbp), %rdi
movl -0x24(%rbp), %esi
movq -0x30(%rbp), %rdx
callq 0x2ce440
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x3e66f(%rip), %rsi # 0x30ce6c
movb $0x0, %al
callq 0x1fdbc0
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
movq -0x30(%rbp), %r9
movq (%rdi), %rax
callq *0x58(%rax)
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
| /dcodeIO[P]wabt/src/binary-reader-logging.cc |
wabt::BinaryReaderLogging::OnStructType(unsigned int, unsigned int, wabt::TypeMut*) | Result BinaryReaderLogging::OnStructType(Index index,
Index field_count,
TypeMut* fields) {
LOGF("OnStructType(index: %" PRIindex ", fields: ", index);
LOGF_NOINDENT("[");
for (Index i = 0; i < field_count; ++i) {
LogField(fields[i]);
if (i != field_count - 1) {
LOGF_NOINDENT(", ");
}
}
LOGF_NOINDENT("])\n");
return reader_->OnStructType(index, field_count, fields);
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x2ce320
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0x14(%rbp), %edx
leaq 0x4294b(%rip), %rsi # 0x3111b4
movb $0x0, %al
callq 0x1fdbc0
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x42c5e(%rip), %rsi # 0x3114dd
movb $0x0, %al
callq 0x1fdbc0
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x18(%rbp), %eax
jae 0x2ce8e1
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movl -0x24(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x2c(%rbp)
movq -0x2c(%rbp), %rsi
callq 0x2ce540
movl -0x24(%rbp), %eax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
je 0x2ce8d4
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x35f15(%rip), %rsi # 0x3047e2
movb $0x0, %al
callq 0x1fdbc0
jmp 0x2ce8d6
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2ce88d
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdi
leaq 0x428e5(%rip), %rsi # 0x3111d5
movb $0x0, %al
callq 0x1fdbc0
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movq -0x20(%rbp), %rcx
movq (%rdi), %rax
callq *0x60(%rax)
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /dcodeIO[P]wabt/src/binary-reader-logging.cc |
wabt::BinaryReaderLogging::OnImportTable(unsigned int, wabt::string_view, wabt::string_view, unsigned int, wabt::Type, wabt::Limits const*) | Result BinaryReaderLogging::OnImportTable(Index import_index,
string_view module_name,
string_view field_name,
Index table_index,
Type elem_type,
const Limits* elem_limits) {
char buf[100];
SPrintLimits(buf, sizeof(buf), elem_limits);
LOGF("OnImportTable(import_index: %" PRIindex ", table_index: %" PRIindex
", elem_type: %s, %s)\n",
import_index, table_index, elem_type.GetName(), buf);
return reader_->OnImportTable(import_index, module_name, field_name,
table_index, elem_type, elem_limits);
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq 0x20(%rbp), %rax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %r10d
movq %rdx, -0x20(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x28(%rbp)
movl %eax, -0x34(%rbp)
movq %rdi, -0x40(%rbp)
movl %esi, -0x44(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0xe0(%rbp)
leaq -0xb0(%rbp), %rdi
movq 0x20(%rbp), %rdx
movl $0x64, %esi
callq 0x2ced30
movq -0xe0(%rbp), %rdi
callq 0x2ce320
movq -0xe0(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0xf0(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0xe8(%rbp)
movl 0x10(%rbp), %eax
movl %eax, -0xe4(%rbp)
leaq -0x34(%rbp), %rdi
callq 0x1cbd60
movq -0xf0(%rbp), %rdi
movl -0xe8(%rbp), %edx
movl -0xe4(%rbp), %ecx
movq %rax, %r8
leaq -0xb0(%rbp), %r9
leaq 0x425e7(%rip), %rsi # 0x311275
movb $0x0, %al
callq 0x1fdbc0
movq -0xe0(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0x44(%rbp), %esi
movq -0x20(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0xd0(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0xc8(%rbp)
movl 0x10(%rbp), %ebx
movl -0x34(%rbp), %eax
movl %eax, -0xd4(%rbp)
movq 0x20(%rbp), %r10
movq -0xc0(%rbp), %rdx
movq -0xb8(%rbp), %rcx
movq -0xd0(%rbp), %r8
movq -0xc8(%rbp), %r9
movl -0xd4(%rbp), %r11d
movq (%rdi), %rax
movl %ebx, (%rsp)
movl %r11d, 0x8(%rsp)
movq %r10, 0x10(%rsp)
callq *0x98(%rax)
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %rbp
retq
nopl (%rax,%rax)
| /dcodeIO[P]wabt/src/binary-reader-logging.cc |
wabt::(anonymous namespace)::SPrintLimits(char*, unsigned long, wabt::Limits const*) | void SPrintLimits(char* dst, size_t size, const Limits* limits) {
int result;
if (limits->has_max) {
result = wabt_snprintf(dst, size, "initial: %" PRIu64 ", max: %" PRIu64,
limits->initial, limits->max);
} else {
result = wabt_snprintf(dst, size, "initial: %" PRIu64, limits->initial);
}
WABT_USE(result);
assert(static_cast<size_t>(result) < size);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
testb $0x1, 0x10(%rax)
je 0x2ced78
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %r8
leaq 0x43ca3(%rip), %rdx # 0x312a0f
movb $0x0, %al
callq 0x1a65e0
movl %eax, -0x1c(%rbp)
jmp 0x2ced98
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq (%rax), %rcx
leaq 0x43c98(%rip), %rdx # 0x312a26
movb $0x0, %al
callq 0x1a65e0
movl %eax, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x2ceda4
jmp 0x2cedc3
leaq 0x43c88(%rip), %rdi # 0x312a33
leaq 0x422f8(%rip), %rsi # 0x3110aa
movl $0x2e, %edx
leaq 0x43c98(%rip), %rcx # 0x312a56
callq 0x1a6290
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| /dcodeIO[P]wabt/src/binary-reader-logging.cc |
wabt::BinaryReaderLogging::OnImportGlobal(unsigned int, wabt::string_view, wabt::string_view, unsigned int, wabt::Type, bool) | Result BinaryReaderLogging::OnImportGlobal(Index import_index,
string_view module_name,
string_view field_name,
Index global_index,
Type type,
bool mutable_) {
LOGF("OnImportGlobal(import_index: %" PRIindex ", global_index: %" PRIindex
", type: %s, mutable: "
"%s)\n",
import_index, global_index, type.GetName(), mutable_ ? "true" : "false");
return reader_->OnImportGlobal(import_index, module_name, field_name,
global_index, type, mutable_);
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xa8, %rsp
movq %rcx, -0x80(%rbp)
movq %rdx, %r10
movq -0x80(%rbp), %rdx
movb 0x20(%rbp), %al
movl 0x18(%rbp), %ecx
movl 0x10(%rbp), %r11d
movq %r10, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x28(%rbp)
movl %ecx, -0x34(%rbp)
movq %rdi, -0x40(%rbp)
movl %esi, -0x44(%rbp)
andb $0x1, %al
movb %al, -0x45(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
callq 0x2ce320
movq -0x78(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x90(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0x88(%rbp)
movl 0x10(%rbp), %eax
movl %eax, -0x84(%rbp)
leaq -0x34(%rbp), %rdi
callq 0x1cbd60
movq -0x90(%rbp), %rdi
movl -0x88(%rbp), %edx
movl -0x84(%rbp), %ecx
movq %rax, %r8
movb -0x45(%rbp), %sil
leaq 0x32478(%rip), %r9 # 0x3013e4
leaq 0x368a9(%rip), %rax # 0x30581c
testb $0x1, %sil
cmovneq %rax, %r9
leaq 0x42370(%rip), %rsi # 0x3112f2
movb $0x0, %al
callq 0x1fdbc0
movq -0x78(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0x44(%rbp), %esi
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x60(%rbp)
movl 0x10(%rbp), %ebx
movl -0x34(%rbp), %eax
movl %eax, -0x6c(%rbp)
movb -0x45(%rbp), %r10b
movq -0x58(%rbp), %rdx
movq -0x50(%rbp), %rcx
movq -0x68(%rbp), %r8
movq -0x60(%rbp), %r9
movl -0x6c(%rbp), %r11d
movq (%rdi), %rax
andb $0x1, %r10b
movl %ebx, (%rsp)
movl %r11d, 0x8(%rsp)
movzbl %r10b, %r10d
movl %r10d, 0x10(%rsp)
callq *0xa8(%rax)
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0xa8, %rsp
popq %rbx
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /dcodeIO[P]wabt/src/binary-reader-logging.cc |
wabt::ExprVisitor::HandleDefaultState(wabt::Expr*) | Result ExprVisitor::HandleDefaultState(Expr* expr) {
switch (expr->type()) {
case ExprType::AtomicLoad:
CHECK_RESULT(delegate_->OnAtomicLoadExpr(cast<AtomicLoadExpr>(expr)));
break;
case ExprType::AtomicStore:
CHECK_RESULT(delegate_->OnAtomicStoreExpr(cast<AtomicStoreExpr>(expr)));
break;
case ExprType::AtomicRmw:
CHECK_RESULT(delegate_->OnAtomicRmwExpr(cast<AtomicRmwExpr>(expr)));
break;
case ExprType::AtomicRmwCmpxchg:
CHECK_RESULT(
delegate_->OnAtomicRmwCmpxchgExpr(cast<AtomicRmwCmpxchgExpr>(expr)));
break;
case ExprType::AtomicWait:
CHECK_RESULT(delegate_->OnAtomicWaitExpr(cast<AtomicWaitExpr>(expr)));
break;
case ExprType::AtomicFence:
CHECK_RESULT(delegate_->OnAtomicFenceExpr(cast<AtomicFenceExpr>(expr)));
break;
case ExprType::AtomicNotify:
CHECK_RESULT(delegate_->OnAtomicNotifyExpr(cast<AtomicNotifyExpr>(expr)));
break;
case ExprType::Binary:
CHECK_RESULT(delegate_->OnBinaryExpr(cast<BinaryExpr>(expr)));
break;
case ExprType::Block: {
auto block_expr = cast<BlockExpr>(expr);
CHECK_RESULT(delegate_->BeginBlockExpr(block_expr));
PushExprlist(State::Block, expr, block_expr->block.exprs);
break;
}
case ExprType::Br:
CHECK_RESULT(delegate_->OnBrExpr(cast<BrExpr>(expr)));
break;
case ExprType::BrIf:
CHECK_RESULT(delegate_->OnBrIfExpr(cast<BrIfExpr>(expr)));
break;
case ExprType::BrOnExn:
CHECK_RESULT(delegate_->OnBrOnExnExpr(cast<BrOnExnExpr>(expr)));
break;
case ExprType::BrTable:
CHECK_RESULT(delegate_->OnBrTableExpr(cast<BrTableExpr>(expr)));
break;
case ExprType::Call:
CHECK_RESULT(delegate_->OnCallExpr(cast<CallExpr>(expr)));
break;
case ExprType::CallIndirect:
CHECK_RESULT(delegate_->OnCallIndirectExpr(cast<CallIndirectExpr>(expr)));
break;
case ExprType::Compare:
CHECK_RESULT(delegate_->OnCompareExpr(cast<CompareExpr>(expr)));
break;
case ExprType::Const:
CHECK_RESULT(delegate_->OnConstExpr(cast<ConstExpr>(expr)));
break;
case ExprType::Convert:
CHECK_RESULT(delegate_->OnConvertExpr(cast<ConvertExpr>(expr)));
break;
case ExprType::Drop:
CHECK_RESULT(delegate_->OnDropExpr(cast<DropExpr>(expr)));
break;
case ExprType::GlobalGet:
CHECK_RESULT(delegate_->OnGlobalGetExpr(cast<GlobalGetExpr>(expr)));
break;
case ExprType::GlobalSet:
CHECK_RESULT(delegate_->OnGlobalSetExpr(cast<GlobalSetExpr>(expr)));
break;
case ExprType::If: {
auto if_expr = cast<IfExpr>(expr);
CHECK_RESULT(delegate_->BeginIfExpr(if_expr));
PushExprlist(State::IfTrue, expr, if_expr->true_.exprs);
break;
}
case ExprType::Load:
CHECK_RESULT(delegate_->OnLoadExpr(cast<LoadExpr>(expr)));
break;
case ExprType::LoadSplat:
CHECK_RESULT(delegate_->OnLoadSplatExpr(cast<LoadSplatExpr>(expr)));
break;
case ExprType::LocalGet:
CHECK_RESULT(delegate_->OnLocalGetExpr(cast<LocalGetExpr>(expr)));
break;
case ExprType::LocalSet:
CHECK_RESULT(delegate_->OnLocalSetExpr(cast<LocalSetExpr>(expr)));
break;
case ExprType::LocalTee:
CHECK_RESULT(delegate_->OnLocalTeeExpr(cast<LocalTeeExpr>(expr)));
break;
case ExprType::Loop: {
auto loop_expr = cast<LoopExpr>(expr);
CHECK_RESULT(delegate_->BeginLoopExpr(loop_expr));
PushExprlist(State::Loop, expr, loop_expr->block.exprs);
break;
}
case ExprType::MemoryCopy:
CHECK_RESULT(delegate_->OnMemoryCopyExpr(cast<MemoryCopyExpr>(expr)));
break;
case ExprType::DataDrop:
CHECK_RESULT(delegate_->OnDataDropExpr(cast<DataDropExpr>(expr)));
break;
case ExprType::MemoryFill:
CHECK_RESULT(delegate_->OnMemoryFillExpr(cast<MemoryFillExpr>(expr)));
break;
case ExprType::MemoryGrow:
CHECK_RESULT(delegate_->OnMemoryGrowExpr(cast<MemoryGrowExpr>(expr)));
break;
case ExprType::MemoryInit:
CHECK_RESULT(delegate_->OnMemoryInitExpr(cast<MemoryInitExpr>(expr)));
break;
case ExprType::MemorySize:
CHECK_RESULT(delegate_->OnMemorySizeExpr(cast<MemorySizeExpr>(expr)));
break;
case ExprType::TableCopy:
CHECK_RESULT(delegate_->OnTableCopyExpr(cast<TableCopyExpr>(expr)));
break;
case ExprType::ElemDrop:
CHECK_RESULT(delegate_->OnElemDropExpr(cast<ElemDropExpr>(expr)));
break;
case ExprType::TableInit:
CHECK_RESULT(delegate_->OnTableInitExpr(cast<TableInitExpr>(expr)));
break;
case ExprType::TableGet:
CHECK_RESULT(delegate_->OnTableGetExpr(cast<TableGetExpr>(expr)));
break;
case ExprType::TableSet:
CHECK_RESULT(delegate_->OnTableSetExpr(cast<TableSetExpr>(expr)));
break;
case ExprType::TableGrow:
CHECK_RESULT(delegate_->OnTableGrowExpr(cast<TableGrowExpr>(expr)));
break;
case ExprType::TableSize:
CHECK_RESULT(delegate_->OnTableSizeExpr(cast<TableSizeExpr>(expr)));
break;
case ExprType::TableFill:
CHECK_RESULT(delegate_->OnTableFillExpr(cast<TableFillExpr>(expr)));
break;
case ExprType::RefFunc:
CHECK_RESULT(delegate_->OnRefFuncExpr(cast<RefFuncExpr>(expr)));
break;
case ExprType::RefNull:
CHECK_RESULT(delegate_->OnRefNullExpr(cast<RefNullExpr>(expr)));
break;
case ExprType::RefIsNull:
CHECK_RESULT(delegate_->OnRefIsNullExpr(cast<RefIsNullExpr>(expr)));
break;
case ExprType::Nop:
CHECK_RESULT(delegate_->OnNopExpr(cast<NopExpr>(expr)));
break;
case ExprType::Rethrow:
CHECK_RESULT(delegate_->OnRethrowExpr(cast<RethrowExpr>(expr)));
break;
case ExprType::Return:
CHECK_RESULT(delegate_->OnReturnExpr(cast<ReturnExpr>(expr)));
break;
case ExprType::ReturnCall:
CHECK_RESULT(delegate_->OnReturnCallExpr(cast<ReturnCallExpr>(expr)));
break;
case ExprType::ReturnCallIndirect:
CHECK_RESULT(delegate_->OnReturnCallIndirectExpr(
cast<ReturnCallIndirectExpr>(expr)));
break;
case ExprType::Select:
CHECK_RESULT(delegate_->OnSelectExpr(cast<SelectExpr>(expr)));
break;
case ExprType::Store:
CHECK_RESULT(delegate_->OnStoreExpr(cast<StoreExpr>(expr)));
break;
case ExprType::Throw:
CHECK_RESULT(delegate_->OnThrowExpr(cast<ThrowExpr>(expr)));
break;
case ExprType::Try: {
auto try_expr = cast<TryExpr>(expr);
CHECK_RESULT(delegate_->BeginTryExpr(try_expr));
PushExprlist(State::Try, expr, try_expr->block.exprs);
break;
}
case ExprType::Unary:
CHECK_RESULT(delegate_->OnUnaryExpr(cast<UnaryExpr>(expr)));
break;
case ExprType::Ternary:
CHECK_RESULT(delegate_->OnTernaryExpr(cast<TernaryExpr>(expr)));
break;
case ExprType::SimdLaneOp: {
CHECK_RESULT(delegate_->OnSimdLaneOpExpr(cast<SimdLaneOpExpr>(expr)));
break;
}
case ExprType::SimdShuffleOp: {
CHECK_RESULT(
delegate_->OnSimdShuffleOpExpr(cast<SimdShuffleOpExpr>(expr)));
break;
}
case ExprType::Unreachable:
CHECK_RESULT(delegate_->OnUnreachableExpr(cast<UnreachableExpr>(expr)));
break;
}
return Result::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0x2f0, %rsp # imm = 0x2F0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x138(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2beab0
movl %eax, %ecx
movq %rcx, -0x130(%rbp)
subl $0x3a, %eax
ja 0x2d6815
movq -0x130(%rbp), %rax
leaq 0x3d8e5(%rip), %rcx # 0x312b0c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x2d5232
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x140(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d6ba0
movq -0x140(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x1d8(%rax)
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d5270
jmp 0x2d5283
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d5285
jmp 0x2d6815
jmp 0x2d528c
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x148(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d6bf0
movq -0x148(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x1e0(%rax)
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d52ca
jmp 0x2d52dd
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d52df
jmp 0x2d6815
jmp 0x2d52e6
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x150(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d6c40
movq -0x150(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x1e8(%rax)
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d5324
jmp 0x2d5337
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d5339
jmp 0x2d6815
jmp 0x2d5340
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x158(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d6c90
movq -0x158(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x1f0(%rax)
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d537e
jmp 0x2d5391
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d5393
jmp 0x2d6815
jmp 0x2d539a
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x160(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d6ce0
movq -0x160(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x1c0(%rax)
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d53d8
jmp 0x2d53eb
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d53ed
jmp 0x2d6815
jmp 0x2d53f4
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x168(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d6d30
movq -0x168(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x1c8(%rax)
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d5432
jmp 0x2d5445
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d5447
jmp 0x2d6815
jmp 0x2d544e
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x170(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d6d80
movq -0x170(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x1d0(%rax)
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d548c
jmp 0x2d549f
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d54a1
jmp 0x2d6815
jmp 0x2d54a8
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x178(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d6dd0
movq -0x178(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d54e3
jmp 0x2d54f6
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d54f8
jmp 0x2d6815
movq -0x18(%rbp), %rdi
callq 0x2bfb80
movq %rax, -0x40(%rbp)
movq -0x138(%rbp), %rax
movq (%rax), %rdi
movq -0x40(%rbp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d552f
jmp 0x2d5542
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d5544
movq -0x138(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x40(%rbp), %rcx
addq $0x40, %rcx
addq $0xa0, %rcx
movl $0x1, %esi
callq 0x2d6870
jmp 0x2d6815
jmp 0x2d556f
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x180(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d6e20
movq -0x180(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x28(%rax)
movl %eax, -0x48(%rbp)
movl -0x48(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d55aa
jmp 0x2d55bd
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d55bf
jmp 0x2d6815
jmp 0x2d55c6
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x188(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d6e70
movq -0x188(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x30(%rax)
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d5601
jmp 0x2d5614
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d5616
jmp 0x2d6815
jmp 0x2d561d
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x190(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d6ec0
movq -0x190(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x38(%rax)
movl %eax, -0x50(%rbp)
movl -0x50(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d5658
jmp 0x2d566b
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d566d
jmp 0x2d6815
jmp 0x2d5674
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x198(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d6f10
movq -0x198(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x40(%rax)
movl %eax, -0x54(%rbp)
movl -0x54(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d56af
jmp 0x2d56c2
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d56c4
jmp 0x2d6815
jmp 0x2d56cb
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x1a0(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d6f60
movq -0x1a0(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x48(%rax)
movl %eax, -0x58(%rbp)
movl -0x58(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d5706
jmp 0x2d5719
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d571b
jmp 0x2d6815
jmp 0x2d5722
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x1a8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d6fb0
movq -0x1a8(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x50(%rax)
movl %eax, -0x5c(%rbp)
movl -0x5c(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d575d
jmp 0x2d5770
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d5772
jmp 0x2d6815
jmp 0x2d5779
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x1b0(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d7000
movq -0x1b0(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x58(%rax)
movl %eax, -0x60(%rbp)
movl -0x60(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d57b4
jmp 0x2d57c7
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d57c9
jmp 0x2d6815
jmp 0x2d57d0
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x1b8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d7050
movq -0x1b8(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x60(%rax)
movl %eax, -0x64(%rbp)
movl -0x64(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d580b
jmp 0x2d581e
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d5820
jmp 0x2d6815
jmp 0x2d5827
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x1c0(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d70a0
movq -0x1c0(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x68(%rax)
movl %eax, -0x68(%rbp)
movl -0x68(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d5862
jmp 0x2d5875
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d5877
jmp 0x2d6815
jmp 0x2d587e
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x1c8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d70f0
movq -0x1c8(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x70(%rax)
movl %eax, -0x6c(%rbp)
movl -0x6c(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d58b9
jmp 0x2d58cc
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d58ce
jmp 0x2d6815
jmp 0x2d58d5
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x1d0(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d7140
movq -0x1d0(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x78(%rax)
movl %eax, -0x70(%rbp)
movl -0x70(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d5910
jmp 0x2d5923
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d5925
jmp 0x2d6815
jmp 0x2d592c
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x1d8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d7190
movq -0x1d8(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x80(%rax)
movl %eax, -0x74(%rbp)
movl -0x74(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d596a
jmp 0x2d597d
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d597f
jmp 0x2d6815
movq -0x18(%rbp), %rdi
callq 0x2bfae0
movq %rax, -0x80(%rbp)
movq -0x138(%rbp), %rax
movq (%rax), %rdi
movq -0x80(%rbp), %rsi
movq (%rdi), %rax
callq *0x88(%rax)
movl %eax, -0x84(%rbp)
movl -0x84(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d59bf
jmp 0x2d59d2
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d59d4
movq -0x138(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x80(%rbp), %rcx
addq $0x40, %rcx
addq $0xa0, %rcx
movl $0x2, %esi
callq 0x2d6870
jmp 0x2d6815
jmp 0x2d59ff
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x1e0(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d71e0
movq -0x1e0(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0xa0(%rax)
movl %eax, -0x88(%rbp)
movl -0x88(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d5a43
jmp 0x2d5a56
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d5a58
jmp 0x2d6815
jmp 0x2d5a5f
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x1e8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d7230
movq -0x1e8(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x210(%rax)
movl %eax, -0x8c(%rbp)
movl -0x8c(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d5aa3
jmp 0x2d5ab6
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d5ab8
jmp 0x2d6815
jmp 0x2d5abf
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x1f0(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d7280
movq -0x1f0(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0xa8(%rax)
movl %eax, -0x90(%rbp)
movl -0x90(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d5b03
jmp 0x2d5b16
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d5b18
jmp 0x2d6815
jmp 0x2d5b1f
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x1f8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d72d0
movq -0x1f8(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0xb0(%rax)
movl %eax, -0x94(%rbp)
movl -0x94(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d5b63
jmp 0x2d5b76
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d5b78
jmp 0x2d6815
jmp 0x2d5b7f
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x200(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d7320
movq -0x200(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0xb8(%rax)
movl %eax, -0x98(%rbp)
movl -0x98(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d5bc3
jmp 0x2d5bd6
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d5bd8
jmp 0x2d6815
movq -0x18(%rbp), %rdi
callq 0x2bfbd0
movq %rax, -0xa0(%rbp)
movq -0x138(%rbp), %rax
movq (%rax), %rdi
movq -0xa0(%rbp), %rsi
movq (%rdi), %rax
callq *0xc0(%rax)
movl %eax, -0xa4(%rbp)
movl -0xa4(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d5c1e
jmp 0x2d5c31
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d5c33
movq -0x138(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0xa0(%rbp), %rcx
addq $0x40, %rcx
addq $0xa0, %rcx
movl $0x4, %esi
callq 0x2d6870
jmp 0x2d6815
jmp 0x2d5c61
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x208(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d7370
movq -0x208(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0xd0(%rax)
movl %eax, -0xa8(%rbp)
movl -0xa8(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d5ca5
jmp 0x2d5cb8
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d5cba
jmp 0x2d6815
jmp 0x2d5cc1
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x210(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d73c0
movq -0x210(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0xd8(%rax)
movl %eax, -0xac(%rbp)
movl -0xac(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d5d05
jmp 0x2d5d18
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d5d1a
jmp 0x2d6815
jmp 0x2d5d21
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x218(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d7410
movq -0x218(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0xe0(%rax)
movl %eax, -0xb0(%rbp)
movl -0xb0(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d5d65
jmp 0x2d5d78
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d5d7a
jmp 0x2d6815
jmp 0x2d5d81
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x220(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d7460
movq -0x220(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0xe8(%rax)
movl %eax, -0xb4(%rbp)
movl -0xb4(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d5dc5
jmp 0x2d5dd8
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d5dda
jmp 0x2d6815
jmp 0x2d5de1
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x228(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d74b0
movq -0x228(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0xf0(%rax)
movl %eax, -0xb8(%rbp)
movl -0xb8(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d5e25
jmp 0x2d5e38
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d5e3a
jmp 0x2d6815
jmp 0x2d5e41
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x230(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d7500
movq -0x230(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0xf8(%rax)
movl %eax, -0xbc(%rbp)
movl -0xbc(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d5e85
jmp 0x2d5e98
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d5e9a
jmp 0x2d6815
jmp 0x2d5ea1
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x238(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d7550
movq -0x238(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x100(%rax)
movl %eax, -0xc0(%rbp)
movl -0xc0(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d5ee5
jmp 0x2d5ef8
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d5efa
jmp 0x2d6815
jmp 0x2d5f01
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x240(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d75a0
movq -0x240(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x108(%rax)
movl %eax, -0xc4(%rbp)
movl -0xc4(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d5f45
jmp 0x2d5f58
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d5f5a
jmp 0x2d6815
jmp 0x2d5f61
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x248(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d75f0
movq -0x248(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x110(%rax)
movl %eax, -0xc8(%rbp)
movl -0xc8(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d5fa5
jmp 0x2d5fb8
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d5fba
jmp 0x2d6815
jmp 0x2d5fc1
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x250(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d7640
movq -0x250(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x118(%rax)
movl %eax, -0xcc(%rbp)
movl -0xcc(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d6005
jmp 0x2d6018
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d601a
jmp 0x2d6815
jmp 0x2d6021
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x258(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d7690
movq -0x258(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x120(%rax)
movl %eax, -0xd0(%rbp)
movl -0xd0(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d6065
jmp 0x2d6078
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d607a
jmp 0x2d6815
jmp 0x2d6081
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x260(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d76e0
movq -0x260(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x128(%rax)
movl %eax, -0xd4(%rbp)
movl -0xd4(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d60c5
jmp 0x2d60d8
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d60da
jmp 0x2d6815
jmp 0x2d60e1
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x268(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d7730
movq -0x268(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x130(%rax)
movl %eax, -0xd8(%rbp)
movl -0xd8(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d6125
jmp 0x2d6138
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d613a
jmp 0x2d6815
jmp 0x2d6141
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x270(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d7780
movq -0x270(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x138(%rax)
movl %eax, -0xdc(%rbp)
movl -0xdc(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d6185
jmp 0x2d6198
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d619a
jmp 0x2d6815
jmp 0x2d61a1
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x278(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d77d0
movq -0x278(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x140(%rax)
movl %eax, -0xe0(%rbp)
movl -0xe0(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d61e5
jmp 0x2d61f8
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d61fa
jmp 0x2d6815
jmp 0x2d6201
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x280(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d7820
movq -0x280(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x148(%rax)
movl %eax, -0xe4(%rbp)
movl -0xe4(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d6245
jmp 0x2d6258
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d625a
jmp 0x2d6815
jmp 0x2d6261
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x288(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d7870
movq -0x288(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x150(%rax)
movl %eax, -0xe8(%rbp)
movl -0xe8(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d62a5
jmp 0x2d62b8
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d62ba
jmp 0x2d6815
jmp 0x2d62c1
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x290(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d78c0
movq -0x290(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x158(%rax)
movl %eax, -0xec(%rbp)
movl -0xec(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d6305
jmp 0x2d6318
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d631a
jmp 0x2d6815
jmp 0x2d6321
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x298(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d7910
movq -0x298(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x1b8(%rax)
movl %eax, -0xf0(%rbp)
movl -0xf0(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d6365
jmp 0x2d6378
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d637a
jmp 0x2d6815
jmp 0x2d6381
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x2a0(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d7960
movq -0x2a0(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x160(%rax)
movl %eax, -0xf4(%rbp)
movl -0xf4(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d63c5
jmp 0x2d63d8
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d63da
jmp 0x2d6815
jmp 0x2d63e1
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x2a8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d79b0
movq -0x2a8(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x168(%rax)
movl %eax, -0xf8(%rbp)
movl -0xf8(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d6425
jmp 0x2d6438
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d643a
jmp 0x2d6815
jmp 0x2d6441
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x2b0(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d7a00
movq -0x2b0(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x170(%rax)
movl %eax, -0xfc(%rbp)
movl -0xfc(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d6485
jmp 0x2d6498
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d649a
jmp 0x2d6815
jmp 0x2d64a1
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x2b8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d7a50
movq -0x2b8(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x178(%rax)
movl %eax, -0x100(%rbp)
movl -0x100(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d64e5
jmp 0x2d64f8
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d64fa
jmp 0x2d6815
jmp 0x2d6501
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x2c0(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d7aa0
movq -0x2c0(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x180(%rax)
movl %eax, -0x104(%rbp)
movl -0x104(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d6545
jmp 0x2d6558
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d655a
jmp 0x2d6815
jmp 0x2d6561
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x2c8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d7af0
movq -0x2c8(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x1b0(%rax)
movl %eax, -0x108(%rbp)
movl -0x108(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d65a5
jmp 0x2d65b8
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d65ba
jmp 0x2d6815
movq -0x18(%rbp), %rdi
callq 0x2bea10
movq %rax, -0x110(%rbp)
movq -0x138(%rbp), %rax
movq (%rax), %rdi
movq -0x110(%rbp), %rsi
movq (%rdi), %rax
callq *0x198(%rax)
movl %eax, -0x114(%rbp)
movl -0x114(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d6600
jmp 0x2d6613
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d6615
movq -0x138(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x110(%rbp), %rcx
addq $0x40, %rcx
addq $0xa0, %rcx
movl $0x5, %esi
callq 0x2d6870
jmp 0x2d6815
jmp 0x2d6643
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x2d0(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d7b40
movq -0x2d0(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x188(%rax)
movl %eax, -0x118(%rbp)
movl -0x118(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d6687
jmp 0x2d669a
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d669c
jmp 0x2d6815
jmp 0x2d66a3
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x2d8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d7b90
movq -0x2d8(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x1f8(%rax)
movl %eax, -0x11c(%rbp)
movl -0x11c(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d66e7
jmp 0x2d66fa
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d66fc
jmp 0x2d6815
jmp 0x2d6703
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x2e0(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d7be0
movq -0x2e0(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x200(%rax)
movl %eax, -0x120(%rbp)
movl -0x120(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d6747
jmp 0x2d675a
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d675c
jmp 0x2d6815
jmp 0x2d6763
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x2e8(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d7c30
movq -0x2e8(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x208(%rax)
movl %eax, -0x124(%rbp)
movl -0x124(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d67a7
jmp 0x2d67b7
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d67b9
jmp 0x2d6815
jmp 0x2d67bd
movq -0x138(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x2f0(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d7c80
movq -0x2f0(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x190(%rax)
movl %eax, -0x128(%rbp)
movl -0x128(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2d6801
jmp 0x2d6811
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2d6820
jmp 0x2d6813
jmp 0x2d6815
leaq -0x4(%rbp), %rdi
xorl %esi, %esi
callq 0x1cba40
movl -0x4(%rbp), %eax
addq $0x2f0, %rsp # imm = 0x2F0
popq %rbp
retq
nopl (%rax)
| /dcodeIO[P]wabt/src/expr-visitor.cc |
wabt::Module::AppendField(std::unique_ptr<wabt::ElemSegmentModuleField, std::default_delete<wabt::ElemSegmentModuleField>>) | void Module::AppendField(std::unique_ptr<ElemSegmentModuleField> field) {
ElemSegment& elem_segment = field->elem_segment;
if (!elem_segment.name.empty()) {
elem_segment_bindings.emplace(elem_segment.name,
Binding(field->loc, elem_segments.size()));
}
elem_segments.push_back(&elem_segment);
fields.push_back(std::move(field));
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x70(%rbp)
movq %rdi, %rax
movq -0x70(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x22be50
addq $0x40, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x1a6610
testb $0x1, %al
jne 0x2dbc3d
movq -0x60(%rbp), %rax
movq -0x68(%rbp), %rdi
addq $0x338, %rax # imm = 0x338
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x78(%rbp)
callq 0x22be50
movq -0x60(%rbp), %rdi
addq $0x18, %rax
movq %rax, -0x88(%rbp)
addq $0x118, %rdi # imm = 0x118
callq 0x2cc740
movq -0x88(%rbp), %rsi
movl %eax, %edx
leaq -0x40(%rbp), %rdi
callq 0x22dbb0
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
leaq -0x40(%rbp), %rdx
callq 0x22db70
movq %rax, -0x48(%rbp)
movq -0x60(%rbp), %rdi
addq $0x118, %rdi # imm = 0x118
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rsi
callq 0x2dd850
movq -0x60(%rbp), %rax
movq -0x68(%rbp), %rsi
addq $0x40, %rax
movq %rax, -0x90(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2dd880
movq -0x90(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x22d9f0
leaq -0x58(%rbp), %rdi
callq 0x22db20
addq $0x90, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /dcodeIO[P]wabt/src/ir.cc |
wabt::Module::AppendField(std::unique_ptr<wabt::ModuleField, std::default_delete<wabt::ModuleField>>) | void Module::AppendField(std::unique_ptr<ModuleField> field) {
switch (field->type()) {
case ModuleFieldType::Func:
AppendField(cast<FuncModuleField>(std::move(field)));
break;
case ModuleFieldType::Global:
AppendField(cast<GlobalModuleField>(std::move(field)));
break;
case ModuleFieldType::Import:
AppendField(cast<ImportModuleField>(std::move(field)));
break;
case ModuleFieldType::Export:
AppendField(cast<ExportModuleField>(std::move(field)));
break;
case ModuleFieldType::Type:
AppendField(cast<TypeModuleField>(std::move(field)));
break;
case ModuleFieldType::Table:
AppendField(cast<TableModuleField>(std::move(field)));
break;
case ModuleFieldType::ElemSegment:
AppendField(cast<ElemSegmentModuleField>(std::move(field)));
break;
case ModuleFieldType::Memory:
AppendField(cast<MemoryModuleField>(std::move(field)));
break;
case ModuleFieldType::DataSegment:
AppendField(cast<DataSegmentModuleField>(std::move(field)));
break;
case ModuleFieldType::Start:
AppendField(cast<StartModuleField>(std::move(field)));
break;
case ModuleFieldType::Event:
AppendField(cast<EventModuleField>(std::move(field)));
break;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x88(%rbp)
movq %rdi, %rax
movq -0x88(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
callq 0x246e60
movq %rax, %rdi
callq 0x235470
movl %eax, %ecx
movq %rcx, -0x70(%rbp)
subl $0xa, %eax
ja 0x2dca1a
movq -0x70(%rbp), %rax
leaq 0x37885(%rip), %rcx # 0x3140ec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x80(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x2ddf60
movq -0x78(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x2dbea0
leaq -0x18(%rbp), %rdi
callq 0x22c3e0
jmp 0x2dca1a
movq -0x80(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x2ddfe0
movq -0x78(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2dc0b0
leaq -0x20(%rbp), %rdi
callq 0x22cbe0
jmp 0x2dca1a
movq -0x80(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x2de060
movq -0x78(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2dc1b0
leaq -0x28(%rbp), %rdi
callq 0x22c260
jmp 0x2dca1a
movq -0x80(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x2de0e0
movq -0x78(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2dbda0
leaq -0x30(%rbp), %rdi
callq 0x22c0a0
jmp 0x2dca1a
movq -0x80(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x2de160
movq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2dbfa0
leaq -0x38(%rbp), %rdi
callq 0x22c8a0
jmp 0x2dca1a
movq -0x80(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x2de1e0
movq -0x78(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2dc710
leaq -0x40(%rbp), %rdi
callq 0x22d9a0
jmp 0x2dca1a
movq -0x80(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x2de260
movq -0x78(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2dbb90
leaq -0x48(%rbp), %rdi
callq 0x22bea0
jmp 0x2dca1a
movq -0x80(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x2de2e0
movq -0x78(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x2dc590
leaq -0x50(%rbp), %rdi
callq 0x22d650
jmp 0x2dca1a
movq -0x80(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x2de360
movq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x2dba80
leaq -0x58(%rbp), %rdi
callq 0x22bd90
jmp 0x2dca1a
movq -0x80(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x2de3e0
movq -0x78(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x2dc690
leaq -0x60(%rbp), %rdi
callq 0x22d740
jmp 0x2dca1a
movq -0x80(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x2de460
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x2dbca0
leaq -0x68(%rbp), %rdi
callq 0x22bfb0
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /dcodeIO[P]wabt/src/ir.cc |
wabt::(anonymous namespace)::NameResolver::ResolveLocalVar(wabt::Var*) | void NameResolver::ResolveLocalVar(Var* var) {
if (var->is_name()) {
if (!current_func_) {
return;
}
Index index = current_func_->GetLocalIndex(*var);
if (index == kInvalidIndex) {
PrintError(&var->loc, "undefined local variable \"%s\"",
var->name().c_str());
return;
}
var->set_index(index);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2de880
testb $0x1, %al
jne 0x2e7c47
jmp 0x2e7cae
movq -0x20(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x2e7c54
jmp 0x2e7cae
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x2db3b0
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x2e7ca2
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2e8ee0
movq %rax, %rdi
callq 0x1a6170
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq %rax, %rcx
leaq 0x2d9ef(%rip), %rdx # 0x315688
movb $0x0, %al
callq 0x2e7880
jmp 0x2e7cae
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x2dcf40
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /dcodeIO[P]wabt/src/resolve-names.cc |
wabt::(anonymous namespace)::NameResolver::VisitExport(wabt::Export*) | void NameResolver::VisitExport(Export* export_) {
switch (export_->kind) {
case ExternalKind::Func:
ResolveFuncVar(&export_->var);
break;
case ExternalKind::Table:
ResolveTableVar(&export_->var);
break;
case ExternalKind::Memory:
ResolveMemoryVar(&export_->var);
break;
case ExternalKind::Global:
ResolveGlobalVar(&export_->var);
break;
case ExternalKind::Event:
ResolveEventVar(&export_->var);
break;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x4, %rax
ja 0x2e7eea
movq -0x18(%rbp), %rax
leaq 0x2d680(%rip), %rcx # 0x315504
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
callq 0x2e7b60
jmp 0x2e7eea
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
callq 0x2e7ba0
jmp 0x2e7eea
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
callq 0x2e8980
jmp 0x2e7eea
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
callq 0x2e7be0
jmp 0x2e7eea
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
callq 0x2e7b20
addq $0x20, %rsp
popq %rbp
retq
| /dcodeIO[P]wabt/src/resolve-names.cc |
wabt::SharedValidator::OnFuncType(wabt::Location const&, unsigned int, wabt::Type const*, unsigned int, wabt::Type const*) | Result SharedValidator::OnFuncType(const Location& loc,
Index param_count,
const Type* param_types,
Index result_count,
const Type* result_types) {
Result result = Result::Ok;
if (!options_.features.multi_value_enabled() && result_count > 1) {
result |=
PrintError(loc, "multiple result values not currently supported.");
}
func_types_.emplace(num_types_++,
FuncType{ToTypeVector(param_count, param_types),
ToTypeVector(result_count, result_types)});
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq -0x4(%rbp), %rdi
xorl %esi, %esi
callq 0x1cba40
movq -0xb8(%rbp), %rdi
callq 0x2af700
testb $0x1, %al
jne 0x2e9da6
cmpl $0x1, -0x2c(%rbp)
jbe 0x2e9da6
movq -0xb8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x2bb45(%rip), %rdx # 0x3158d5
movb $0x0, %al
callq 0x2e9b70
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %esi
leaq -0x4(%rbp), %rdi
callq 0x1cf770
movq -0xb8(%rbp), %rsi
movq %rsi, %rax
addq $0x90, %rax
movq %rax, -0xc0(%rbp)
movl 0x88(%rsi), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, 0x88(%rsi)
movl %eax, -0x40(%rbp)
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
leaq -0x88(%rbp), %rdi
callq 0x2e98f0
movq -0xb8(%rbp), %rsi
movl -0x2c(%rbp), %edx
movq -0x38(%rbp), %rcx
leaq -0xa0(%rbp), %rdi
callq 0x2e98f0
leaq -0x70(%rbp), %rdi
leaq -0x88(%rbp), %rsi
leaq -0xa0(%rbp), %rdx
callq 0x2ef9f0
movq -0xc0(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x70(%rbp), %rdx
callq 0x2ef9a0
movq %rax, -0xb0(%rbp)
movb %dl, -0xa8(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x26ab20
leaq -0xa0(%rbp), %rdi
callq 0x1cc0e0
leaq -0x88(%rbp), %rdi
callq 0x1cc0e0
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /dcodeIO[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnEvent(wabt::Location const&, wabt::Var) | Result SharedValidator::OnEvent(const Location& loc, Var sig_var) {
Result result = Result::Ok;
FuncType type;
result |= CheckFuncTypeIndex(sig_var, &type);
if (!type.results.empty()) {
result |= PrintError(loc, "Event signature must have 0 results.");
}
events_.push_back(EventType{type.params});
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdx, -0xd0(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x4(%rbp), %rdi
xorl %esi, %esi
callq 0x1cba40
leaq -0x50(%rbp), %rdi
callq 0x2efb80
movq -0xd0(%rbp), %rsi
leaq -0xa0(%rbp), %rdi
callq 0x2dce60
movq -0xc8(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x2ea080
movl %eax, -0x54(%rbp)
movl -0x54(%rbp), %esi
leaq -0x4(%rbp), %rdi
callq 0x1cf770
leaq -0xa0(%rbp), %rdi
callq 0x2dcfd0
leaq -0x50(%rbp), %rdi
addq $0x18, %rdi
callq 0x235680
testb $0x1, %al
jne 0x2ead71
movq -0xc8(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x2adfd(%rip), %rdx # 0x315b52
movb $0x0, %al
callq 0x2e9b70
movl %eax, -0xa4(%rbp)
movl -0xa4(%rbp), %esi
leaq -0x4(%rbp), %rdi
callq 0x1cf770
movq -0xc8(%rbp), %rax
addq $0x180, %rax # imm = 0x180
movq %rax, -0xd8(%rbp)
leaq -0xc0(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1d0340
movq -0xd8(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x2efea0
leaq -0xc0(%rbp), %rdi
callq 0x26a3d0
leaq -0x50(%rbp), %rdi
callq 0x26ab20
movl -0x4(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax)
| /dcodeIO[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnDataSegmentInitExpr_GlobalGet(wabt::Location const&, wabt::Var) | Result SharedValidator::OnDataSegmentInitExpr_GlobalGet(const Location& loc,
Var global_var) {
Result result = Result::Ok;
GlobalType ref_global;
result |= CheckGlobalIndex(global_var, &ref_global);
if (ref_global.mutable_) {
result |= PrintError(
loc, "initializer expression cannot reference a mutable global");
}
result |= CheckType(loc, ref_global.type, Type::I32, "data segment offset");
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdx, -0x98(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x4(%rbp), %rdi
xorl %esi, %esi
callq 0x1cba40
leaq -0x28(%rbp), %rdi
callq 0x2efe00
movq -0x98(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x2dce60
movq -0x90(%rbp), %rdi
leaq -0x78(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x2eaa50
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %esi
leaq -0x4(%rbp), %rdi
callq 0x1cf770
leaq -0x78(%rbp), %rdi
callq 0x2dcfd0
testb $0x1, -0x24(%rbp)
je 0x2eb8c7
movq -0x90(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x2a223(%rip), %rdx # 0x315ad4
movb $0x0, %al
callq 0x2e9b70
movl %eax, -0x7c(%rbp)
movl -0x7c(%rbp), %esi
leaq -0x4(%rbp), %rdi
callq 0x1cf770
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x84(%rbp)
leaq -0x88(%rbp), %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x1cbac0
movq -0x90(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movl -0x84(%rbp), %edx
movl -0x88(%rbp), %ecx
leaq 0x2a3b2(%rip), %r8 # 0x315cbf
callq 0x2ea7a0
movl %eax, -0x80(%rbp)
movl -0x80(%rbp), %esi
leaq -0x4(%rbp), %rdi
callq 0x1cf770
movl -0x4(%rbp), %eax
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
| /dcodeIO[P]wabt/src/shared-validator.cc |
wabt::TypeChecker::OnBrTableTarget(unsigned int) | Result TypeChecker::OnBrTableTarget(Index depth) {
Result result = Result::Ok;
Label* label;
CHECK_RESULT(GetLabel(depth, &label));
TypeVector& label_sig = label->br_types();
result |= CheckSignature(label_sig, "br_table");
// Make sure this label's signature is consistent with the previous labels'
// signatures.
if (br_table_sig_ == nullptr) {
br_table_sig_ = &label_sig;
} else {
if (*br_table_sig_ != label_sig) {
result |= Result::Error;
PrintError("br_table labels have inconsistent types: expected %s, got %s",
TypesToString(*br_table_sig_).c_str(),
TypesToString(label_sig).c_str());
}
}
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x1cba40
movq -0x80(%rbp), %rdi
movl -0x14(%rbp), %esi
leaq -0x20(%rbp), %rdx
callq 0x2f8ac0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
jne 0x2fa506
jmp 0x2fa519
leaq -0x4(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
jmp 0x2fa610
jmp 0x2fa51b
movq -0x20(%rbp), %rdi
callq 0x265d40
movq -0x80(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
leaq 0xb0ec(%rip), %rdx # 0x305623
callq 0x2f9360
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %esi
leaq -0x18(%rbp), %rdi
callq 0x1cf770
movq -0x80(%rbp), %rax
cmpq $0x0, 0x50(%rax)
jne 0x2fa567
movq -0x80(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, 0x50(%rax)
jmp 0x2fa60a
movq -0x80(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x30(%rbp), %rsi
callq 0x2786f0
testb $0x1, %al
jne 0x2fa581
jmp 0x2fa608
leaq -0x38(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
movl -0x38(%rbp), %esi
leaq -0x18(%rbp), %rdi
callq 0x1cf770
movq -0x80(%rbp), %rax
movq 0x50(%rax), %rsi
leaq -0x58(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x2f97b0
leaq -0x58(%rbp), %rdi
callq 0x1a6170
movq %rax, -0x88(%rbp)
movq -0x30(%rbp), %rsi
leaq -0x78(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x2f97b0
leaq -0x78(%rbp), %rdi
callq 0x1a6170
movq -0x80(%rbp), %rdi
movq -0x88(%rbp), %rdx
movq %rax, %rcx
leaq 0x1bda4(%rip), %rsi # 0x316393
movb $0x0, %al
callq 0x2f8950
leaq -0x78(%rbp), %rdi
callq 0x1a6250
leaq -0x58(%rbp), %rdi
callq 0x1a6250
jmp 0x2fa60a
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
| /dcodeIO[P]wabt/src/type-checker.cc |
wabt::TypeChecker::OnSimdShuffleOp(wabt::Opcode, v128) | Result TypeChecker::OnSimdShuffleOp(Opcode opcode, v128 lane_idx) {
Result result = Result::Ok;
uint8_t simd_data[16];
memcpy(simd_data, &lane_idx, 16);
for (int i = 0; i < 16; i++) {
if (simd_data[i] >= 32) {
PrintError("lane index must be less than 32 (got %d)", simd_data[i]);
result = Result::Error;
}
}
result |= CheckOpcode2(opcode);
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %esi, -0x8(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x4(%rbp), %rdi
xorl %esi, %esi
callq 0x1cba40
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
cmpl $0x10, -0x34(%rbp)
jge 0x2fbda1
movslq -0x34(%rbp), %rax
movzbl -0x30(%rbp,%rax), %eax
cmpl $0x20, %eax
jl 0x2fbd94
movq -0x48(%rbp), %rdi
movslq -0x34(%rbp), %rax
movzbl -0x30(%rbp,%rax), %edx
leaq 0x1a792(%rip), %rsi # 0x31650b
movb $0x0, %al
callq 0x2f8950
leaq -0x38(%rbp), %rdi
movl $0x1, %esi
callq 0x1cba40
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2fbd96
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x2fbd51
movq -0x48(%rbp), %rdi
movl -0x8(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x2f9ce0
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %esi
leaq -0x4(%rbp), %rdi
callq 0x1cf770
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
| /dcodeIO[P]wabt/src/type-checker.cc |
main | int main(int argc, char *argv[])
{
char *dbname;
RC rc;
// Look for 2 arguments. The first is always the name of the program
// that was executed, and the second should be the name of the
// database.
if (argc != 2) {
cerr << "Usage: " << argv[0] << " dbname \n";
exit(1);
}
// Opens up the database folder
dbname = argv[1];
if ((rc = smm.OpenDb(dbname))) {
PrintError(rc);
return (1);
}
RBparse(pfm, smm, qlm);
// Closes the database folder
if ((rc = smm.CloseDb())) {
PrintError(rc);
return (1);
}
cout << "Bye.\n";
} | pushq %rbx
movq %rsi, %rbx
cmpl $0x2, %edi
jne 0x4d1c
movq 0x8(%rbx), %rsi
leaq 0x24688(%rip), %rdi # 0x29348
callq 0x8458
testl %eax, %eax
jne 0x4cf2
leaq 0x24660(%rip), %rdi # 0x29330
leaq 0x24671(%rip), %rbx # 0x29348
leaq 0x24712(%rip), %rdx # 0x293f0
movq %rbx, %rsi
callq 0x18ffe
movq %rbx, %rdi
callq 0x853c
testl %eax, %eax
je 0x4d00
movl %eax, %edi
callq 0x18f4a
movl $0x1, %eax
popq %rbx
retq
movq 0x242c1(%rip), %rdi # 0x28fc8
leaq 0x18308(%rip), %rsi # 0x1d016
movl $0x5, %edx
callq 0x4330
xorl %eax, %eax
jmp 0x4cfe
movq 0x242cd(%rip), %rdi # 0x28ff0
leaq 0x182da(%rip), %rsi # 0x1d004
callq 0x42e0
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x42e0
leaq 0x182cb(%rip), %rsi # 0x1d00c
movq %rax, %rdi
callq 0x42e0
movl $0x1, %edi
callq 0x4360
nop
| /lyang1024[P]redbase/src/redbase.cc |
PF_Manager::OpenFile(char const*, PF_FileHandle&) | RC PF_Manager::OpenFile (const char *fileName, PF_FileHandle &fileHandle)
{
int rc; // return code
// Ensure file is not already open
if (fileHandle.bFileOpen)
return (PF_FILEOPEN);
// Open the file
if ((fileHandle.unixfd = open(fileName,
#ifdef PC
O_BINARY |
#endif
O_RDWR)) < 0)
return (PF_UNIX);
// Read the file header
{
int numBytes = read(fileHandle.unixfd, (char *)&fileHandle.hdr,
sizeof(PF_FileHdr));
if (numBytes != sizeof(PF_FileHdr)) {
rc = (numBytes < 0) ? PF_UNIX : PF_HDRREAD;
goto err;
}
}
// Set file header to be not changed
fileHandle.bHdrChanged = FALSE;
// Set local variables in file handle object to refer to open file
fileHandle.pBufferMgr = pBufferMgr;
fileHandle.bFileOpen = TRUE;
// Return ok
return 0;
err:
// Close file
close(fileHandle.unixfd);
fileHandle.bFileOpen = FALSE;
// Return error
return (rc);
} | pushq %rbp
pushq %r14
pushq %rbx
movl $0x4, %ebp
cmpl $0x0, 0x10(%rdx)
jne 0x4ed9
movq %rdx, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movl $0x2, %esi
xorl %eax, %eax
callq 0x4240
movl %eax, 0x18(%rbx)
testl %eax, %eax
js 0x4eb6
leaq 0x8(%rbx), %rsi
movl $0x8, %edx
movl %eax, %edi
callq 0x43f0
cmpl $0x8, %eax
jne 0x4ebd
movl $0x0, 0x14(%rbx)
movq (%r14), %rax
movq %rax, (%rbx)
xorl %ebp, %ebp
movl $0x1, %eax
jmp 0x4ed6
movl $0xfffffff5, %ebp # imm = 0xFFFFFFF5
jmp 0x4ed9
testl %eax, %eax
movl $0xfffffffb, %eax # imm = 0xFFFFFFFB
movl $0xfffffff5, %ebp # imm = 0xFFFFFFF5
cmovnsl %eax, %ebp
movl 0x18(%rbx), %edi
callq 0x4570
xorl %eax, %eax
movl %eax, 0x10(%rbx)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
| /lyang1024[P]redbase/src/pf_manager.cc |
PF_BufferMgr::InternalAlloc(int&) | RC PF_BufferMgr::InternalAlloc(int &slot)
{
RC rc; // return code
// If the free list is not empty, choose a slot from the free list
if (free != INVALID_SLOT) {
slot = free;
free = bufTable[slot].next;
}
else {
// Choose the least-recently used page that is unpinned
for (slot = last; slot != INVALID_SLOT; slot = bufTable[slot].prev) {
if (bufTable[slot].pinCount == 0)
break;
}
// Return error if all buffers were pinned
if (slot == INVALID_SLOT)
return (PF_NOBUF);
// Write out the page if it is dirty
if (bufTable[slot].bDirty) {
if ((rc = WritePage(bufTable[slot].fd, bufTable[slot].pageNum,
bufTable[slot].pData)))
return (rc);
bufTable[slot].bDirty = FALSE;
}
// Remove page from the hash table and slot from the used buffer list
if ((rc = hashTable.Delete(bufTable[slot].fd, bufTable[slot].pageNum)) ||
(rc = Unlink(slot)))
return (rc);
}
// Link slot at the head of the used list
if ((rc = LinkHead(slot)))
return (rc);
// Return ok
return (0);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movslq 0x28(%rdi), %rax
cmpq $-0x1, %rax
je 0x5351
movl %eax, (%r14)
movq (%rbx), %rcx
shlq $0x5, %rax
movl 0x8(%rcx,%rax), %eax
movl %eax, 0x28(%rbx)
movslq (%r14), %rcx
movslq 0x20(%rbx), %rax
movq %rcx, %rsi
shlq $0x5, %rsi
movq (%rbx), %rdx
movl %eax, 0x8(%rdx,%rsi)
movl $0xffffffff, 0xc(%rdx,%rsi) # imm = 0xFFFFFFFF
cmpq $-0x1, %rax
je 0x533a
shlq $0x5, %rax
movl %ecx, 0xc(%rdx,%rax)
movl %ecx, 0x20(%rbx)
xorl %eax, %eax
cmpl $-0x1, 0x24(%rbx)
jne 0x53f4
movl %ecx, 0x24(%rbx)
jmp 0x53f4
movslq 0x24(%rbx), %rcx
movl %ecx, (%r14)
movl $0xfffffffe, %eax # imm = 0xFFFFFFFE
cmpq $-0x1, %rcx
sete %sil
je 0x53f4
movq (%rbx), %rdx
movq %rcx, %rdi
shlq $0x5, %rdi
cmpw $0x0, 0x14(%rdx,%rdi)
je 0x5395
shlq $0x5, %rcx
movslq 0xc(%rdx,%rcx), %rcx
movl %ecx, (%r14)
cmpq $-0x1, %rcx
sete %sil
jne 0x536e
jmp 0x53f4
testb %sil, %sil
jne 0x53f4
movq (%rbx), %rax
movslq %ecx, %rcx
shlq $0x5, %rcx
cmpl $0x0, 0x10(%rax,%rcx)
je 0x53d5
addq %rcx, %rax
movl 0x1c(%rax), %esi
movl 0x18(%rax), %edx
movq (%rax), %rcx
movq %rbx, %rdi
callq 0x5892
testl %eax, %eax
jne 0x53f4
movq (%rbx), %rax
movslq (%r14), %rcx
shlq $0x5, %rcx
movl $0x0, 0x10(%rax,%rcx)
leaq 0x8(%rbx), %rdi
movq (%rbx), %rax
movslq (%r14), %rcx
shlq $0x5, %rcx
movl 0x18(%rax,%rcx), %edx
movl 0x1c(%rax,%rcx), %esi
callq 0x64da
testl %eax, %eax
je 0x53fc
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl (%r14), %esi
movq %rbx, %rdi
callq 0x54b2
jmp 0x530f
| /lyang1024[P]redbase/src/pf_buffermgr.cc |
PF_BufferMgr::InitPageDesc(int, int, int) | RC PF_BufferMgr::InitPageDesc(int fd, PageNum pageNum, int slot)
{
// set the slot to refer to a newly-pinned page
bufTable[slot].fd = fd;
bufTable[slot].pageNum = pageNum;
bufTable[slot].bDirty = FALSE;
bufTable[slot].pinCount = 1;
// Return ok
return (0);
} | movq (%rdi), %rax
movslq %ecx, %rcx
shlq $0x5, %rcx
movl %esi, 0x1c(%rax,%rcx)
movl %edx, 0x18(%rax,%rcx)
movl $0x0, 0x10(%rax,%rcx)
movw $0x1, 0x14(%rax,%rcx)
xorl %eax, %eax
retq
| /lyang1024[P]redbase/src/pf_buffermgr.cc |
PF_BufferMgr::LinkHead(int) | RC PF_BufferMgr::LinkHead(int slot)
{
// Set next and prev pointers of slot entry
bufTable[slot].next = first;
bufTable[slot].prev = INVALID_SLOT;
// If list isn't empty, point old first back to slot
if (first != INVALID_SLOT)
bufTable[first].prev = slot;
first = slot;
// if list was empty, set last to slot
if (last == INVALID_SLOT)
last = first;
// Return ok
return (0);
} | movslq 0x20(%rdi), %rax
movslq %esi, %rdx
shlq $0x5, %rdx
movq (%rdi), %rcx
movl %eax, 0x8(%rcx,%rdx)
movl $0xffffffff, 0xc(%rcx,%rdx) # imm = 0xFFFFFFFF
cmpq $-0x1, %rax
je 0x5566
shlq $0x5, %rax
movl %esi, 0xc(%rcx,%rax)
movl %esi, 0x20(%rdi)
cmpl $-0x1, 0x24(%rdi)
jne 0x5572
movl %esi, 0x24(%rdi)
xorl %eax, %eax
retq
nop
| /lyang1024[P]redbase/src/pf_buffermgr.cc |
PF_BufferMgr::MarkDirty(int, int) | RC PF_BufferMgr::MarkDirty(int fd, PageNum pageNum)
{
RC rc; // return code
int slot; // buffer slot where page is located
#ifdef PF_LOG
char psMessage[100];
sprintf (psMessage, "Marking dirty (%d,%d).\n", fd, pageNum);
WriteLog(psMessage);
#endif
// The page must be found and pinned in the buffer
if ((rc = hashTable.Find(fd, pageNum, slot))){
if ((rc == PF_HASHNOTFOUND))
return (PF_PAGENOTINBUF);
else
return (rc); // unexpected error
}
if (bufTable[slot].pinCount == 0)
return (PF_PAGEUNPINNED);
// Mark this page dirty
bufTable[slot].bDirty = TRUE;
// Make this page the most recently used page
if ((rc = Unlink(slot)) ||
(rc = LinkHead (slot)))
return (rc);
// Return ok
return (0);
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
addq $0x8, %rdi
leaq 0xc(%rsp), %rcx
callq 0x641e
cmpl $-0x8, %eax
je 0x56d6
testl %eax, %eax
jne 0x56e2
movq (%rbx), %rax
movslq 0xc(%rsp), %rcx
shlq $0x5, %rcx
cmpw $0x0, 0x14(%rax,%rcx)
je 0x56dd
addq %rcx, %rax
movl $0x1, 0x10(%rax)
movl 0xc(%rsp), %esi
movq %rbx, %rdi
callq 0x54b2
movslq 0xc(%rsp), %rcx
movslq 0x20(%rbx), %rax
movq %rcx, %rsi
shlq $0x5, %rsi
movq (%rbx), %rdx
movl %eax, 0x8(%rdx,%rsi)
movl $0xffffffff, 0xc(%rdx,%rsi) # imm = 0xFFFFFFFF
cmpq $-0x1, %rax
je 0x56c6
shlq $0x5, %rax
movl %ecx, 0xc(%rdx,%rax)
movl %ecx, 0x20(%rbx)
xorl %eax, %eax
cmpl $-0x1, 0x24(%rbx)
jne 0x56e2
movl %ecx, 0x24(%rbx)
jmp 0x56e2
movl $0x2, %eax
jmp 0x56e2
movl $0x7, %eax
addq $0x10, %rsp
popq %rbx
retq
| /lyang1024[P]redbase/src/pf_buffermgr.cc |
PF_BufferMgr::WritePage(int, int, char*) | RC PF_BufferMgr::WritePage(int fd, PageNum pageNum, char *source)
{
#ifdef PF_LOG
char psMessage[100];
sprintf (psMessage, "Writing (%d,%d).\n", fd, pageNum);
WriteLog(psMessage);
#endif
#ifdef PF_STATS
pStatisticsMgr->Register(PF_WRITEPAGE, STAT_ADDONE);
#endif
// seek to the appropriate place (cast to long for PC's)
long offset = pageNum * (long)pageSize + PF_FILE_HDR_SIZE;
if (lseek(fd, offset, L_SET) < 0)
return (PF_UNIX);
// Read the data
int numBytes = write(fd, source, pageSize);
if (numBytes < 0)
return (PF_UNIX);
else if (numBytes != pageSize)
return (PF_INCOMPLETEWRITE);
else
return (0);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %r15d
movl %esi, %ebp
movq %rdi, %rbx
movq 0x23c4d(%rip), %rdi # 0x294f8
leaq 0x23a4e(%rip), %rax # 0x29300
movq (%rax), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x662c
movslq %r15d, %rax
movslq 0x1c(%rbx), %rsi
imulq %rax, %rsi
addq $0x1000, %rsi # imm = 0x1000
movl %ebp, %edi
xorl %edx, %edx
callq 0x4540
testq %rax, %rax
js 0x5907
movslq 0x1c(%rbx), %rdx
movl %ebp, %edi
movq %r14, %rsi
callq 0x4120
xorl %ecx, %ecx
cmpl %eax, 0x1c(%rbx)
sete %cl
testl %eax, %eax
leal -0x4(,%rcx,4), %ecx
movl $0xfffffff5, %eax # imm = 0xFFFFFFF5
cmovnsl %ecx, %eax
jmp 0x590c
movl $0xfffffff5, %eax # imm = 0xFFFFFFF5
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
| /lyang1024[P]redbase/src/pf_buffermgr.cc |
PF_BufferMgr::ClearBuffer() | RC PF_BufferMgr::ClearBuffer()
{
RC rc;
int slot, next;
slot = first;
while (slot != INVALID_SLOT) {
next = bufTable[slot].next;
if (bufTable[slot].pinCount == 0)
if ((rc = hashTable.Delete(bufTable[slot].fd,
bufTable[slot].pageNum)) ||
(rc = Unlink(slot)) ||
(rc = InsertFree(slot)))
return (rc);
slot = next;
}
return 0;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x20(%rdi), %ebp
xorl %ebx, %ebx
cmpl $-0x1, %ebp
je 0x5c20
movq %rdi, %r14
leaq 0x8(%rdi), %r15
movq (%r14), %rax
movslq %ebp, %r13
shlq $0x5, %r13
movl 0x8(%rax,%r13), %r12d
cmpw $0x0, 0x14(%rax,%r13)
jne 0x5c13
addq %r13, %rax
movl 0x18(%rax), %edx
movl 0x1c(%rax), %esi
movq %r15, %rdi
callq 0x64da
testl %eax, %eax
jne 0x5c1e
movq %r14, %rdi
movl %ebp, %esi
callq 0x54b2
movl 0x28(%r14), %eax
movq (%r14), %rcx
movl %eax, 0x8(%rcx,%r13)
movl %ebp, 0x28(%r14)
movl %r12d, %ebp
cmpl $-0x1, %r12d
jne 0x5bcc
jmp 0x5c20
movl %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /lyang1024[P]redbase/src/pf_buffermgr.cc |
PF_BufferMgr::AllocateBlock(char*&) | RC PF_BufferMgr::AllocateBlock(char *&buffer)
{
RC rc = OK_RC;
// Get an empty slot from the buffer pool
int slot;
if ((rc = InternalAlloc(slot)) != OK_RC)
return rc;
// Create artificial page number (just needs to be unique for hash table)
PageNum pageNum = PageNum(atoi(bufTable[slot].pData));
// Insert the page into the hash table, and initialize the page description entry
if ((rc = hashTable.Insert(MEMORY_FD, pageNum, slot) != OK_RC) ||
(rc = InitPageDesc(MEMORY_FD, pageNum, slot)) != OK_RC) {
// Put the slot back on the free list before returning the error
Unlink(slot);
InsertFree(slot);
return rc;
}
// Return pointer to buffer
buffer = bufTable[slot].pData;
// Return success code
return OK_RC;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4(%rsp), %rsi
callq 0x52ea
testl %eax, %eax
jne 0x5e8f
movq (%rbx), %rax
movl 0x4(%rsp), %ebp
movslq %ebp, %r12
movq %r12, %r13
shlq $0x5, %r13
movq (%rax,%r13), %rdi
callq 0x4450
movl %eax, %r15d
leaq 0x8(%rbx), %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
movl %eax, %edx
movl %r12d, %ecx
callq 0x6458
testl %eax, %eax
je 0x5e64
movq %rbx, %rdi
movl %ebp, %esi
callq 0x54b2
movl 0x28(%rbx), %eax
movq (%rbx), %rcx
movl %eax, 0x8(%rcx,%r13)
movl %ebp, 0x28(%rbx)
movl $0x1, %eax
jmp 0x5e8f
movq (%rbx), %rax
movl $0xffffffff, 0x1c(%rax,%r13) # imm = 0xFFFFFFFF
movl %r15d, 0x18(%rax,%r13)
movl $0x0, 0x10(%rax,%r13)
movw $0x1, 0x14(%rax,%r13)
movq (%rax,%r13), %rax
movq %rax, (%r14)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /lyang1024[P]redbase/src/pf_buffermgr.cc |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.