name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
wabt::(anonymous namespace)::Validator::OnTableFillExpr(wabt::VarExpr<(wabt::ExprType)57>*) | Result Validator::OnTableFillExpr(TableFillExpr* expr) {
result_ |= validator_.OnTableFill(expr->loc, expr->var);
return Result::Ok;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
leaq 0x18(%rsi), %r15
addq $0x40, %rsi
movq %rsp, %r12
movq %r12, %rdi
callq 0x3e72c
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x512ee
cmpl $0x1, 0x298(%rbx)
sete %cl
cmpl $0x1, %eax
sete %al
orb %cl, %al
movzbl %al, %eax
movl %eax, 0x298(%rbx)
movq %r12, %rdi
callq 0x3e814
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /WebAssembly[P]wabt/src/validator.cc |
wabt::(anonymous namespace)::Validator::OnReturnCallExpr(wabt::VarExpr<(wabt::ExprType)40>*) | Result Validator::OnReturnCallExpr(ReturnCallExpr* expr) {
result_ |= validator_.OnReturnCall(expr->loc, expr->var);
return Result::Ok;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
leaq 0x18(%rsi), %r15
addq $0x40, %rsi
movq %rsp, %r12
movq %r12, %rdi
callq 0x3e72c
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x50af4
cmpl $0x1, 0x298(%rbx)
sete %cl
cmpl $0x1, %eax
sete %al
orb %cl, %al
movzbl %al, %eax
movl %eax, 0x298(%rbx)
movq %r12, %rdi
callq 0x3e814
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /WebAssembly[P]wabt/src/validator.cc |
wabt::(anonymous namespace)::Validator::OnReturnCallIndirectExpr(wabt::ReturnCallIndirectExpr*) | Result Validator::OnReturnCallIndirectExpr(ReturnCallIndirectExpr* expr) {
result_ |= validator_.OnReturnCallIndirect(
expr->loc, GetFuncTypeIndex(expr->loc, expr->decl), expr->table);
return Result::Ok;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x18(%rdi), %r12
leaq 0x18(%rsi), %r13
leaq 0x40(%rsi), %rcx
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x47586
addq $0xc0, %r15
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
movq %r15, %rsi
callq 0x3e72c
movq %r12, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movq %rbp, %rcx
callq 0x50bca
cmpl $0x1, 0x298(%r14)
sete %cl
cmpl $0x1, %eax
sete %al
orb %cl, %al
movzbl %al, %eax
movl %eax, 0x298(%r14)
movq %rbp, %rdi
callq 0x3e814
movq %rbx, %rdi
callq 0x3e814
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/validator.cc |
wabt::(anonymous namespace)::Validator::OnSelectExpr(wabt::SelectExpr*) | Result Validator::OnSelectExpr(SelectExpr* expr) {
result_ |= validator_.OnSelect(expr->loc, expr->result_type.size(),
expr->result_type.data());
return Result::Ok;
} | pushq %rbx
movq %rdi, %rbx
addq $0x18, %rdi
leaq 0x18(%rsi), %rax
movq 0x40(%rsi), %rcx
movq 0x48(%rsi), %rdx
subq %rcx, %rdx
shrq $0x3, %rdx
movq %rax, %rsi
callq 0x50d4e
cmpl $0x1, 0x298(%rbx)
sete %cl
cmpl $0x1, %eax
sete %al
orb %cl, %al
movzbl %al, %eax
movl %eax, 0x298(%rbx)
xorl %eax, %eax
popq %rbx
retq
| /WebAssembly[P]wabt/src/validator.cc |
wabt::(anonymous namespace)::Validator::OnStoreExpr(wabt::LoadStoreExpr<(wabt::ExprType)49>*) | Result Validator::OnStoreExpr(StoreExpr* expr) {
result_ |=
validator_.OnStore(expr->loc, expr->opcode, expr->memidx,
expr->opcode.GetAlignment(expr->align), expr->offset);
return Result::Ok;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18(%rdi), %r12
leaq 0x18(%rsi), %r13
leaq 0x88(%rsi), %rbp
movl 0x88(%rsi), %r14d
addq $0x40, %rsi
movq %rsp, %rdi
callq 0x3e72c
movq 0x90(%r15), %rsi
movq %rbp, %rdi
callq 0x4140a
movq 0x98(%r15), %r9
movq %r12, %rdi
movq %r13, %rsi
movl %r14d, %edx
movq %rsp, %r14
movq %r14, %rcx
movq %rax, %r8
callq 0x510c8
cmpl $0x1, 0x298(%rbx)
sete %cl
cmpl $0x1, %eax
sete %al
orb %cl, %al
movzbl %al, %eax
movl %eax, 0x298(%rbx)
movq %r14, %rdi
callq 0x3e814
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/validator.cc |
wabt::(anonymous namespace)::Validator::OnCatchExpr(wabt::TryExpr*, wabt::Catch*) | Result Validator::OnCatchExpr(TryExpr*, Catch* catch_) {
result_ |= validator_.OnCatch(catch_->loc, catch_->var, catch_->IsCatchAll());
return Result::Ok;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x18(%rdi), %r12
leaq 0x20(%rdx), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x3e72c
movl 0x48(%r15), %eax
notl %eax
xorl %ecx, %ecx
orl 0x40(%r15), %eax
sete %cl
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4f960
cmpl $0x1, 0x298(%rbx)
sete %cl
cmpl $0x1, %eax
sete %al
orb %cl, %al
movzbl %al, %eax
movl %eax, 0x298(%rbx)
movq %r14, %rdi
callq 0x3e814
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /WebAssembly[P]wabt/src/validator.cc |
wabt::(anonymous namespace)::Validator::OnDelegateExpr(wabt::TryExpr*) | Result Validator::OnDelegateExpr(TryExpr* expr) {
result_ |= validator_.OnDelegate(expr->loc, expr->delegate_target);
return Result::Ok;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
leaq 0x18(%rsi), %r15
addq $0x130, %rsi # imm = 0x130
movq %rsp, %r12
movq %r12, %rdi
callq 0x3e72c
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4fb74
cmpl $0x1, 0x298(%rbx)
sete %cl
cmpl $0x1, %eax
sete %al
orb %cl, %al
movzbl %al, %eax
movl %eax, 0x298(%rbx)
movq %r12, %rdi
callq 0x3e814
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| /WebAssembly[P]wabt/src/validator.cc |
wabt::(anonymous namespace)::Validator::OnRethrowExpr(wabt::VarExpr<(wabt::ExprType)38>*) | Result Validator::OnRethrowExpr(RethrowExpr* expr) {
result_ |= validator_.OnRethrow(expr->loc, expr->var);
return Result::Ok;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
leaq 0x18(%rsi), %r15
addq $0x40, %rsi
movq %rsp, %r12
movq %r12, %rdi
callq 0x3e72c
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x50a90
cmpl $0x1, 0x298(%rbx)
sete %cl
cmpl $0x1, %eax
sete %al
orb %cl, %al
movzbl %al, %eax
movl %eax, 0x298(%rbx)
movq %r12, %rdi
callq 0x3e814
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /WebAssembly[P]wabt/src/validator.cc |
wabt::(anonymous namespace)::Validator::OnAtomicWaitExpr(wabt::LoadStoreExpr<(wabt::ExprType)6>*) | Result Validator::OnAtomicWaitExpr(AtomicWaitExpr* expr) {
result_ |= validator_.OnAtomicWait(expr->loc, expr->opcode, expr->memidx,
expr->opcode.GetAlignment(expr->align),
expr->offset);
return Result::Ok;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18(%rdi), %r12
leaq 0x18(%rsi), %r13
leaq 0x88(%rsi), %rbp
movl 0x88(%rsi), %r14d
addq $0x40, %rsi
movq %rsp, %rdi
callq 0x3e72c
movq 0x90(%r15), %rsi
movq %rbp, %rdi
callq 0x4140a
movq 0x98(%r15), %r9
movq %r12, %rdi
movq %r13, %rsi
movl %r14d, %edx
movq %rsp, %r14
movq %r14, %rcx
movq %rax, %r8
callq 0x4f296
cmpl $0x1, 0x298(%rbx)
sete %cl
cmpl $0x1, %eax
sete %al
orb %cl, %al
movzbl %al, %eax
movl %eax, 0x298(%rbx)
movq %r14, %rdi
callq 0x3e814
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/validator.cc |
wabt::(anonymous namespace)::Validator::OnAtomicNotifyExpr(wabt::LoadStoreExpr<(wabt::ExprType)4>*) | Result Validator::OnAtomicNotifyExpr(AtomicNotifyExpr* expr) {
result_ |= validator_.OnAtomicNotify(expr->loc, expr->opcode, expr->memidx,
expr->opcode.GetAlignment(expr->align),
expr->offset);
return Result::Ok;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18(%rdi), %r12
leaq 0x18(%rsi), %r13
leaq 0x88(%rsi), %rbp
movl 0x88(%rsi), %r14d
addq $0x40, %rsi
movq %rsp, %rdi
callq 0x3e72c
movq 0x90(%r15), %rsi
movq %rbp, %rdi
callq 0x4140a
movq 0x98(%r15), %r9
movq %r12, %rdi
movq %r13, %rsi
movl %r14d, %edx
movq %rsp, %r14
movq %r14, %rcx
movq %rax, %r8
callq 0x4ee56
cmpl $0x1, 0x298(%rbx)
sete %cl
cmpl $0x1, %eax
sete %al
orb %cl, %al
movzbl %al, %eax
movl %eax, 0x298(%rbx)
movq %r14, %rdi
callq 0x3e814
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/validator.cc |
wabt::(anonymous namespace)::Validator::OnAtomicLoadExpr(wabt::LoadStoreExpr<(wabt::ExprType)0>*) | Result Validator::OnAtomicLoadExpr(AtomicLoadExpr* expr) {
result_ |= validator_.OnAtomicLoad(expr->loc, expr->opcode, expr->memidx,
expr->opcode.GetAlignment(expr->align),
expr->offset);
return Result::Ok;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18(%rdi), %r12
leaq 0x18(%rsi), %r13
leaq 0x88(%rsi), %rbp
movl 0x88(%rsi), %r14d
addq $0x40, %rsi
movq %rsp, %rdi
callq 0x3e72c
movq 0x90(%r15), %rsi
movq %rbp, %rdi
callq 0x4140a
movq 0x98(%r15), %r9
movq %r12, %rdi
movq %r13, %rsi
movl %r14d, %edx
movq %rsp, %r14
movq %r14, %rcx
movq %rax, %r8
callq 0x4ed46
cmpl $0x1, 0x298(%rbx)
sete %cl
cmpl $0x1, %eax
sete %al
orb %cl, %al
movzbl %al, %eax
movl %eax, 0x298(%rbx)
movq %r14, %rdi
callq 0x3e814
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/validator.cc |
wabt::(anonymous namespace)::Validator::OnAtomicStoreExpr(wabt::LoadStoreExpr<(wabt::ExprType)3>*) | Result Validator::OnAtomicStoreExpr(AtomicStoreExpr* expr) {
result_ |= validator_.OnAtomicStore(expr->loc, expr->opcode, expr->memidx,
expr->opcode.GetAlignment(expr->align),
expr->offset);
return Result::Ok;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18(%rdi), %r12
leaq 0x18(%rsi), %r13
leaq 0x88(%rsi), %rbp
movl 0x88(%rsi), %r14d
addq $0x40, %rsi
movq %rsp, %rdi
callq 0x3e72c
movq 0x90(%r15), %rsi
movq %rbp, %rdi
callq 0x4140a
movq 0x98(%r15), %r9
movq %r12, %rdi
movq %r13, %rsi
movl %r14d, %edx
movq %rsp, %r14
movq %r14, %rcx
movq %rax, %r8
callq 0x4f186
cmpl $0x1, 0x298(%rbx)
sete %cl
cmpl $0x1, %eax
sete %al
orb %cl, %al
movzbl %al, %eax
movl %eax, 0x298(%rbx)
movq %r14, %rdi
callq 0x3e814
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/validator.cc |
wabt::(anonymous namespace)::Validator::OnAtomicRmwExpr(wabt::LoadStoreExpr<(wabt::ExprType)1>*) | Result Validator::OnAtomicRmwExpr(AtomicRmwExpr* expr) {
result_ |= validator_.OnAtomicRmw(expr->loc, expr->opcode, expr->memidx,
expr->opcode.GetAlignment(expr->align),
expr->offset);
return Result::Ok;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18(%rdi), %r12
leaq 0x18(%rsi), %r13
leaq 0x88(%rsi), %rbp
movl 0x88(%rsi), %r14d
addq $0x40, %rsi
movq %rsp, %rdi
callq 0x3e72c
movq 0x90(%r15), %rsi
movq %rbp, %rdi
callq 0x4140a
movq 0x98(%r15), %r9
movq %r12, %rdi
movq %r13, %rsi
movl %r14d, %edx
movq %rsp, %r14
movq %r14, %rcx
movq %rax, %r8
callq 0x4f076
cmpl $0x1, 0x298(%rbx)
sete %cl
cmpl $0x1, %eax
sete %al
orb %cl, %al
movzbl %al, %eax
movl %eax, 0x298(%rbx)
movq %r14, %rdi
callq 0x3e814
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/validator.cc |
wabt::(anonymous namespace)::Validator::OnAtomicRmwCmpxchgExpr(wabt::LoadStoreExpr<(wabt::ExprType)2>*) | Result Validator::OnAtomicRmwCmpxchgExpr(AtomicRmwCmpxchgExpr* expr) {
result_ |= validator_.OnAtomicRmwCmpxchg(
expr->loc, expr->opcode, expr->memidx,
expr->opcode.GetAlignment(expr->align), expr->offset);
return Result::Ok;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18(%rdi), %r12
leaq 0x18(%rsi), %r13
leaq 0x88(%rsi), %rbp
movl 0x88(%rsi), %r14d
addq $0x40, %rsi
movq %rsp, %rdi
callq 0x3e72c
movq 0x90(%r15), %rsi
movq %rbp, %rdi
callq 0x4140a
movq 0x98(%r15), %r9
movq %r12, %rdi
movq %r13, %rsi
movl %r14d, %edx
movq %rsp, %r14
movq %r14, %rcx
movq %rax, %r8
callq 0x4ef66
cmpl $0x1, 0x298(%rbx)
sete %cl
cmpl $0x1, %eax
sete %al
orb %cl, %al
movzbl %al, %eax
movl %eax, 0x298(%rbx)
movq %r14, %rdi
callq 0x3e814
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/validator.cc |
wabt::(anonymous namespace)::Validator::OnSimdLoadLaneExpr(wabt::SimdLoadLaneExpr*) | Result Validator::OnSimdLoadLaneExpr(SimdLoadLaneExpr* expr) {
result_ |= validator_.OnSimdLoadLane(expr->loc, expr->opcode, expr->memidx,
expr->opcode.GetAlignment(expr->align),
expr->offset, expr->val);
return Result::Ok;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18(%rdi), %r12
leaq 0x18(%rsi), %r13
leaq 0x88(%rsi), %rbp
movl 0x88(%rsi), %r14d
addq $0x40, %rsi
leaq 0x10(%rsp), %rdi
callq 0x3e72c
movq 0x90(%r15), %rsi
movq %rbp, %rdi
callq 0x4140a
movq 0x98(%r15), %r9
movq 0xa0(%r15), %rcx
movq %rcx, (%rsp)
movq %r12, %rdi
movq %r13, %rsi
movl %r14d, %edx
leaq 0x10(%rsp), %r14
movq %r14, %rcx
movq %rax, %r8
callq 0x50e54
cmpl $0x1, 0x298(%rbx)
sete %cl
cmpl $0x1, %eax
sete %al
orb %cl, %al
movzbl %al, %eax
movl %eax, 0x298(%rbx)
movq %r14, %rdi
callq 0x3e814
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/src/validator.cc |
wabt::(anonymous namespace)::Validator::OnSimdStoreLaneExpr(wabt::SimdStoreLaneExpr*) | Result Validator::OnSimdStoreLaneExpr(SimdStoreLaneExpr* expr) {
result_ |= validator_.OnSimdStoreLane(expr->loc, expr->opcode, expr->memidx,
expr->opcode.GetAlignment(expr->align),
expr->offset, expr->val);
return Result::Ok;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18(%rdi), %r12
leaq 0x18(%rsi), %r13
leaq 0x88(%rsi), %rbp
movl 0x88(%rsi), %r14d
addq $0x40, %rsi
leaq 0x10(%rsp), %rdi
callq 0x3e72c
movq 0x90(%r15), %rsi
movq %rbp, %rdi
callq 0x4140a
movq 0x98(%r15), %r9
movq 0xa0(%r15), %rcx
movq %rcx, (%rsp)
movq %r12, %rdi
movq %r13, %rsi
movl %r14d, %edx
leaq 0x10(%rsp), %r14
movq %r14, %rcx
movq %rax, %r8
callq 0x50f66
cmpl $0x1, 0x298(%rbx)
sete %cl
cmpl $0x1, %eax
sete %al
orb %cl, %al
movzbl %al, %eax
movl %eax, 0x298(%rbx)
movq %r14, %rdi
callq 0x3e814
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/src/validator.cc |
wabt::(anonymous namespace)::Validator::OnLoadSplatExpr(wabt::LoadStoreExpr<(wabt::ExprType)47>*) | Result Validator::OnLoadSplatExpr(LoadSplatExpr* expr) {
result_ |= validator_.OnLoadSplat(expr->loc, expr->opcode, expr->memidx,
expr->opcode.GetAlignment(expr->align),
expr->offset);
return Result::Ok;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18(%rdi), %r12
leaq 0x18(%rsi), %r13
leaq 0x88(%rsi), %rbp
movl 0x88(%rsi), %r14d
addq $0x40, %rsi
movq %rsp, %rdi
callq 0x3e72c
movq 0x90(%r15), %rsi
movq %rbp, %rdi
callq 0x4140a
movq 0x98(%r15), %r9
movq %r12, %rdi
movq %r13, %rsi
movl %r14d, %edx
movq %rsp, %r14
movq %r14, %rcx
movq %rax, %r8
callq 0x500f4
cmpl $0x1, 0x298(%rbx)
sete %cl
cmpl $0x1, %eax
sete %al
orb %cl, %al
movzbl %al, %eax
movl %eax, 0x298(%rbx)
movq %r14, %rdi
callq 0x3e814
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/validator.cc |
wabt::(anonymous namespace)::Validator::OnLoadZeroExpr(wabt::LoadStoreExpr<(wabt::ExprType)48>*) | Result Validator::OnLoadZeroExpr(LoadZeroExpr* expr) {
result_ |= validator_.OnLoadZero(expr->loc, expr->opcode, expr->memidx,
expr->opcode.GetAlignment(expr->align),
expr->offset);
return Result::Ok;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x18(%rdi), %r12
leaq 0x18(%rsi), %r13
leaq 0x88(%rsi), %rbp
movl 0x88(%rsi), %r14d
addq $0x40, %rsi
movq %rsp, %rdi
callq 0x3e72c
movq 0x90(%r15), %rsi
movq %rbp, %rdi
callq 0x4140a
movq 0x98(%r15), %r9
movq %r12, %rdi
movq %r13, %rsi
movl %r14d, %edx
movq %rsp, %r14
movq %r14, %rcx
movq %rax, %r8
callq 0x50204
cmpl $0x1, 0x298(%rbx)
sete %cl
cmpl $0x1, %eax
sete %al
orb %cl, %al
movzbl %al, %eax
movl %eax, 0x298(%rbx)
movq %r14, %rdi
callq 0x3e814
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/validator.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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq 0x20(%rdi), %r15
cmpq $0x8f, %r15
jb 0x47f22
leaq 0xc66c4(%rip), %r14 # 0x10e5c0
movq 0x10(%rbx), %rdi
movl $0x8e, %edx
movq %r14, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x438c2
addq $-0x8e, %r15
cmpq $0x8e, %r15
ja 0x47efc
testq %r15, %r15
je 0x47f45
movq 0x10(%rbx), %rdi
movslq 0x20(%rbx), %rdx
leaq 0xc668a(%rip), %rsi # 0x10e5c0
xorl %ecx, %ecx
xorl %r8d, %r8d
popq %rbx
popq %r14
popq %r15
jmp 0x438c2
popq %rbx
popq %r14
popq %r15
retq
nop
| /WebAssembly[P]wabt/src/binary-reader-logging.cc |
wabt::BinaryReaderLogging::LogType(wabt::Type) | void BinaryReaderLogging::LogType(Type type) {
if (type.IsIndex()) {
LOGF_NOINDENT("typeidx[%d]", type.GetIndex());
} else {
LOGF_NOINDENT("%s", type.GetName().c_str());
}
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rdx
movq %rsi, (%rsp)
movq 0x10(%rdi), %rbx
testl %edx, %edx
js 0x47f7a
leaq 0x1b9a8(%rip), %rsi # 0x63911
movq %rbx, %rdi
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x4394e
leaq 0x8(%rsp), %r14
movq %rsp, %rsi
movq %r14, %rdi
callq 0x2df88
movq (%r14), %rdx
leaq 0x12eb1(%rip), %rsi # 0x5ae45
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4394e
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x47fb8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x15200
addq $0x28, %rsp
popq %rbx
popq %r14
retq
| /WebAssembly[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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r15d
movq %rdi, %r14
movq 0x10(%rdi), %rdi
leaq 0x1bdfc(%rip), %rsi # 0x63ddb
xorl %eax, %eax
callq 0x4394e
testl %r15d, %r15d
je 0x48022
leal -0x1(%r15), %r12d
movl %r15d, %r13d
leaq 0x160a4(%rip), %r15 # 0x5e09d
xorl %ebp, %ebp
movq (%rbx,%rbp,8), %rsi
movq %r14, %rdi
callq 0x47f4c
cmpq %rbp, %r12
je 0x4801a
movq 0x10(%r14), %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x4394e
incq %rbp
cmpq %rbp, %r13
jne 0x47ffb
movq 0x10(%r14), %rdi
leaq 0x145a4(%rip), %rsi # 0x5c5d1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x4394e
| /WebAssembly[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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movl %r8d, %ebp
movq %rcx, %r14
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %r13
callq 0x47ee0
movq 0x10(%r13), %rdi
leaq 0x1b7bf(%rip), %rsi # 0x63964
movl %r12d, %edx
xorl %eax, %eax
callq 0x4394e
movq %r13, %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x47fc0
movq 0x10(%r13), %rdi
leaq 0x1b7bb(%rip), %rsi # 0x63983
xorl %eax, %eax
callq 0x4394e
movq %r13, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x47fc0
movq 0x10(%r13), %rdi
leaq 0x1c1fa(%rip), %rsi # 0x643e1
xorl %eax, %eax
callq 0x4394e
movq 0x18(%r13), %rdi
movq (%rdi), %rax
movq 0x58(%rax), %rax
movl %r12d, %esi
movl %r15d, %edx
movq %r14, %rcx
movl %ebp, %r8d
movq %rbx, %r9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
| /WebAssembly[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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %r15
callq 0x47ee0
movq 0x10(%r15), %rdi
leaq 0x1b74e(%rip), %rsi # 0x6398f
movl %ebp, 0xc(%rsp)
movl %ebp, %edx
xorl %eax, %eax
callq 0x4394e
movq 0x10(%r15), %rdi
leaq 0x1bb82(%rip), %rsi # 0x63ddb
xorl %eax, %eax
callq 0x4394e
movq %r14, 0x10(%rsp)
testl %r14d, %r14d
je 0x482bb
movq 0x10(%rsp), %rcx
leal -0x1(%rcx), %eax
movl %ecx, %ecx
shlq $0x2, %rax
leaq (%rax,%rax,2), %r13
shlq $0x2, %rcx
leaq (%rcx,%rcx,2), %rbp
leaq 0x15e12(%rip), %r12 # 0x5e09d
xorl %r14d, %r14d
movq (%rbx,%r14), %rsi
movl 0x8(%rbx,%r14), %edx
movq %r15, %rdi
callq 0x48056
cmpq %r14, %r13
je 0x482b2
movq 0x10(%r15), %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x4394e
addq $0xc, %r14
cmpq %r14, %rbp
jne 0x4828e
movq 0x10(%r15), %rdi
leaq 0x1b6ea(%rip), %rsi # 0x639b0
xorl %eax, %eax
callq 0x4394e
movq 0x18(%r15), %rdi
movq (%rdi), %rax
movq 0x60(%rax), %rax
movl 0xc(%rsp), %esi
movq 0x10(%rsp), %rdx
movq %rbx, %rcx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
| /WebAssembly[P]wabt/src/binary-reader-logging.cc |
wabt::BinaryReaderLogging::OnImport(unsigned int, wabt::ExternalKind, std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>) | Result BinaryReaderLogging::OnImport(Index index,
ExternalKind kind,
std::string_view module_name,
std::string_view field_name) {
LOGF("OnImport(index: %" PRIindex ", kind: %s, module: \"" PRIstringview
"\", field: \"" PRIstringview "\")\n",
index, GetKindName(kind), WABT_PRINTF_STRING_VIEW_ARG(module_name),
WABT_PRINTF_STRING_VIEW_ARG(field_name));
return reader_->OnImport(index, kind, module_name, field_name);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r12
leaq 0x40(%rsp), %r13
callq 0x47ee0
movq 0x10(%r12), %rdi
cmpl $0x4, %ebp
ja 0x48398
movl %ebp, %eax
leaq 0x3bf0e(%rip), %rcx # 0x842a0
movq (%rcx,%rax,8), %rcx
jmp 0x4839f
leaq 0x1d10d(%rip), %rcx # 0x654ac
movl (%r13), %r10d
leaq 0x1b629(%rip), %rsi # 0x639d3
movl %r15d, %edx
movl %r14d, %r8d
movq %rbx, %r9
xorl %eax, %eax
pushq 0x8(%r13)
pushq %r10
callq 0x4394e
addq $0x10, %rsp
movq 0x18(%r12), %rdi
movq (%rdi), %rax
movq 0x88(%rax), %rax
movl %r15d, %esi
movl %ebp, %edx
movq %r14, %rcx
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
| /WebAssembly[P]wabt/src/binary-reader-logging.cc |
wabt::BinaryReaderLogging::OnImportTable(unsigned int, std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>, unsigned int, wabt::Type, wabt::Limits const*) | Result BinaryReaderLogging::OnImportTable(Index import_index,
std::string_view module_name,
std::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().c_str(), buf);
return reader_->OnImportTable(import_index, module_name, field_name,
table_index, elem_type, elem_limits);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r9, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %rdx, %rbp
movl %esi, %r14d
movq %rdi, %r13
movq 0xf0(%rsp), %rsi
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
callq 0x48550
movq %r13, %rdi
callq 0x47ee0
movq 0x10(%r13), %r15
leaq 0x20(%rsp), %r12
leaq 0xe8(%rsp), %rsi
movq %r12, %rdi
callq 0x2df88
movq (%r12), %r8
leaq 0x1b57e(%rip), %rsi # 0x63a50
movq %r15, %rdi
movl 0xe0(%rsp), %r15d
movl %r14d, %edx
movl %r15d, %ecx
movq %rbx, %r9
xorl %eax, %eax
callq 0x4394e
movq (%r12), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x48508
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x15200
movq 0x18(%r13), %rdi
movq (%rdi), %rax
subq $0x8, %rsp
movl %r14d, %esi
movq %rbp, %rdx
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %r8
movq 0x20(%rsp), %r9
pushq 0xf8(%rsp)
pushq 0xf8(%rsp)
pushq %r15
callq *0x98(%rax)
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[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 %rax
movq (%rsi), %rcx
cmpb $0x1, 0x10(%rsi)
jne 0x48573
movq 0x8(%rsi), %r8
leaq 0x1cf54(%rip), %rdx # 0x654b9
movl $0x64, %esi
xorl %eax, %eax
callq 0x153c0
jmp 0x48586
leaq 0x1cf56(%rip), %rdx # 0x654d0
movl $0x64, %esi
xorl %eax, %eax
callq 0x153c0
cmpl $0x64, %eax
jae 0x4858d
popq %rax
retq
leaq 0x1cf49(%rip), %rdi # 0x654dd
leaq 0x1b2eb(%rip), %rsi # 0x63886
leaq 0x1cf5e(%rip), %rcx # 0x65500
movl $0x2e, %edx
callq 0x15160
| /WebAssembly[P]wabt/src/binary-reader-logging.cc |
wabt::BinaryReaderLogging::OnImportMemory(unsigned int, std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>, unsigned int, wabt::Limits const*, unsigned int) | Result BinaryReaderLogging::OnImportMemory(Index import_index,
std::string_view module_name,
std::string_view field_name,
Index memory_index,
const Limits* page_limits,
uint32_t page_size) {
char buf[100];
SPrintLimits(buf, sizeof(buf), page_limits);
LOGF("OnImportMemory(import_index: %" PRIindex ", memory_index: %" PRIindex
", %s)\n",
import_index, memory_index, buf);
return reader_->OnImportMemory(import_index, module_name, field_name,
memory_index, page_limits, page_size);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r9, 0x8(%rsp)
movq %r8, (%rsp)
movq %rcx, %r12
movq %rdx, %rbp
movl %esi, %r14d
movq %rdi, %r13
movl 0xb0(%rsp), %r15d
movq 0xb8(%rsp), %rsi
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x48550
movq %r13, %rdi
callq 0x47ee0
movq 0x10(%r13), %rdi
leaq 0x1b496(%rip), %rsi # 0x63a95
movl %r14d, %edx
movl %r15d, %ecx
movq %rbx, %r8
xorl %eax, %eax
callq 0x4394e
movq 0x18(%r13), %rdi
movq (%rdi), %rax
subq $0x8, %rsp
movl %r14d, %esi
movq %rbp, %rdx
movq %r12, %rcx
movq 0x8(%rsp), %r8
movq 0x10(%rsp), %r9
movl 0xc8(%rsp), %r10d
pushq %r10
pushq 0xc8(%rsp)
pushq %r15
callq *0xa0(%rax)
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/src/binary-reader-logging.cc |
wabt::BinaryReaderLogging::OnImportGlobal(unsigned int, std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>, unsigned int, wabt::Type, bool) | Result BinaryReaderLogging::OnImportGlobal(Index import_index,
std::string_view module_name,
std::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().c_str(),
mutable_ ? "true" : "false");
return reader_->OnImportGlobal(import_index, module_name, field_name,
global_index, type, mutable_);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movq %rcx, %r12
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %r14
callq 0x47ee0
movq 0x10(%r14), %rbx
leaq 0x18(%rsp), %r15
leaq 0x78(%rsp), %rsi
movq %r15, %rdi
callq 0x2df88
movq (%r15), %r8
leaq 0x19b0b(%rip), %rax # 0x621ab
leaq 0x1635a(%rip), %r9 # 0x5ea01
cmpb $0x0, 0x80(%rsp)
cmovneq %rax, %r9
leaq 0x1b413(%rip), %rsi # 0x63acd
movq %rbx, %rdi
movl 0x70(%rsp), %ebx
movl %ebp, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x4394e
movq (%r15), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x486e6
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x15200
movq 0x18(%r14), %rdi
movq (%rdi), %rax
subq $0x8, %rsp
movzbl 0x88(%rsp), %r10d
movl %ebp, %esi
movq %r13, %rdx
movq %r12, %rcx
movq 0x10(%rsp), %r8
movq 0x18(%rsp), %r9
pushq %r10
pushq 0x88(%rsp)
pushq %rbx
callq *0xa8(%rax)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/binary-reader-logging.cc |
wabt::BinaryReaderLogging::OnTable(unsigned int, wabt::Type, wabt::Limits const*) | Result BinaryReaderLogging::OnTable(Index index,
Type elem_type,
const Limits* elem_limits) {
char buf[100];
SPrintLimits(buf, sizeof(buf), elem_limits);
LOGF("OnTable(index: %" PRIindex ", elem_type: %s, %s)\n", index,
elem_type.GetName().c_str(), buf);
return reader_->OnTable(index, elem_type, elem_limits);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %rdx, (%r15)
leaq 0x30(%rsp), %rdi
movq %rcx, %rsi
callq 0x48550
movq %r14, %rdi
callq 0x47ee0
movq 0x10(%r14), %r13
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2df88
movq (%r12), %rcx
leaq 0x1b35a(%rip), %rsi # 0x63b55
movq %r13, %rdi
movl %ebp, %edx
leaq 0x30(%rsp), %r8
xorl %eax, %eax
callq 0x4394e
movq (%r12), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x48827
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x15200
movq 0x18(%r14), %rdi
movq 0x8(%rsp), %rdx
movq (%rdi), %rax
movl %ebp, %esi
movq %rbx, %rcx
callq *0xf0(%rax)
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/src/binary-reader-logging.cc |
wabt::BinaryReaderLogging::BeginGlobal(unsigned int, wabt::Type, bool) | Result BinaryReaderLogging::BeginGlobal(Index index, Type type, bool mutable_) {
LOGF("BeginGlobal(index: %" PRIindex ", type: %s, mutable: %s)\n", index,
type.GetName().c_str(), mutable_ ? "true" : "false");
return reader_->BeginGlobal(index, type, mutable_);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movl %esi, %ebx
movq %rdi, %r14
movq %rsp, %r15
movq %rdx, (%r15)
callq 0x47ee0
movq 0x10(%r14), %r12
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x2df88
movq (%r13), %rcx
leaq 0x198b8(%rip), %rax # 0x621ab
leaq 0x16107(%rip), %r8 # 0x5ea01
testl %ebp, %ebp
cmovneq %rax, %r8
leaq 0x1b28e(%rip), %rsi # 0x63b95
movq %r12, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x4394e
movq (%r13), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4892e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x15200
movq 0x18(%r14), %rdi
movq (%rsp), %rdx
movq (%rdi), %rax
movzbl %bpl, %ecx
movl %ebx, %esi
callq *0x130(%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/src/binary-reader-logging.cc |
wabt::BinaryReaderLogging::OnBrTableExpr(unsigned int, unsigned int*, unsigned int) | Result BinaryReaderLogging::OnBrTableExpr(Index num_targets,
Index* target_depths,
Index default_target_depth) {
LOGF("OnBrTableExpr(num_targets: %" PRIindex ", depths: [", num_targets);
for (Index i = 0; i < num_targets; ++i) {
LOGF_NOINDENT("%" PRIindex, target_depths[i]);
if (i != num_targets - 1) {
LOGF_NOINDENT(", ");
}
}
LOGF_NOINDENT("], default: %" PRIindex ")\n", default_target_depth);
return reader_->OnBrTableExpr(num_targets, target_depths,
default_target_depth);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, 0xc(%rsp)
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r12
callq 0x47ee0
movq 0x10(%r12), %rdi
leaq 0x1b0e6(%rip), %rsi # 0x63c8d
movl %ebx, %edx
xorl %eax, %eax
callq 0x4394e
movq %rbx, 0x10(%rsp)
testl %ebx, %ebx
je 0x48c00
movq 0x10(%rsp), %rax
leal -0x1(%rax), %ebx
movl %eax, %r15d
leaq 0x1d083(%rip), %r13 # 0x65c4e
xorl %ebp, %ebp
movq 0x10(%r12), %rdi
movl (%r14,%rbp,4), %edx
movq %r13, %rsi
xorl %eax, %eax
callq 0x4394e
cmpq %rbp, %rbx
je 0x48bf8
movq 0x10(%r12), %rdi
leaq 0x154ac(%rip), %rsi # 0x5e09d
xorl %eax, %eax
callq 0x4394e
incq %rbp
cmpq %rbp, %r15
jne 0x48bcd
movq 0x10(%r12), %rdi
leaq 0x1b0aa(%rip), %rsi # 0x63cb6
movl 0xc(%rsp), %ebx
movl %ebx, %edx
xorl %eax, %eax
callq 0x4394e
movq 0x18(%r12), %rdi
movq (%rdi), %rax
movq 0x288(%rax), %rax
movq 0x10(%rsp), %rsi
movq %r14, %rdx
movl %ebx, %ecx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
| /WebAssembly[P]wabt/src/binary-reader-logging.cc |
wabt::BinaryReaderLogging::OnTryTableExpr(wabt::Type, std::vector<wabt::CatchClause, std::allocator<wabt::CatchClause>> const&) | Result BinaryReaderLogging::OnTryTableExpr(Type sig_type,
const CatchClauseVector& catches) {
LOGF("OnTryTableExpr(sig: ");
LogType(sig_type);
Index count = catches.size();
LOGF_NOINDENT(", n: %" PRIindex ", catches: [", count);
for (auto& catch_ : catches) {
auto tag = catch_.tag;
auto depth = catch_.depth;
switch (catch_.kind) {
case CatchKind::Catch:
LOGF_NOINDENT("catch %" PRIindex " %" PRIindex, tag, depth);
break;
case CatchKind::CatchRef:
LOGF_NOINDENT("catch_ref %" PRIindex " %" PRIindex, tag, depth);
break;
case CatchKind::CatchAll:
LOGF_NOINDENT("catch_all %" PRIindex, depth);
break;
case CatchKind::CatchAllRef:
LOGF_NOINDENT("catch_all_ref %" PRIindex, depth);
break;
}
if (--count != 0) {
LOGF_NOINDENT(", ");
}
}
LOGF_NOINDENT("])\n");
return reader_->OnTryTableExpr(sig_type, catches);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x47ee0
movq 0x10(%r15), %rdi
leaq 0x1ae77(%rip), %rsi # 0x63db4
xorl %eax, %eax
callq 0x4394e
movq %r15, %rdi
movq %r14, 0x8(%rsp)
movq %r14, %rsi
callq 0x47f4c
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x2, %rax
imull $0xaaaaaaab, %eax, %ebp # imm = 0xAAAAAAAB
movq 0x10(%r15), %rdi
leaq 0x1ae59(%rip), %rsi # 0x63dc9
movl %ebp, %edx
xorl %eax, %eax
callq 0x4394e
movq (%rbx), %r13
movq %rbx, 0x10(%rsp)
movq 0x8(%rbx), %r14
cmpq %r14, %r13
je 0x49017
decl %ebp
leaq 0x15106(%rip), %r12 # 0x5e09d
leaq 0x1a8ae(%rip), %rbx # 0x6384c
movl (%r13), %eax
cmpq $0x3, %rax
ja 0x48ffb
movl 0x4(%r13), %edx
movl 0x8(%r13), %ecx
movslq (%rbx,%rax,4), %rax
addq %rbx, %rax
jmpq *%rax
movq 0x10(%r15), %rdi
leaq 0x1ae19(%rip), %rsi # 0x63ddd
jmp 0x48ff4
movq 0x10(%r15), %rdi
leaq 0x1ae28(%rip), %rsi # 0x63df9
jmp 0x48fde
movq 0x10(%r15), %rdi
leaq 0x1ae28(%rip), %rsi # 0x63e06
movl %ecx, %edx
xorl %eax, %eax
callq 0x4394e
jmp 0x48ffb
movq 0x10(%r15), %rdi
leaq 0x1adf5(%rip), %rsi # 0x63de9
xorl %eax, %eax
callq 0x4394e
subl $0x1, %ebp
jb 0x4900e
movq 0x10(%r15), %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x4394e
addq $0xc, %r13
cmpq %r14, %r13
jne 0x48f9e
movq 0x10(%r15), %rdi
leaq 0x1a98e(%rip), %rsi # 0x639b0
xorl %eax, %eax
callq 0x4394e
movq 0x18(%r15), %rdi
movq (%rdi), %rax
movq 0x428(%rax), %rax
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
nop
| /WebAssembly[P]wabt/src/binary-reader-logging.cc |
wabt::BinaryReaderLogging::OnElemSegmentElemType(unsigned int, wabt::Type) | Result BinaryReaderLogging::OnElemSegmentElemType(Index index, Type elem_type) {
LOGF("OnElemSegmentElemType(index: %" PRIindex ", type: %s)\n", index,
elem_type.GetName().c_str());
return reader_->OnElemSegmentElemType(index, elem_type);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %rdx, (%r15)
callq 0x47ee0
movq 0x10(%r14), %r12
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x2df88
movq (%r13), %rcx
leaq 0x1ad11(%rip), %rsi # 0x63ea1
movq %r12, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x4394e
movq (%r13), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x491b7
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x15200
movq 0x18(%r14), %rdi
movq 0x8(%rsp), %rdx
movq (%rdi), %rax
movl %ebx, %esi
callq *0x4b0(%rax)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
| /WebAssembly[P]wabt/src/binary-reader-logging.cc |
wabt::BindingHash::FindDuplicates(std::function<void (std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, wabt::Binding> const&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, wabt::Binding> const&)>) const | void BindingHash::FindDuplicates(DuplicateCallback callback) const {
if (size() > 0) {
ValueTypeVector duplicates;
CreateDuplicatesVector(&duplicates);
SortDuplicatesVectorByLocation(&duplicates);
CallCallbacks(duplicates, callback);
}
} | cmpq $0x0, 0x18(%rdi)
je 0x4c80c
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq %r14, %rsi
callq 0x4c80e
movq %r14, %rsi
callq 0x4c8ba
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x4c7c7
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x2, %edx
callq *%rax
movq 0x18(%rbx), %rax
movq %rax, 0x18(%r14)
movq 0x10(%rbx), %rax
movq %rax, 0x10(%r14)
movq %rsp, %rsi
leaq 0x20(%rsp), %rbx
movq %rbx, %rdx
callq 0x4c954
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x4c7ef
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4c805
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
addq $0x48, %rsp
popq %rbx
popq %r14
retq
nop
| /WebAssembly[P]wabt/src/binding-hash.cc |
wabt::BindingHash::CreateDuplicatesVector(std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, wabt::Binding> const*, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, wabt::Binding> const*>>*) const | void BindingHash::CreateDuplicatesVector(
ValueTypeVector* out_duplicates) const {
// This relies on the fact that in an unordered_multimap, all values with the
// same key are adjacent in iteration order.
auto first = begin();
bool is_first = true;
for (auto iter = std::next(first); iter != end(); ++iter) {
if (first->first == iter->first) {
if (is_first) {
out_duplicates->push_back(&*first);
}
out_duplicates->push_back(&*iter);
is_first = false;
} else {
is_first = true;
first = iter;
}
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
movq 0x10(%rdi), %r12
movq (%r12), %r15
testq %r15, %r15
je 0x4c8ab
movb $0x1, %bpl
leaq 0x8(%r12), %r14
leaq 0x8(%r15), %r13
movq 0x10(%r12), %rdx
cmpq 0x10(%r15), %rdx
jne 0x4c85d
testq %rdx, %rdx
je 0x4c861
movq (%r13), %rsi
movq (%r14), %rdi
callq 0x15220
testl %eax, %eax
sete %bl
jmp 0x4c863
xorl %ebx, %ebx
jmp 0x4c863
movb $0x1, %bl
movq %r15, %rax
testb %bl, %bl
je 0x4c89b
testb $0x1, %bpl
je 0x4c884
movq %r14, 0x8(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x4cee4
movq %r13, 0x8(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x4cee4
movq %r12, %rax
xorb $0x1, %bl
movq (%r15), %r15
movl %ebx, %ebp
movq %rax, %r12
testq %r15, %r15
jne 0x4c831
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/src/binding-hash.cc |
wabt::BindingHash::FindIndex(wabt::Var const&) const | Index BindingHash::FindIndex(const Var& var) const {
if (var.is_name()) {
return FindIndex(var.name());
}
return var.index();
} | pushq %rax
movl 0x20(%rsi), %eax
testl %eax, %eax
je 0x4cb12
cmpl $0x1, %eax
jne 0x4cb21
addq $0x28, %rsi
callq 0x24f6c
testq %rax, %rax
je 0x4cb1a
movq %rax, %rsi
addq $0x48, %rsi
jmp 0x4cb16
addq $0x28, %rsi
movl (%rsi), %eax
popq %rcx
retq
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0x4cb18
leaq 0xa7b4(%rip), %rdi # 0x572dc
leaq 0xa756(%rip), %rsi # 0x57285
leaq 0xa7b1(%rip), %rcx # 0x572e7
movl $0x3b, %edx
callq 0x15160
| /WebAssembly[P]wabt/src/binding-hash.cc |
wabt::Color::SupportsColor(_IO_FILE*) | bool Color::SupportsColor(FILE* file) {
char* force = getenv("FORCE_COLOR");
if (force) {
return atoi(force) != 0;
}
#if HAVE_WIN32_VT100
HANDLE handle;
if (file == stdout) {
handle = GetStdHandle(STD_OUTPUT_HANDLE);
} else if (file == stderr) {
handle = GetStdHandle(STD_ERROR_HANDLE);
} else {
return false;
}
DWORD mode;
if (!_isatty(_fileno(file)) || !GetConsoleMode(handle, &mode) ||
!SetConsoleMode(handle, mode | ENABLE_VIRTUAL_TERMINAL_PROCESSING)) {
return false;
}
return true;
// TODO(binji): Support older Windows by using SetConsoleTextAttribute?
#elif HAVE_UNISTD_H
return isatty(fileno(file));
#else
return false;
#endif
} | pushq %rbx
movq %rdi, %rbx
leaq 0x185a3(%rip), %rdi # 0x6561a
callq 0x15300
testq %rax, %rax
je 0x4d08b
movq %rax, %rdi
callq 0x153a0
jmp 0x4d09a
movq %rbx, %rdi
callq 0x15250
movl %eax, %edi
callq 0x153e0
testl %eax, %eax
setne %al
popq %rbx
retq
nop
| /WebAssembly[P]wabt/src/color.cc |
wabt::SharedValidator::SharedValidator(std::vector<wabt::Error, std::allocator<wabt::Error>>*, wabt::ValidateOptions const&) | SharedValidator::SharedValidator(Errors* errors, const ValidateOptions& options)
: options_(options), errors_(errors), typechecker_(options.features) {
typechecker_.set_error_callback(
[this](const char* msg) { OnTypecheckerError(msg); });
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl 0xf(%rdx), %eax
movl %eax, 0xf(%rdi)
movups (%rdx), %xmm0
movups %xmm0, (%rdi)
movq %rsi, 0x18(%rdi)
leaq 0x20(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
movups %xmm0, 0x60(%rdi)
xorps %xmm1, %xmm1
xorl %r15d, %r15d
movq %r15, 0x70(%rdi)
movups (%rdx), %xmm0
movups %xmm0, 0x78(%rdi)
movl 0xf(%rdx), %eax
movl %eax, 0x87(%rdi)
movups %xmm1, 0x90(%rdi)
movq $-0x1, 0xa0(%rdi)
movb $0x0, 0xb0(%rdi)
movl %r15d, 0xb4(%rdi)
leaq 0xc0(%rdi), %rax
movl %r15d, 0xc0(%rdi)
movq %r15, 0xc8(%rdi)
movq %rax, 0xd0(%rdi)
movq %rax, 0xd8(%rdi)
movq %r15, 0xe0(%rdi)
leaq 0xf0(%rdi), %rax
movl %r15d, 0xf0(%rdi)
movq %r15, 0xf8(%rdi)
movq %rax, 0x100(%rdi)
movq %rax, 0x108(%rdi)
movq %r15, 0x110(%rdi)
leaq 0x120(%rdi), %rax
movl %r15d, 0x120(%rdi)
movq %r15, 0x128(%rdi)
movq %rax, 0x130(%rdi)
movq %rax, 0x138(%rdi)
addq $0x140, %rdi # imm = 0x140
movq %r15, 0x1f8(%rbx)
movups %xmm1, 0x1e8(%rbx)
leaq 0x208(%rbx), %r12
movl %r15d, 0x208(%rbx)
movq %r15, 0x210(%rbx)
movl $0xa4, %edx
xorl %esi, %esi
callq 0x15140
movq %r12, 0x218(%rbx)
movq %r12, 0x220(%rbx)
movq %r15, 0x228(%rbx)
leaq 0x238(%rbx), %rax
movl %r15d, 0x238(%rbx)
movq %r15, 0x240(%rbx)
movq %rax, 0x248(%rbx)
movq %rax, 0x250(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x258(%rbx)
movups %xmm0, 0x268(%rbx)
movq %rsp, %r15
movaps %xmm0, (%r15)
movaps %xmm0, 0x10(%r15)
movq %rbx, (%r15)
leaq 0x49a7(%rip), %rax # 0x51c04
movq %rax, 0x18(%r15)
leaq 0x49b8(%rip), %rax # 0x51c20
movq %rax, 0x10(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x42f88
movq 0x10(%r15), %rax
testq %rax, %rax
je 0x4d28d
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnStructType(wabt::Location const&, unsigned int, wabt::TypeMut*) | Result SharedValidator::OnStructType(const Location&,
Index field_count,
TypeMut* fields) {
struct_types_.emplace(num_types_++, StructType{TypeMutVector(
&fields[0], &fields[field_count])});
return Result::Ok;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
leaq 0xe8(%rdi), %rbx
movl 0xb4(%rdi), %eax
leal 0x1(%rax), %esi
movl %esi, 0xb4(%rdi)
leaq 0xc(%rsp), %r14
movl %eax, (%r14)
movl %edx, %eax
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,4), %rdx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r15
movaps %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movq %r15, %rdi
movq %rcx, %rsi
callq 0x524ba
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x5221e
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x52564
movq (%r12), %rdi
testq %rdi, %rdi
je 0x4d594
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x4d5ab
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnFunction(wabt::Location const&, wabt::Var) | Result SharedValidator::OnFunction(const Location& loc, Var sig_var) {
Result result = Result::Ok;
FuncType type;
result |= CheckFuncTypeIndex(sig_var, &type);
funcs_.push_back(type);
return result;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %r14
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, 0x20(%r15)
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
leaq 0x40(%rsp), %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0x3e72c
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x4d69e
movl %eax, %ebx
movq %r12, %rdi
callq 0x3e814
addq $0x148, %r14 # imm = 0x148
movq %r14, %rdi
movq %r15, %rsi
callq 0x51c46
movq 0x18(%r15), %rdi
testq %rdi, %rdi
je 0x4d671
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4d687
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
xorl %eax, %eax
cmpl $0x1, %ebx
sete %al
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::CheckFuncTypeIndex(wabt::Var, wabt::SharedValidator::FuncType*) | Result SharedValidator::CheckFuncTypeIndex(Var sig_var, FuncType* out) {
Result result = CheckIndex(sig_var, num_types_, "function type");
if (Failed(result)) {
*out = FuncType{};
return Result::Error;
}
auto iter = func_types_.find(sig_var.index());
if (iter == func_types_.end()) {
return PrintError(sig_var.loc, "type %d is not a function",
sig_var.index());
}
if (out) {
*out = iter->second;
}
return Result::Ok;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x38(%rsp), %r12
movq %r12, %rdi
callq 0x3e72c
movl 0xb4(%r15), %edx
leaq 0x182fd(%rip), %rcx # 0x659ce
movq %r15, %rdi
movq %r12, %rsi
callq 0x4e5a6
movl %eax, %ebp
movq %r12, %rdi
callq 0x3e814
cmpl $0x1, %ebp
jne 0x4d759
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, (%rsi)
movq $0x0, 0x30(%rsi)
movq %rbx, %rdi
callq 0x224cc
leaq 0x18(%rbx), %rdi
leaq 0x18(%rsp), %r14
movq %r14, %rsi
callq 0x224cc
movl 0x18(%r14), %eax
movl %eax, 0x30(%rbx)
movq (%r14), %rdi
testq %rdi, %rdi
je 0x4d739
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4d74f
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
movl $0x1, %ebp
jmp 0x4d7f1
cmpl $0x0, 0x20(%r14)
jne 0x4d803
movl 0x28(%r14), %ecx
movq 0xc8(%r15), %rsi
leaq 0xc0(%r15), %rax
movq %rax, %rdx
testq %rsi, %rsi
je 0x4d798
movq %rax, %rdx
xorl %edi, %edi
cmpl %ecx, 0x20(%rsi)
setb %dil
cmovaeq %rsi, %rdx
movq 0x10(%rsi,%rdi,8), %rsi
testq %rsi, %rsi
jne 0x4d781
movq %rax, %r12
cmpq %rax, %rdx
je 0x4d7aa
cmpl 0x20(%rdx), %ecx
cmovbq %rax, %rdx
movq %rdx, %r12
cmpq %rax, %r12
je 0x4d7db
xorl %ebp, %ebp
testq %rbx, %rbx
je 0x4d7f1
leaq 0x28(%r12), %rsi
movq %rbx, %rdi
callq 0x20e42
leaq 0x18(%rbx), %rdi
leaq 0x40(%r12), %rsi
callq 0x20e42
movl 0x58(%r12), %eax
movl %eax, 0x30(%rbx)
jmp 0x4d7f1
leaq 0x181fa(%rip), %rdx # 0x659dc
movq %r15, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x4d29a
movl %eax, %ebp
movl %ebp, %eax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9ad2(%rip), %rdi # 0x572dc
leaq 0x9a74(%rip), %rsi # 0x57285
leaq 0x9acf(%rip), %rcx # 0x572e7
movl $0x3b, %edx
callq 0x15160
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::CheckLimits(wabt::Location const&, wabt::Limits const&, unsigned long, char const*) | Result SharedValidator::CheckLimits(const Location& loc,
const Limits& limits,
uint64_t absolute_max,
const char* desc) {
Result result = Result::Ok;
if (limits.initial > absolute_max) {
result |=
PrintError(loc, "initial %s (%" PRIu64 ") must be <= (%" PRIu64 ")",
desc, limits.initial, absolute_max);
}
if (limits.has_max) {
if (limits.max > absolute_max) {
result |= PrintError(loc, "max %s (%" PRIu64 ") must be <= (%" PRIu64 ")",
desc, limits.max, absolute_max);
}
if (limits.max < limits.initial) {
result |= PrintError(
loc, "max %s (%" PRIu64 ") must be >= initial %s (%" PRIu64 ")", desc,
limits.max, desc, limits.initial);
}
}
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movq (%rdx), %r8
xorl %ebp, %ebp
cmpq %rcx, %r8
jbe 0x4d869
leaq 0x17e8a(%rip), %rdx # 0x656d7
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
movq %r13, %r9
xorl %eax, %eax
callq 0x4d29a
xorl %ebp, %ebp
cmpl $0x1, %eax
sete %bpl
cmpb $0x1, 0x10(%r12)
jne 0x4d8d9
movq 0x8(%r12), %r8
cmpq %r13, %r8
jbe 0x4d8a1
leaq 0x17e77(%rip), %rdx # 0x656f9
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
movq %r13, %r9
xorl %eax, %eax
callq 0x4d29a
cmpl $0x1, %eax
sete %al
orb %bpl, %al
movzbl %al, %ebp
movq (%r12), %rax
movq 0x8(%r12), %r8
cmpq %rax, %r8
jae 0x4d8d9
movq %rax, (%rsp)
leaq 0x17e5d(%rip), %rdx # 0x65717
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
movq %rbx, %r9
xorl %eax, %eax
callq 0x4d29a
cmpl $0x1, %eax
sete %al
orb %bpl, %al
movzbl %al, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnTable(wabt::Location const&, wabt::Type, wabt::Limits const&) | Result SharedValidator::OnTable(const Location& loc,
Type elem_type,
const Limits& limits) {
Result result = Result::Ok;
if (tables_.size() > 0 && !options_.features.reference_types_enabled()) {
result |= PrintError(loc, "only one table allowed");
}
result |= CheckLimits(loc, limits, UINT32_MAX, "elems");
if (limits.is_shared) {
result |= PrintError(loc, "tables may not be shared");
}
if (elem_type != Type::FuncRef &&
!options_.features.reference_types_enabled()) {
result |= PrintError(loc, "tables must have funcref type");
}
if (!elem_type.IsRef()) {
result |= PrintError(loc, "tables must have reference types");
}
tables_.push_back(TableType{elem_type, limits});
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq 0x168(%rdi), %rax
cmpq 0x160(%rdi), %rax
je 0x4d91a
cmpb $0x0, 0xa(%rbx)
je 0x4d91f
xorl %r13d, %r13d
jmp 0x4d93a
leaq 0x17e1a(%rip), %rdx # 0x65740
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x4d29a
cmpl $0x1, %eax
sete %r13b
movl $0xfffffff0, %eax # imm = 0xFFFFFFF0
leaq 0xf(%rax), %rcx
leaq 0x17e0d(%rip), %r8 # 0x65757
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x4d822
cmpl $0x1, %eax
sete %bpl
orb %r13b, %bpl
cmpb $0x1, 0x11(%r15)
jne 0x4d986
leaq 0xddd4(%rip), %rdx # 0x5b744
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x4d29a
cmpl $0x1, %eax
sete %al
orb %al, %bpl
movl $0xfffffff0, %eax # imm = 0xFFFFFFF0
cmpl %eax, %r14d
je 0x4d9b3
cmpb $0x0, 0xa(%rbx)
jne 0x4d9b3
leaq 0x17dc0(%rip), %rdx # 0x6575d
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x4d29a
cmpl $0x1, %eax
sete %al
orb %al, %bpl
leal 0x17(%r14), %eax
cmpl $0x7, %eax
ja 0x4da2f
movl $0xc5, %ecx
btl %eax, %ecx
jae 0x4da2f
movq 0x10(%r15), %rax
movq %rax, 0x20(%rsp)
movups (%r15), %xmm0
movups %xmm0, 0x10(%rsp)
movq %r14, 0x8(%rsp)
movq 0x168(%rbx), %rsi
cmpq 0x170(%rbx), %rsi
je 0x4da08
movups 0x8(%rsp), %xmm0
movups 0x18(%rsp), %xmm1
movups %xmm1, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x20, 0x168(%rbx)
jmp 0x4da1c
addq $0x160, %rbx # imm = 0x160
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x529f2
movzbl %bpl, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x17d45(%rip), %rdx # 0x6577b
movq %rbx, %rdi
movq %r12, %rsi
xorl %eax, %eax
callq 0x4d29a
cmpl $0x1, %eax
sete %al
orb %al, %bpl
jmp 0x4d9c6
nop
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnMemory(wabt::Location const&, wabt::Limits const&, unsigned int) | Result SharedValidator::OnMemory(const Location& loc,
const Limits& limits,
uint32_t page_size) {
Result result = Result::Ok;
if (memories_.size() > 0 && !options_.features.multi_memory_enabled()) {
result |= PrintError(loc, "only one memory block allowed");
}
if (page_size != WABT_DEFAULT_PAGE_SIZE) {
if (!options_.features.custom_page_sizes_enabled()) {
result |= PrintError(loc, "only default page size (64 KiB) is allowed");
} else if (page_size != 1) {
result |= PrintError(loc, "only page sizes of 1 B or 64 KiB are allowed");
}
}
uint64_t absolute_max = WABT_BYTES_TO_MIN_PAGES(
(limits.is_64 ? UINT64_MAX : UINT32_MAX), page_size);
result |= CheckLimits(loc, limits, absolute_max, "pages");
if (limits.is_shared) {
if (!options_.features.threads_enabled()) {
result |= PrintError(loc, "memories may not be shared");
} else if (!limits.has_max) {
result |= PrintError(loc, "shared memories must have max sizes");
}
}
memories_.push_back(MemoryType{limits});
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %ecx, %r12d
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x180(%rdi), %rax
xorl %ebp, %ebp
cmpq 0x178(%rdi), %rax
je 0x4da9f
cmpb $0x0, 0xf(%rbx)
jne 0x4da9f
leaq 0x17d13(%rip), %rdx # 0x6579c
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x4d29a
xorl %ebp, %ebp
cmpl $0x1, %eax
sete %bpl
cmpl $0x10000, %r12d # imm = 0x10000
je 0x4dadd
cmpb $0x1, 0x12(%rbx)
jne 0x4dabd
cmpl $0x1, %r12d
je 0x4dadd
leaq 0x17d2a(%rip), %rdx # 0x657e5
jmp 0x4dac4
leaq 0x17cf6(%rip), %rdx # 0x657ba
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x4d29a
cmpl $0x1, %eax
sete %al
orb %bpl, %al
movzbl %al, %ebp
leal -0x1(%r12), %eax
movl %r12d, %ecx
xorl %eax, %ecx
cmpl %eax, %ecx
jbe 0x4dbcf
movzbl 0x12(%r14), %eax
negq %rax
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
orq %rax, %rsi
movl %r12d, %edi
movq %rsi, %rax
xorl %edx, %edx
divq %rdi
imulq %rax, %rdi
xorl %ecx, %ecx
cmpq %rsi, %rdi
setne %cl
addq %rax, %rcx
leaq 0x17cf2(%rip), %r8 # 0x65812
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4d822
cmpl $0x1, %eax
sete %r12b
orb %bpl, %r12b
cmpb $0x1, 0x11(%r14)
jne 0x4db72
cmpb $0x1, 0x5(%rbx)
jne 0x4db55
cmpb $0x0, 0x10(%r14)
jne 0x4db72
leaq 0x17ce0(%rip), %rdx # 0x65833
jmp 0x4db5c
leaq 0x17cbc(%rip), %rdx # 0x65818
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x4d29a
cmpl $0x1, %eax
sete %al
orb %al, %r12b
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movaps %xmm0, (%rsp)
movq 0x180(%rbx), %rsi
cmpq 0x188(%rbx), %rsi
je 0x4dbac
movups (%r14), %xmm0
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsi)
movups %xmm0, (%rsi)
addq $0x18, 0x180(%rbx)
jmp 0x4dbbe
addq $0x178, %rbx # imm = 0x178
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x52b50
movzbl %r12b, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x15150
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnGlobalImport(wabt::Location const&, wabt::Type, bool) | Result SharedValidator::OnGlobalImport(const Location& loc,
Type type,
bool mutable_) {
Result result = Result::Ok;
if (mutable_ && !options_.features.mutable_globals_enabled()) {
result |= PrintError(loc, "mutable globals cannot be imported");
}
globals_.push_back(GlobalType{type, mutable_});
++num_imported_globals_;
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r14d
movq %rdx, %r15
movq %rdi, %rbx
xorl %ebp, %ebp
testl %ecx, %ecx
je 0x4dc0d
cmpb $0x0, 0x1(%rbx)
jne 0x4dc0d
leaq 0x17c5d(%rip), %rdx # 0x65857
movq %rbx, %rdi
xorl %eax, %eax
callq 0x4d29a
xorl %ebp, %ebp
cmpl $0x1, %eax
sete %bpl
movq %r15, 0x8(%rsp)
movb %r14b, 0x10(%rsp)
movq 0x198(%rbx), %rsi
cmpq 0x1a0(%rbx), %rsi
je 0x4dc40
movl 0x10(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0xc, 0x198(%rbx)
jmp 0x4dc51
leaq 0x190(%rbx), %rdi
leaq 0x8(%rsp), %rdx
callq 0x52ce6
incl 0x1dc(%rbx)
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnGlobal(wabt::Location const&, wabt::Type, bool) | Result SharedValidator::OnGlobal(const Location& loc,
Type type,
bool mutable_) {
globals_.push_back(GlobalType{type, mutable_});
return Result::Ok;
} | subq $0x18, %rsp
movq %rdx, 0x8(%rsp)
movb %cl, 0x10(%rsp)
movq 0x198(%rdi), %rsi
cmpq 0x1a0(%rdi), %rsi
je 0x4dc9a
movl 0x10(%rsp), %eax
movl %eax, 0x8(%rsi)
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0xc, 0x198(%rdi)
jmp 0x4dcab
addq $0x190, %rdi # imm = 0x190
leaq 0x8(%rsp), %rdx
callq 0x52ce6
xorl %eax, %eax
addq $0x18, %rsp
retq
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::CheckType(wabt::Location const&, wabt::Type, wabt::Type, char const*) | Result SharedValidator::CheckType(const Location& loc,
Type actual,
Type expected,
const char* desc) {
if (Failed(TypeChecker::CheckType(actual, expected))) {
PrintError(loc, "type mismatch at %s. got %s, expected %s", desc,
actual.GetName().c_str(), expected.GetName().c_str());
return Result::Error;
}
return Result::Ok;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %r8, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, 0x8(%rsp)
movq %rcx, (%rsp)
movq %rdx, %rdi
movq %rcx, %rsi
callq 0x53cd0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
jne 0x4dd64
leaq 0x30(%rsp), %r12
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
callq 0x2df88
movq (%r12), %r12
leaq 0x10(%rsp), %r13
movq %rsp, %rsi
movq %r13, %rdi
callq 0x2df88
movq (%r13), %r9
leaq 0x17b64(%rip), %rdx # 0x6587a
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rcx
movq %r12, %r8
xorl %eax, %eax
callq 0x4d29a
movq (%r13), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x4dd44
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x15200
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4dd5f
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x15200
movl $0x1, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnTag(wabt::Location const&, wabt::Var) | Result SharedValidator::OnTag(const Location& loc, Var sig_var) {
Result result = Result::Ok;
FuncType type;
result |= CheckFuncTypeIndex(sig_var, &type);
if (!type.results.empty()) {
result |= PrintError(loc, "Tag signature must have 0 results.");
}
tags_.push_back(TagType{type.params});
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, 0x20(%r15)
movaps %xmm0, 0x10(%r15)
movaps %xmm0, (%r15)
leaq 0x50(%rsp), %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0x3e72c
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x4d69e
movl %eax, %ebp
cmpl $0x1, %eax
sete %r13b
movq %r12, %rdi
callq 0x3e814
movq 0x18(%r15), %rax
cmpq 0x20(%r15), %rax
je 0x4ddfb
cmpl $0x1, %ebp
sete %bpl
leaq 0x17abf(%rip), %rdx # 0x658a3
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x4d29a
cmpl $0x1, %eax
sete %r13b
orb %bpl, %r13b
addq $0x1a8, %rbx # imm = 0x1A8
leaq 0x38(%rsp), %r14
movq %rsp, %rsi
movq %r14, %rdi
callq 0x238fe
movq %rbx, %rdi
movq %r14, %rsi
callq 0x52e76
movq (%r14), %rdi
testq %rdi, %rdi
je 0x4de32
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x4de49
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4de5f
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
movzbl %r13b, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnExport(wabt::Location const&, wabt::ExternalKind, wabt::Var, std::basic_string_view<char, std::char_traits<char>>) | Result SharedValidator::OnExport(const Location& loc,
ExternalKind kind,
Var item_var,
std::string_view name) {
Result result = Result::Ok;
auto name_str = std::string(name);
if (export_names_.find(name_str) != export_names_.end()) {
result |= PrintError(loc, "duplicate export \"" PRIstringview "\"",
WABT_PRINTF_STRING_VIEW_ARG(name));
}
export_names_.insert(name_str);
switch (kind) {
case ExternalKind::Func:
result |= CheckFuncIndex(item_var);
declared_funcs_.insert(item_var.index());
break;
case ExternalKind::Table:
result |= CheckTableIndex(item_var);
break;
case ExternalKind::Memory:
result |= CheckMemoryIndex(item_var);
break;
case ExternalKind::Global:
result |= CheckGlobalIndex(item_var);
break;
case ExternalKind::Tag:
result |= CheckTagIndex(item_var);
break;
}
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %r9, %rbx
movq %r8, %r13
movq %rcx, 0x8(%rsp)
movl %edx, %ebp
movq %rsi, 0x30(%rsp)
movq %rdi, %r14
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
leaq (%r9,%r8), %rdx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r9, %rsi
callq 0x16a80
leaq 0x200(%r14), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x5308e
leaq 0x208(%r14), %rcx
cmpq %rcx, %rax
je 0x4defd
leaq 0x179e8(%rip), %rdx # 0x658c6
movq %r14, %rdi
movq 0x30(%rsp), %rsi
movl %r13d, %ecx
movq %rbx, %r8
xorl %eax, %eax
callq 0x4d29a
xorl %ebx, %ebx
cmpl $0x1, %eax
sete %bl
jmp 0x4deff
xorl %ebx, %ebx
leaq 0x10(%rsp), %rsi
movq %r12, %rdi
callq 0x530f6
cmpl $0x4, %ebp
ja 0x4e02e
movq %r14, %r15
movl %ebp, %eax
leaq 0x17707(%rip), %rcx # 0x65628
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x160(%rsp), %r14
movq %r14, %rdi
movq 0x8(%rsp), %r12
movq %r12, %rsi
callq 0x3e72c
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x4e07e
movl %eax, %ebp
movq %r14, %rdi
callq 0x3e814
cmpl $0x0, 0x20(%r12)
jne 0x4e05e
addq $0x230, %r15 # imm = 0x230
cmpl $0x1, %ebp
sete %al
orb %bl, %al
movzbl %al, %ebx
movl 0x28(%r12), %eax
leaq 0x3c(%rsp), %rsi
movl %eax, (%rsi)
movq %r15, %rdi
callq 0x53240
jmp 0x4e02e
leaq 0x40(%rsp), %r14
movq %r14, %rdi
movq 0x8(%rsp), %rsi
callq 0x3e72c
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x4e1b6
jmp 0x4e01b
leaq 0xd0(%rsp), %r14
movq %r14, %rdi
movq 0x8(%rsp), %rsi
callq 0x3e72c
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x4e11a
jmp 0x4e01b
leaq 0x88(%rsp), %r14
movq %r14, %rdi
movq 0x8(%rsp), %rsi
callq 0x3e72c
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x4e168
jmp 0x4e01b
leaq 0x118(%rsp), %r14
movq %r14, %rdi
movq 0x8(%rsp), %rsi
callq 0x3e72c
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x4e0cc
cmpl $0x1, %eax
sete %al
orb %bl, %al
movzbl %al, %ebx
movq %r14, %rdi
callq 0x3e814
leaq 0x20(%rsp), %rax
movq 0x10(%rsp), %rdi
cmpq %rax, %rdi
je 0x4e04a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x15200
movl %ebx, %eax
addq $0x1a8, %rsp # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9277(%rip), %rdi # 0x572dc
leaq 0x9219(%rip), %rsi # 0x57285
leaq 0x9274(%rip), %rcx # 0x572e7
movl $0x3b, %edx
callq 0x15160
nop
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnStart(wabt::Location const&, wabt::Var) | Result SharedValidator::OnStart(const Location& loc, Var func_var) {
Result result = Result::Ok;
if (starts_++ > 0) {
result |= PrintError(loc, "only one start function allowed");
}
FuncType func_type;
result |= CheckFuncIndex(func_var, &func_type);
if (func_type.params.size() != 0) {
result |= PrintError(loc, "start function must be nullary");
}
if (func_type.results.size() != 0) {
result |= PrintError(loc, "start function must not return anything");
}
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %r15
movq %rdi, %r14
movl 0x1d8(%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x1d8(%rdi)
testl %eax, %eax
movq %rsi, 0x8(%rsp)
je 0x4e24c
leaq 0x176a4(%rip), %rdx # 0x658de
movq %r14, %rdi
xorl %eax, %eax
callq 0x4d29a
cmpl $0x1, %eax
sete %bl
jmp 0x4e24e
xorl %ebx, %ebx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r12
movaps %xmm0, 0x20(%r12)
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
leaq 0x50(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x3e72c
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x4e07e
cmpl $0x1, %eax
sete %bpl
orb %bl, %bpl
movq %r13, %rdi
callq 0x3e814
movq 0x8(%r12), %rax
cmpq (%r12), %rax
je 0x4e2c6
leaq 0x17655(%rip), %rdx # 0x658fe
movq %r14, %rdi
movq 0x8(%rsp), %rbx
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4d29a
cmpl $0x1, %eax
sete %al
orb %al, %bpl
jmp 0x4e2cb
movq 0x8(%rsp), %rbx
movq 0x30(%rsp), %rax
cmpq 0x28(%rsp), %rax
je 0x4e2f4
leaq 0x1763f(%rip), %rdx # 0x6591d
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4d29a
cmpl $0x1, %eax
sete %al
orb %al, %bpl
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x4e30b
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x4e322
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
movzbl %bpl, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnElemSegment(wabt::Location const&, wabt::Var, wabt::SegmentKind) | Result SharedValidator::OnElemSegment(const Location& loc,
Var table_var,
SegmentKind kind) {
Result result = Result::Ok;
TableType table_type;
if (kind == SegmentKind::Active) {
result |= CheckTableIndex(table_var, &table_type);
}
// Type gets set later in OnElemSegmentElemType.
elems_.push_back(
ElemType{Type::Void, kind == SegmentKind::Active, table_type.element});
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movl %ecx, %r14d
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x2b(%rsp)
movaps %xmm0, 0x20(%rsp)
xorl %ebp, %ebp
testl %ecx, %ecx
jne 0x4e38f
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x3e72c
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4e0cc
xorl %ebp, %ebp
cmpl $0x1, %eax
sete %bpl
movq %r15, %rdi
callq 0x3e814
testl %r14d, %r14d
movq 0x20(%rsp), %rax
movl $0xffffffc0, %ecx # imm = 0xFFFFFFC0
movq %rcx, 0x8(%rsp)
sete 0x10(%rsp)
movq %rax, 0x14(%rsp)
movq 0x1c8(%rbx), %rsi
cmpq 0x1d0(%rbx), %rsi
je 0x4e3d4
movl 0x18(%rsp), %eax
movl %eax, 0x10(%rsi)
movups 0x8(%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x14, 0x1c8(%rbx)
jmp 0x4e3e8
addq $0x1c0, %rbx # imm = 0x1C0
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x532ea
movl %ebp, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnElemSegmentElemType(wabt::Location const&, wabt::Type) | Result SharedValidator::OnElemSegmentElemType(const Location& loc,
Type elem_type) {
Result result = Result::Ok;
auto& elem = elems_.back();
if (elem.is_active) {
// Check that the type of the elem segment matches the table in which
// it is active.
result |= CheckType(loc, elem_type, elem.table_type, "elem segment");
}
elem.element = elem_type;
return result;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq 0x1c8(%rdi), %r14
xorl %eax, %eax
cmpb $0x1, -0xc(%r14)
jne 0x4e42c
movq -0x8(%r14), %rcx
leaq 0x1752b(%rip), %r8 # 0x65945
movq %rbx, %rdx
callq 0x4dcb2
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
sete %al
movq %rbx, -0x14(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::CheckDeclaredFunc(wabt::Var) | Result SharedValidator::CheckDeclaredFunc(Var func_var) {
if (declared_funcs_.count(func_var.index()) == 0) {
return PrintError(func_var.loc,
"function %" PRIindex
" is not declared in any elem sections",
func_var.index());
}
return Result::Ok;
} | pushq %rax
cmpl $0x0, 0x20(%rsi)
jne 0x4e4f3
movl 0x28(%rsi), %ecx
movq 0x240(%rdi), %r8
leaq 0x238(%rdi), %rax
movq %rax, %rdx
testq %r8, %r8
je 0x4e4c8
movq %rax, %rdx
xorl %r9d, %r9d
cmpl %ecx, 0x20(%r8)
setb %r9b
cmovaeq %r8, %rdx
movq 0x10(%r8,%r9,8), %r8
testq %r8, %r8
jne 0x4e4af
movq %rax, %r8
cmpq %rax, %rdx
je 0x4e4da
cmpl 0x20(%rdx), %ecx
cmovbq %rax, %rdx
movq %rdx, %r8
cmpq %rax, %r8
je 0x4e4e3
xorl %eax, %eax
popq %rcx
retq
leaq 0x17468(%rip), %rdx # 0x65952
xorl %eax, %eax
popq %r8
jmp 0x4d29a
leaq 0x8de2(%rip), %rdi # 0x572dc
leaq 0x8d84(%rip), %rsi # 0x57285
leaq 0x8ddf(%rip), %rcx # 0x572e7
movl $0x3b, %edx
callq 0x15160
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::EndModule() | Result SharedValidator::OnRethrow(const Location& loc, Var depth) {
Result result = CheckInstr(Opcode::Rethrow, loc);
result |= typechecker_.OnRethrow(depth.index());
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq 0x260(%rdi), %r14
movq 0x268(%rdi), %r13
cmpq %r13, %r14
je 0x4e591
movq %rdi, %rbx
xorl %ebp, %ebp
leaq 0x50(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x3e72c
movq %r12, %rdi
movq %r15, %rsi
callq 0x3e72c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4e48c
cmpl $0x1, %eax
sete %al
orb %al, %bpl
movq %r12, %rdi
callq 0x3e814
movq %r15, %rdi
callq 0x3e814
addq $0x48, %r14
cmpq %r13, %r14
jne 0x4e545
movzbl %bpl, %eax
andl $0x1, %eax
jmp 0x4e593
xorl %eax, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::CheckIndex(wabt::Var, unsigned int, char const*) | Index index() const {
assert(is_index());
return index_;
} | cmpl $0x0, 0x20(%rsi)
jne 0x4e5c9
movl %edx, %r9d
movl 0x28(%rsi), %r8d
cmpl %edx, %r8d
jae 0x4e5bb
xorl %eax, %eax
retq
leaq 0x173c1(%rip), %rdx # 0x65983
xorl %eax, %eax
jmp 0x4d29a
pushq %rax
leaq 0x8d0b(%rip), %rdi # 0x572dc
leaq 0x8cad(%rip), %rsi # 0x57285
leaq 0x8d08(%rip), %rcx # 0x572e7
movl $0x3b, %edx
callq 0x15160
nop
| /WebAssembly[P]wabt/include/wabt/ir.h |
wabt::SharedValidator::CheckBlockSignature(wabt::Location const&, wabt::Opcode, wabt::Type, std::vector<wabt::Type, std::allocator<wabt::Type>>*, std::vector<wabt::Type, std::allocator<wabt::Type>>*) | Result SharedValidator::CheckBlockSignature(const Location& loc,
Opcode opcode,
Type sig_type,
TypeVector* out_param_types,
TypeVector* out_result_types) {
Result result = Result::Ok;
if (sig_type.IsIndex()) {
Index sig_index = sig_type.GetIndex();
FuncType func_type;
result |= CheckFuncTypeIndex(Var(sig_index, loc), &func_type);
if (!func_type.params.empty() && !options_.features.multi_value_enabled()) {
result |= PrintError(loc, "%s params not currently supported.",
opcode.GetName());
}
// Multiple results without --enable-multi-value is checked above in
// OnType.
*out_param_types = func_type.params;
*out_result_types = func_type.results;
} else {
out_param_types->clear();
*out_result_types = sig_type.GetInlineVector();
}
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %r9, %r13
movq %r8, %r14
movl %edx, 0xc(%rsp)
movq %rcx, 0x18(%rsp)
testl %ecx, %ecx
js 0x4e83d
movq %rsi, %r15
movq %rdi, %r12
movq %r13, 0x10(%rsp)
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r13
movaps %xmm0, 0x20(%r13)
movaps %xmm0, 0x10(%r13)
movaps %xmm0, (%r13)
leaq 0xa0(%rsp), %rbx
movq %rbx, %rdi
movl %ecx, %esi
movq %r15, %rdx
callq 0x3e686
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x4d69e
movl %eax, %ebp
cmpl $0x1, %eax
sete 0xb(%rsp)
movq %rbx, %rdi
callq 0x3e814
movq (%r13), %rax
cmpq 0x8(%r13), %rax
je 0x4e880
cmpb $0x0, 0x7(%r12)
movq 0x10(%rsp), %r13
jne 0x4e885
cmpl $0x1, %ebp
sete %bpl
leaq 0x58(%rsp), %rbx
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x41380
movq (%rbx), %rcx
leaq 0x171ef(%rip), %rdx # 0x65a10
movq %r12, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x4d29a
cmpl $0x1, %eax
sete %al
orb %bpl, %al
movb %al, 0xb(%rsp)
jmp 0x4e885
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x4e84a
movq %rax, 0x8(%r14)
leaq 0x58(%rsp), %rbx
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x2242e
movq %r13, %rdi
movq %rbx, %rsi
callq 0x224cc
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4e87c
movq 0x68(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
xorl %eax, %eax
jmp 0x4e8d3
movq 0x10(%rsp), %r13
leaq 0x20(%rsp), %rsi
movq %r14, %rdi
callq 0x20e42
leaq 0x38(%rsp), %rbx
movq %r13, %rdi
movq %rbx, %rsi
callq 0x20e42
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4e8b7
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x4e8ce
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
movzbl 0xb(%rsp), %eax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::BeginFunctionBody(wabt::Location const&, unsigned int) | Result SharedValidator::BeginFunctionBody(const Location& loc,
Index func_index) {
expr_loc_ = loc;
locals_.clear();
if (func_index < funcs_.size()) {
for (Type type : funcs_[func_index].params) {
// TODO: Coalesce parameters of the same type?
locals_.push_back(LocalDecl{type, GetLocalCount() + 1});
}
return typechecker_.BeginFunction(funcs_[func_index].results);
} else {
// Signature isn't available, use empty.
return typechecker_.BeginFunction(TypeVector());
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups %xmm1, 0xa0(%rdi)
movups %xmm0, 0x90(%rdi)
movq 0x1e8(%rdi), %rax
cmpq %rax, 0x1f0(%rdi)
je 0x4e9af
movq %rax, 0x1f0(%rbx)
movl %edx, %eax
movq 0x148(%rbx), %rcx
movq 0x150(%rbx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
movabsq $0x6db6db6db6db6db7, %rsi # imm = 0x6DB6DB6DB6DB6DB7
imulq %rdx, %rsi
cmpq %rax, %rsi
jbe 0x4ea7c
imulq $0x38, %rax, %r12
movq (%rcx,%r12), %r13
movq 0x8(%rcx,%r12), %rbp
cmpq %rbp, %r13
je 0x4ea5d
leaq 0x1e8(%rbx), %r14
movq %rsp, %r15
movq (%r13), %rax
movq %rax, (%rsp)
movq 0x1f0(%rbx), %rax
cmpq %rax, 0x1e8(%rbx)
je 0x4ea18
movl -0x4(%rax), %eax
incl %eax
jmp 0x4ea1d
movl $0x1, %eax
movl %eax, 0x8(%rsp)
movq 0x1f0(%rbx), %rsi
cmpq 0x1f8(%rbx), %rsi
je 0x4ea49
movl 0x8(%rsp), %eax
movl %eax, 0x8(%rsi)
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0xc, 0x1f0(%rbx)
jmp 0x4ea54
movq %r14, %rdi
movq %r15, %rdx
callq 0x53460
addq $0x8, %r13
cmpq %rbp, %r13
jne 0x4e9f9
movq 0x148(%rbx), %rax
addq $0x20, %rbx
leaq (%rax,%r12), %rsi
addq $0x18, %rsi
movq %rbx, %rdi
callq 0x548fc
movl %eax, %ebx
jmp 0x4eab4
addq $0x20, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x548fc
movl %eax, %ebx
movq (%r14), %rdi
testq %rdi, %rdi
je 0x4eab4
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::CheckAtomicAlign(wabt::Location const&, unsigned long, unsigned long) | Result SharedValidator::CheckAtomicAlign(const Location& loc,
Address alignment,
Address natural_alignment) {
if (!is_power_of_two(alignment)) {
PrintError(loc, "alignment (%" PRIaddress ") must be a power of 2",
alignment);
return Result::Error;
}
if (alignment != natural_alignment) {
PrintError(loc,
"alignment must be equal to natural alignment (%" PRIaddress ")",
natural_alignment);
return Result::Error;
}
return Result::Ok;
} | pushq %rax
movq %rdx, %r8
leal -0x1(%rdx), %eax
xorl %eax, %edx
cmpl %eax, %edx
jbe 0x4ebf7
xorl %eax, %eax
cmpq %rcx, %r8
je 0x4ec0d
leaq 0x16fa5(%rip), %rdx # 0x65b9a
jmp 0x4ec01
leaq 0x16f0d(%rip), %rdx # 0x65b0b
movq %r8, %rcx
xorl %eax, %eax
callq 0x4d29a
movl $0x1, %eax
popq %rcx
retq
nop
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::ValidInitOpcode(wabt::Opcode) const | bool SharedValidator::ValidInitOpcode(Opcode opcode) const {
if (opcode == Opcode::GlobalGet || opcode == Opcode::I32Const ||
opcode == Opcode::I64Const || opcode == Opcode::F32Const ||
opcode == Opcode::F64Const || opcode == Opcode::RefFunc ||
opcode == Opcode::RefNull) {
return true;
}
if (options_.features.extended_const_enabled()) {
if (opcode == Opcode::I32Mul || opcode == Opcode::I64Mul ||
opcode == Opcode::I32Sub || opcode == Opcode::I64Sub ||
opcode == Opcode::I32Add || opcode == Opcode::I64Add) {
return true;
}
}
return false;
} | movb $0x1, %al
cmpl $0x3c, %esi
ja 0x4ec2c
movl %esi, %ecx
movabsq $0x1e00000040000000, %rdx # imm = 0x1E00000040000000
btq %rcx, %rdx
jae 0x4ec2c
andb $0x1, %al
retq
cmpl $0xdb, %esi
je 0x4ec29
cmpl $0xdd, %esi
je 0x4ec29
cmpb $0x1, 0x10(%rdi)
jne 0x4ec55
addl $-0x62, %esi
cmpl $0x14, %esi
ja 0x4ec55
movl $0x1c0007, %eax # imm = 0x1C0007
movl %esi, %ecx
shrl %cl, %eax
jmp 0x4ec29
xorl %eax, %eax
jmp 0x4ec29
nop
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::CheckInstr(wabt::Opcode, wabt::Location const&) | Result SharedValidator::CheckInstr(Opcode opcode, const Location& loc) {
expr_loc_ = loc;
if (in_init_expr_ && !ValidInitOpcode(opcode)) {
PrintError(loc,
"invalid initializer: instruction not valid in initializer "
"expression: %s",
opcode.GetName());
return Result::Error;
}
return Result::Ok;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movl %esi, 0xc(%rsp)
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups %xmm1, 0xa0(%rdi)
movups %xmm0, 0x90(%rdi)
xorl %ebp, %ebp
cmpb $0x1, 0xb0(%rdi)
jne 0x4ecc5
movq %rdx, %rbx
movq %rdi, %r14
callq 0x4ec10
testb %al, %al
jne 0x4ecc5
leaq 0x10(%rsp), %r15
leaq 0xc(%rsp), %rsi
movq %r15, %rdi
callq 0x41380
movq (%r15), %rcx
leaq 0x16f1a(%rip), %rdx # 0x65bcd
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x4d29a
movl $0x1, %ebp
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnAtomicFence(wabt::Location const&, unsigned int) | Result SharedValidator::OnAtomicFence(const Location& loc,
uint32_t consistency_model) {
Result result = CheckInstr(Opcode::AtomicFence, loc);
if (consistency_model != 0) {
result |= PrintError(
loc, "unexpected atomic.fence consistency model (expected 0): %u",
consistency_model);
}
result |= typechecker_.OnAtomicFence(consistency_model);
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movl $0x1e1, %esi # imm = 0x1E1
movq %r15, %rdx
callq 0x4ec5a
movl %eax, %ebp
testl %ebx, %ebx
je 0x4ed1b
leaq 0x16f1b(%rip), %rdx # 0x65c16
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %ecx
xorl %eax, %eax
callq 0x4d29a
cmpl $0x1, %ebp
sete %cl
cmpl $0x1, %eax
sete %al
orb %cl, %al
movzbl %al, %ebp
addq $0x20, %r14
movq %r14, %rdi
movl %ebx, %esi
callq 0x549c6
cmpl $0x1, %ebp
sete %cl
cmpl $0x1, %eax
sete %al
orb %cl, %al
movzbl %al, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnAtomicLoad(wabt::Location const&, wabt::Opcode, wabt::Var, unsigned long, unsigned long) | Result SharedValidator::OnAtomicLoad(const Location& loc,
Opcode opcode,
Var memidx,
Address alignment,
Address offset) {
Result result = CheckInstr(opcode, loc);
MemoryType mt;
result |= CheckMemoryIndex(memidx, &mt);
result |= CheckAtomicAlign(loc, alignment, opcode.GetMemorySize());
result |= CheckOffset(loc, offset, mt.limits);
result |= typechecker_.OnAtomicLoad(opcode, mt.limits);
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %r9, %r15
movq %r8, 0x8(%rsp)
movq %rcx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rax
movl %edx, (%rax)
movl %edx, %esi
movq %r14, %rdx
callq 0x4ec5a
movl %eax, 0x4(%rsp)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rbp
movaps %xmm0, (%rbp)
movl $0x0, 0xf(%rbp)
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x3e72c
movq %rbx, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x4e11a
movl %eax, %r13d
movq %r12, %rdi
callq 0x3e814
leaq 0x70(%rsp), %r12
movq %r12, %rdi
movq %rsp, %rsi
callq 0x41380
movq 0x30(%r12), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq 0x8(%rsp), %rdx
callq 0x4ebda
movl %eax, %r12d
shrq $0x20, %r15
sete %r15b
orb 0x12(%rbp), %r15b
jne 0x4ee01
leaq 0x16d76(%rip), %rdx # 0x65b6a
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x4d29a
xorb $0x1, %r15b
cmpl $0x1, 0x4(%rsp)
sete %al
cmpl $0x1, %r13d
sete %cl
orb %al, %cl
cmpl $0x1, %r12d
sete %bpl
orb %cl, %bpl
orb %r15b, %bpl
addq $0x20, %rbx
movl (%rsp), %esi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x549a0
cmpl $0x1, %eax
sete %al
orb %bpl, %al
movzbl %al, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnAtomicNotify(wabt::Location const&, wabt::Opcode, wabt::Var, unsigned long, unsigned long) | Result SharedValidator::OnAtomicNotify(const Location& loc,
Opcode opcode,
Var memidx,
Address alignment,
Address offset) {
Result result = CheckInstr(opcode, loc);
MemoryType mt;
result |= CheckMemoryIndex(memidx, &mt);
result |= CheckAtomicAlign(loc, alignment, opcode.GetMemorySize());
result |= CheckOffset(loc, offset, mt.limits);
result |= typechecker_.OnAtomicNotify(opcode, mt.limits);
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %r9, %r15
movq %r8, 0x8(%rsp)
movq %rcx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rax
movl %edx, (%rax)
movl %edx, %esi
movq %r14, %rdx
callq 0x4ec5a
movl %eax, 0x4(%rsp)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rbp
movaps %xmm0, (%rbp)
movl $0x0, 0xf(%rbp)
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x3e72c
movq %rbx, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x4e11a
movl %eax, %r13d
movq %r12, %rdi
callq 0x3e814
leaq 0x70(%rsp), %r12
movq %r12, %rdi
movq %rsp, %rsi
callq 0x41380
movq 0x30(%r12), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq 0x8(%rsp), %rdx
callq 0x4ebda
movl %eax, %r12d
shrq $0x20, %r15
sete %r15b
orb 0x12(%rbp), %r15b
jne 0x4ef11
leaq 0x16c66(%rip), %rdx # 0x65b6a
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x4d29a
xorb $0x1, %r15b
cmpl $0x1, 0x4(%rsp)
sete %al
cmpl $0x1, %r13d
sete %cl
orb %al, %cl
cmpl $0x1, %r12d
sete %bpl
orb %cl, %bpl
orb %r15b, %bpl
addq $0x20, %rbx
movl (%rsp), %esi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x549ca
cmpl $0x1, %eax
sete %al
orb %bpl, %al
movzbl %al, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnAtomicRmwCmpxchg(wabt::Location const&, wabt::Opcode, wabt::Var, unsigned long, unsigned long) | Result SharedValidator::OnAtomicRmwCmpxchg(const Location& loc,
Opcode opcode,
Var memidx,
Address alignment,
Address offset) {
Result result = CheckInstr(opcode, loc);
MemoryType mt;
result |= CheckMemoryIndex(memidx, &mt);
result |= CheckAtomicAlign(loc, alignment, opcode.GetMemorySize());
result |= CheckOffset(loc, offset, mt.limits);
result |= typechecker_.OnAtomicRmwCmpxchg(opcode, mt.limits);
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %r9, %r15
movq %r8, 0x8(%rsp)
movq %rcx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rax
movl %edx, (%rax)
movl %edx, %esi
movq %r14, %rdx
callq 0x4ec5a
movl %eax, 0x4(%rsp)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rbp
movaps %xmm0, (%rbp)
movl $0x0, 0xf(%rbp)
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x3e72c
movq %rbx, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x4e11a
movl %eax, %r13d
movq %r12, %rdi
callq 0x3e814
leaq 0x70(%rsp), %r12
movq %r12, %rdi
movq %rsp, %rsi
callq 0x41380
movq 0x30(%r12), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq 0x8(%rsp), %rdx
callq 0x4ebda
movl %eax, %r12d
shrq $0x20, %r15
sete %r15b
orb 0x12(%rbp), %r15b
jne 0x4f021
leaq 0x16b56(%rip), %rdx # 0x65b6a
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x4d29a
xorb $0x1, %r15b
cmpl $0x1, 0x4(%rsp)
sete %al
cmpl $0x1, %r13d
sete %cl
orb %al, %cl
cmpl $0x1, %r12d
sete %bpl
orb %cl, %bpl
orb %r15b, %bpl
addq $0x20, %rbx
movl (%rsp), %esi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x549b2
cmpl $0x1, %eax
sete %al
orb %bpl, %al
movzbl %al, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnAtomicRmw(wabt::Location const&, wabt::Opcode, wabt::Var, unsigned long, unsigned long) | Result SharedValidator::OnAtomicRmw(const Location& loc,
Opcode opcode,
Var memidx,
Address alignment,
Address offset) {
Result result = CheckInstr(opcode, loc);
MemoryType mt;
result |= CheckMemoryIndex(memidx, &mt);
result |= CheckAtomicAlign(loc, alignment, opcode.GetMemorySize());
result |= CheckOffset(loc, offset, mt.limits);
result |= typechecker_.OnAtomicRmw(opcode, mt.limits);
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %r9, %r15
movq %r8, 0x8(%rsp)
movq %rcx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rax
movl %edx, (%rax)
movl %edx, %esi
movq %r14, %rdx
callq 0x4ec5a
movl %eax, 0x4(%rsp)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rbp
movaps %xmm0, (%rbp)
movl $0x0, 0xf(%rbp)
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x3e72c
movq %rbx, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x4e11a
movl %eax, %r13d
movq %r12, %rdi
callq 0x3e814
leaq 0x70(%rsp), %r12
movq %r12, %rdi
movq %rsp, %rsi
callq 0x41380
movq 0x30(%r12), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq 0x8(%rsp), %rdx
callq 0x4ebda
movl %eax, %r12d
shrq $0x20, %r15
sete %r15b
orb 0x12(%rbp), %r15b
jne 0x4f131
leaq 0x16a46(%rip), %rdx # 0x65b6a
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x4d29a
xorb $0x1, %r15b
cmpl $0x1, 0x4(%rsp)
sete %al
cmpl $0x1, %r13d
sete %cl
orb %al, %cl
cmpl $0x1, %r12d
sete %bpl
orb %cl, %bpl
orb %r15b, %bpl
addq $0x20, %rbx
movl (%rsp), %esi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x549ac
cmpl $0x1, %eax
sete %al
orb %bpl, %al
movzbl %al, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnAtomicStore(wabt::Location const&, wabt::Opcode, wabt::Var, unsigned long, unsigned long) | Result SharedValidator::OnAtomicStore(const Location& loc,
Opcode opcode,
Var memidx,
Address alignment,
Address offset) {
Result result = CheckInstr(opcode, loc);
MemoryType mt;
result |= CheckMemoryIndex(memidx, &mt);
result |= CheckAtomicAlign(loc, alignment, opcode.GetMemorySize());
result |= CheckOffset(loc, offset, mt.limits);
result |= typechecker_.OnAtomicStore(opcode, mt.limits);
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %r9, %r15
movq %r8, 0x8(%rsp)
movq %rcx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rax
movl %edx, (%rax)
movl %edx, %esi
movq %r14, %rdx
callq 0x4ec5a
movl %eax, 0x4(%rsp)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rbp
movaps %xmm0, (%rbp)
movl $0x0, 0xf(%rbp)
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x3e72c
movq %rbx, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x4e11a
movl %eax, %r13d
movq %r12, %rdi
callq 0x3e814
leaq 0x70(%rsp), %r12
movq %r12, %rdi
movq %rsp, %rsi
callq 0x41380
movq 0x30(%r12), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq 0x8(%rsp), %rdx
callq 0x4ebda
movl %eax, %r12d
shrq $0x20, %r15
sete %r15b
orb 0x12(%rbp), %r15b
jne 0x4f241
leaq 0x16936(%rip), %rdx # 0x65b6a
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x4d29a
xorb $0x1, %r15b
cmpl $0x1, 0x4(%rsp)
sete %al
cmpl $0x1, %r13d
sete %cl
orb %al, %cl
cmpl $0x1, %r12d
sete %bpl
orb %cl, %bpl
orb %r15b, %bpl
addq $0x20, %rbx
movl (%rsp), %esi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x549a6
cmpl $0x1, %eax
sete %al
orb %bpl, %al
movzbl %al, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnAtomicWait(wabt::Location const&, wabt::Opcode, wabt::Var, unsigned long, unsigned long) | Result SharedValidator::OnAtomicWait(const Location& loc,
Opcode opcode,
Var memidx,
Address alignment,
Address offset) {
Result result = CheckInstr(opcode, loc);
MemoryType mt;
result |= CheckMemoryIndex(memidx, &mt);
result |= CheckAtomicAlign(loc, alignment, opcode.GetMemorySize());
result |= CheckOffset(loc, offset, mt.limits);
result |= typechecker_.OnAtomicWait(opcode, mt.limits);
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %r9, %r15
movq %r8, 0x8(%rsp)
movq %rcx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rax
movl %edx, (%rax)
movl %edx, %esi
movq %r14, %rdx
callq 0x4ec5a
movl %eax, 0x4(%rsp)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rbp
movaps %xmm0, (%rbp)
movl $0x0, 0xf(%rbp)
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x3e72c
movq %rbx, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x4e11a
movl %eax, %r13d
movq %r12, %rdi
callq 0x3e814
leaq 0x70(%rsp), %r12
movq %r12, %rdi
movq %rsp, %rsi
callq 0x41380
movq 0x30(%r12), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq 0x8(%rsp), %rdx
callq 0x4ebda
movl %eax, %r12d
shrq $0x20, %r15
sete %r15b
orb 0x12(%rbp), %r15b
jne 0x4f351
leaq 0x16826(%rip), %rdx # 0x65b6a
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x4d29a
xorb $0x1, %r15b
cmpl $0x1, 0x4(%rsp)
sete %al
cmpl $0x1, %r13d
sete %cl
orb %al, %cl
cmpl $0x1, %r12d
sete %bpl
orb %cl, %bpl
orb %r15b, %bpl
addq $0x20, %rbx
movl (%rsp), %esi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x549bc
cmpl $0x1, %eax
sete %al
orb %bpl, %al
movzbl %al, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnBlock(wabt::Location const&, wabt::Type) | Result SharedValidator::OnBlock(const Location& loc, Type sig_type) {
Result result = CheckInstr(Opcode::Block, loc);
TypeVector param_types, result_types;
result |= CheckBlockSignature(loc, Opcode::Block, sig_type, ¶m_types,
&result_types);
result |= typechecker_.OnBlock(param_types, result_types);
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movl $0x2, %esi
movq %r12, %rdx
callq 0x4ec5a
movl %eax, 0xc(%rsp)
xorl %eax, %eax
leaq 0x10(%rsp), %r13
movq %rax, 0x10(%r13)
xorps %xmm0, %xmm0
movaps %xmm0, (%r13)
leaq 0x30(%rsp), %rbx
movq %rax, 0x10(%rbx)
movaps %xmm0, (%rbx)
movq %r14, %rdi
movq %r12, %rsi
movl $0x2, %edx
movq %r15, %rcx
movq %r13, %r8
movq %rbx, %r9
callq 0x4e760
movl %eax, %ebp
addq $0x20, %r14
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x549d8
movl %eax, %r14d
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4f46c
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x4f483
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
cmpl $0x1, 0xc(%rsp)
sete %al
cmpl $0x1, %ebp
sete %cl
orb %al, %cl
cmpl $0x1, %r14d
sete %al
orb %cl, %al
movzbl %al, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnBr(wabt::Location const&, wabt::Var) | Result SharedValidator::OnBr(const Location& loc, Var depth) {
Result result = CheckInstr(Opcode::Br, loc);
result |= typechecker_.OnBr(depth.index());
return result;
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %r14
movl $0xc, %esi
callq 0x4ec5a
cmpl $0x0, 0x20(%rbx)
jne 0x4f4f2
movl %eax, %ebp
addq $0x20, %r14
movl 0x28(%rbx), %esi
movq %r14, %rdi
callq 0x54a52
cmpl $0x1, %ebp
sete %cl
cmpl $0x1, %eax
sete %al
orb %cl, %al
movzbl %al, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x7de3(%rip), %rdi # 0x572dc
leaq 0x7d85(%rip), %rsi # 0x57285
leaq 0x7de0(%rip), %rcx # 0x572e7
movl $0x3b, %edx
callq 0x15160
nop
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnBrIf(wabt::Location const&, wabt::Var) | Result SharedValidator::OnBrIf(const Location& loc, Var depth) {
Result result = CheckInstr(Opcode::BrIf, loc);
result |= typechecker_.OnBrIf(depth.index());
return result;
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %r14
movl $0xd, %esi
callq 0x4ec5a
cmpl $0x0, 0x20(%rbx)
jne 0x4f556
movl %eax, %ebp
addq $0x20, %r14
movl 0x28(%rbx), %esi
movq %r14, %rdi
callq 0x54ab0
cmpl $0x1, %ebp
sete %cl
cmpl $0x1, %eax
sete %al
orb %cl, %al
movzbl %al, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x7d7f(%rip), %rdi # 0x572dc
leaq 0x7d21(%rip), %rsi # 0x57285
leaq 0x7d7c(%rip), %rcx # 0x572e7
movl $0x3b, %edx
callq 0x15160
nop
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnCall(wabt::Location const&, wabt::Var) | Result SharedValidator::OnCall(const Location& loc, Var func_var) {
Result result = CheckInstr(Opcode::Call, loc);
FuncType func_type;
result |= CheckFuncIndex(func_var, &func_type);
result |= typechecker_.OnCall(func_type.params, func_type.results);
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r15
movq %rsi, %rdx
movq %rdi, %r14
movl $0x10, %esi
callq 0x4ec5a
movl %eax, %ebx
xorps %xmm0, %xmm0
movq %rsp, %r12
movaps %xmm0, 0x20(%r12)
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
leaq 0x40(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x3e72c
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x4e07e
movl %eax, %ebp
movq %r13, %rdi
callq 0x3e814
addq $0x20, %r14
leaq 0x18(%rsp), %r15
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x54c70
movl %eax, %r14d
movq (%r15), %rdi
testq %rdi, %rdi
je 0x4f6d2
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4f6e8
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
cmpl $0x1, %ebx
sete %al
cmpl $0x1, %ebp
sete %cl
orb %al, %cl
cmpl $0x1, %r14d
sete %al
orb %cl, %al
movzbl %al, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnCallRef(wabt::Location const&, unsigned int*) | Result SharedValidator::OnCallRef(const Location& loc,
Index* function_type_index) {
Result result = CheckInstr(Opcode::CallRef, loc);
Index func_index;
result |= typechecker_.OnIndexedFuncRef(&func_index);
if (Failed(result)) {
return result;
}
FuncType func_type;
result |= CheckFuncTypeIndex(Var(func_index, loc), &func_type);
result |= typechecker_.OnCall(func_type.params, func_type.results);
if (Succeeded(result)) {
*function_type_index = func_index;
}
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
movl $0x14, %esi
movq %r12, %rdx
callq 0x4ec5a
movl %eax, %ebp
leaq 0x20(%r15), %r14
leaq 0xc(%rsp), %rsi
movq %r14, %rdi
callq 0x54cda
cmpl $0x1, %ebp
sete %cl
cmpl $0x1, %eax
sete %bpl
orb %cl, %bpl
jne 0x4f94a
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r13
movaps %xmm0, 0x20(%r13)
movaps %xmm0, 0x10(%r13)
movaps %xmm0, (%r13)
movl 0xc(%rsp), %esi
leaq 0x50(%rsp), %rbp
movq %rbp, %rdi
movq %r12, %rdx
callq 0x3e686
movq %r15, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x4d69e
cmpl $0x1, %eax
sete %r15b
movq %rbp, %rdi
callq 0x3e814
leaq 0x28(%rsp), %rdx
movq %r14, %rdi
movq %r13, %rsi
callq 0x54c70
cmpl $0x1, %eax
sete %bpl
orb %r15b, %bpl
jne 0x4f91c
movl 0xc(%rsp), %eax
movl %eax, (%rbx)
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x4f933
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x4f94a
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
movzbl %bpl, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnCatch(wabt::Location const&, wabt::Var, bool) | Result SharedValidator::OnCatch(const Location& loc,
Var tag_var,
bool is_catch_all) {
Result result = CheckInstr(Opcode::Catch, loc);
if (is_catch_all) {
TypeVector empty;
result |= typechecker_.OnCatch(empty);
} else {
TagType tag_type;
result |= CheckTagIndex(tag_var, &tag_type);
result |= typechecker_.OnCatch(tag_type.params);
}
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %rdx
movq %rdi, %rbx
movl $0x7, %esi
callq 0x4ec5a
testl %ebp, %ebp
je 0x4f9a2
cmpl $0x1, %eax
sete %bpl
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
jmp 0x4f9eb
cmpl $0x1, %eax
sete %r13b
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x3e72c
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x4e1b6
cmpl $0x1, %eax
sete %bpl
orb %r13b, %bpl
movq %r12, %rdi
callq 0x3e814
addq $0x20, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x54eae
cmpl $0x1, %eax
sete %bl
movq (%r14), %rdi
testq %rdi, %rdi
je 0x4fa15
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
orb %bl, %bpl
movzbl %bpl, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnDataDrop(wabt::Location const&, wabt::Var) | Result SharedValidator::OnDataDrop(const Location& loc, Var segment_var) {
Result result = CheckInstr(Opcode::DataDrop, loc);
result |= CheckDataSegmentIndex(segment_var);
result |= typechecker_.OnDataDrop(segment_var.index());
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %r14
movl $0xd0, %esi
callq 0x4ec5a
movl %eax, %ebp
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x3e72c
movq %r14, %rdi
movq %r12, %rsi
callq 0x4e71e
movl %eax, %r15d
movq %r12, %rdi
callq 0x3e814
cmpl $0x0, 0x20(%rbx)
jne 0x4fb54
addq $0x20, %r14
cmpl $0x1, %ebp
sete %al
cmpl $0x1, %r15d
sete %bpl
orb %al, %bpl
movl 0x28(%rbx), %esi
movq %r14, %rdi
callq 0x55430
cmpl $0x1, %eax
sete %al
orb %bpl, %al
movzbl %al, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x7781(%rip), %rdi # 0x572dc
leaq 0x7723(%rip), %rsi # 0x57285
leaq 0x777e(%rip), %rcx # 0x572e7
movl $0x3b, %edx
callq 0x15160
nop
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnGlobalSet(wabt::Location const&, wabt::Var) | Result SharedValidator::OnGlobalSet(const Location& loc, Var global_var) {
Result result = CheckInstr(Opcode::GlobalSet, loc);
GlobalType global_type;
result |= CheckGlobalIndex(global_var, &global_type);
if (!global_type.mutable_) {
result |= PrintError(
loc, "can't global.set on immutable global at index %" PRIindex ".",
global_var.index());
}
result |= typechecker_.OnGlobalSet(global_type.type);
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl $0x1f, %esi
movq %r14, %rdx
callq 0x4ec5a
movl %eax, %ebp
movq %rsp, %r12
movq $0x0, (%r12)
movb $0x1, 0x8(%r12)
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x3e72c
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x4e168
cmpl $0x1, %ebp
sete %cl
cmpl $0x1, %eax
sete %bpl
orb %cl, %bpl
movq %r13, %rdi
callq 0x3e814
cmpb $0x0, 0x8(%r12)
jne 0x4fecb
cmpl $0x0, 0x20(%r15)
jne 0x4fef6
movl 0x28(%r15), %ecx
leaq 0x15e54(%rip), %rdx # 0x65d09
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x4d29a
cmpl $0x1, %eax
sete %al
orb %al, %bpl
addq $0x20, %rbx
movq (%rsp), %rsi
movq %rbx, %rdi
callq 0x55316
cmpl $0x1, %eax
sete %al
orb %bpl, %al
movzbl %al, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x73df(%rip), %rdi # 0x572dc
leaq 0x7381(%rip), %rsi # 0x57285
leaq 0x73dc(%rip), %rcx # 0x572e7
movl $0x3b, %edx
callq 0x15160
nop
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnLoad(wabt::Location const&, wabt::Opcode, wabt::Var, unsigned long, unsigned long) | Result SharedValidator::OnLoad(const Location& loc,
Opcode opcode,
Var memidx,
Address alignment,
Address offset) {
Result result = CheckInstr(opcode, loc);
MemoryType mt;
result |= CheckMemoryIndex(memidx, &mt);
result |= CheckAlign(loc, alignment, opcode.GetMemorySize());
result |= CheckOffset(loc, offset, mt.limits);
result |= typechecker_.OnLoad(opcode, mt.limits);
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %r9, %r15
movq %r8, 0x8(%rsp)
movq %rcx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rax
movl %edx, (%rax)
movl %edx, %esi
movq %r14, %rdx
callq 0x4ec5a
movl %eax, 0x4(%rsp)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rbp
movaps %xmm0, (%rbp)
movl $0x0, 0xf(%rbp)
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x3e72c
movq %rbx, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x4e11a
movl %eax, %r13d
movq %r12, %rdi
callq 0x3e814
leaq 0x70(%rsp), %r12
movq %r12, %rdi
movq %rsp, %rsi
callq 0x41380
movq 0x30(%r12), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq 0x8(%rsp), %rdx
callq 0x4eb7c
movl %eax, %r12d
shrq $0x20, %r15
sete %r15b
orb 0x12(%rbp), %r15b
jne 0x5009f
leaq 0x15ad8(%rip), %rdx # 0x65b6a
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x4d29a
xorb $0x1, %r15b
cmpl $0x1, 0x4(%rsp)
sete %al
cmpl $0x1, %r13d
sete %cl
orb %al, %cl
cmpl $0x1, %r12d
sete %bpl
orb %cl, %bpl
orb %r15b, %bpl
addq $0x20, %rbx
movl (%rsp), %esi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x55322
cmpl $0x1, %eax
sete %al
orb %bpl, %al
movzbl %al, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnLoadZero(wabt::Location const&, wabt::Opcode, wabt::Var, unsigned long, unsigned long) | Result SharedValidator::OnLoadZero(const Location& loc,
Opcode opcode,
Var memidx,
Address alignment,
Address offset) {
Result result = CheckInstr(opcode, loc);
MemoryType mt;
result |= CheckMemoryIndex(memidx, &mt);
result |= CheckAlign(loc, alignment, opcode.GetMemorySize());
result |= CheckOffset(loc, offset, mt.limits);
result |= typechecker_.OnLoad(opcode, mt.limits);
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %r9, %r15
movq %r8, 0x8(%rsp)
movq %rcx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rax
movl %edx, (%rax)
movl %edx, %esi
movq %r14, %rdx
callq 0x4ec5a
movl %eax, 0x4(%rsp)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rbp
movaps %xmm0, (%rbp)
movl $0x0, 0xf(%rbp)
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x3e72c
movq %rbx, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x4e11a
movl %eax, %r13d
movq %r12, %rdi
callq 0x3e814
leaq 0x70(%rsp), %r12
movq %r12, %rdi
movq %rsp, %rsi
callq 0x41380
movq 0x30(%r12), %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq 0x8(%rsp), %rdx
callq 0x4eb7c
movl %eax, %r12d
shrq $0x20, %r15
sete %r15b
orb 0x12(%rbp), %r15b
jne 0x502bf
leaq 0x158b8(%rip), %rdx # 0x65b6a
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x4d29a
xorb $0x1, %r15b
cmpl $0x1, 0x4(%rsp)
sete %al
cmpl $0x1, %r13d
sete %cl
orb %al, %cl
cmpl $0x1, %r12d
sete %bpl
orb %cl, %bpl
orb %r15b, %bpl
addq $0x20, %rbx
movl (%rsp), %esi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x55322
cmpl $0x1, %eax
sete %al
orb %bpl, %al
movzbl %al, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnLocalGet(wabt::Location const&, wabt::Var) | Result SharedValidator::OnLocalGet(const Location& loc, Var local_var) {
CHECK_RESULT(CheckInstr(Opcode::LocalGet, loc));
Result result = Result::Ok;
Type type = Type::Any;
result |= CheckLocalIndex(local_var, &type);
result |= typechecker_.OnLocalGet(type);
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rsi, %rdx
movq %rdi, %rbx
movl $0x1b, %esi
callq 0x4ec5a
movl %eax, %ecx
movl $0x1, %eax
cmpl $0x1, %ecx
je 0x50391
movq %rsp, %r15
movq $0x0, (%r15)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x3e72c
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x4e5ea
cmpl $0x1, %eax
sete %bpl
movq %r12, %rdi
callq 0x3e814
addq $0x20, %rbx
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x55328
cmpl $0x1, %eax
sete %al
orb %bpl, %al
movzbl %al, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnLocalSet(wabt::Location const&, wabt::Var) | Result SharedValidator::OnLocalSet(const Location& loc, Var local_var) {
CHECK_RESULT(CheckInstr(Opcode::LocalSet, loc));
Result result = Result::Ok;
Type type = Type::Any;
result |= CheckLocalIndex(local_var, &type);
result |= typechecker_.OnLocalSet(type);
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rsi, %rdx
movq %rdi, %rbx
movl $0x1c, %esi
callq 0x4ec5a
movl %eax, %ecx
movl $0x1, %eax
cmpl $0x1, %ecx
je 0x5041b
movq %rsp, %r15
movq $0x0, (%r15)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x3e72c
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x4e5ea
cmpl $0x1, %eax
sete %bpl
movq %r12, %rdi
callq 0x3e814
addq $0x20, %rbx
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x55332
cmpl $0x1, %eax
sete %al
orb %bpl, %al
movzbl %al, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnMemoryCopy(wabt::Location const&, wabt::Var, wabt::Var) | Result SharedValidator::OnMemoryCopy(const Location& loc,
Var destmemidx,
Var srcmemidx) {
Result result = CheckInstr(Opcode::MemoryCopy, loc);
MemoryType srcmt;
MemoryType dstmt;
result |= CheckMemoryIndex(destmemidx, &dstmt);
result |= CheckMemoryIndex(srcmemidx, &srcmt);
result |= typechecker_.OnMemoryCopy(dstmt.limits, srcmt.limits);
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, %r13
movq %rsi, %rdx
movq %rdi, %rbx
movl $0xd1, %esi
callq 0x4ec5a
movl %eax, %ebp
xorl %eax, %eax
leaq 0x30(%rsp), %r14
movl %eax, 0xf(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
leaq 0x10(%rsp), %r15
movl %eax, 0xf(%r15)
movaps %xmm0, (%r15)
leaq 0x90(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x3e72c
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x4e11a
cmpl $0x1, %ebp
sete %cl
cmpl $0x1, %eax
sete %bpl
orb %cl, %bpl
movq %r12, %rdi
callq 0x3e814
leaq 0x48(%rsp), %r12
movq %r12, %rdi
movq 0x8(%rsp), %rsi
callq 0x3e72c
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x4e11a
cmpl $0x1, %eax
sete %r13b
movq %r12, %rdi
callq 0x3e814
addq $0x20, %rbx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x553ea
cmpl $0x1, %eax
sete %al
orb %r13b, %al
orb %bpl, %al
movzbl %al, %eax
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnMemoryFill(wabt::Location const&, wabt::Var) | Result SharedValidator::OnMemoryFill(const Location& loc, Var memidx) {
Result result = CheckInstr(Opcode::MemoryFill, loc);
MemoryType mt;
result |= CheckMemoryIndex(memidx, &mt);
result |= typechecker_.OnMemoryFill(mt.limits);
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r14
movq %rsi, %rdx
movq %rdi, %rbx
movl $0xd2, %esi
callq 0x4ec5a
movl %eax, %ebp
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, (%r15)
movl $0x0, 0xf(%r15)
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x3e72c
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x4e11a
cmpl $0x1, %ebp
sete %cl
cmpl $0x1, %eax
sete %bpl
orb %cl, %bpl
movq %r12, %rdi
callq 0x3e814
addq $0x20, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x55434
cmpl $0x1, %eax
sete %al
orb %bpl, %al
movzbl %al, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnMemoryGrow(wabt::Location const&, wabt::Var) | Result SharedValidator::OnMemoryGrow(const Location& loc, Var memidx) {
Result result = CheckInstr(Opcode::MemoryGrow, loc);
MemoryType mt;
result |= CheckMemoryIndex(memidx, &mt);
result |= typechecker_.OnMemoryGrow(mt.limits);
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r14
movq %rsi, %rdx
movq %rdi, %rbx
movl $0x38, %esi
callq 0x4ec5a
movl %eax, %ebp
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, (%r15)
movl $0x0, 0xf(%r15)
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x3e72c
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x4e11a
cmpl $0x1, %ebp
sete %cl
cmpl $0x1, %eax
sete %bpl
orb %cl, %bpl
movq %r12, %rdi
callq 0x3e814
addq $0x20, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x55446
cmpl $0x1, %eax
sete %al
orb %bpl, %al
movzbl %al, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnMemorySize(wabt::Location const&, wabt::Var) | Result SharedValidator::OnMemorySize(const Location& loc, Var memidx) {
Result result = CheckInstr(Opcode::MemorySize, loc);
MemoryType mt;
result |= CheckMemoryIndex(memidx, &mt);
result |= typechecker_.OnMemorySize(mt.limits);
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r14
movq %rsi, %rdx
movq %rdi, %rbx
movl $0x37, %esi
callq 0x4ec5a
movl %eax, %ebp
xorps %xmm0, %xmm0
movq %rsp, %r15
movaps %xmm0, (%r15)
movl $0x0, 0xf(%r15)
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x3e72c
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x4e11a
cmpl $0x1, %ebp
sete %cl
cmpl $0x1, %eax
sete %bpl
orb %cl, %bpl
movq %r12, %rdi
callq 0x3e814
addq $0x20, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x554a6
cmpl $0x1, %eax
sete %al
orb %bpl, %al
movzbl %al, %eax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnRethrow(wabt::Location const&, wabt::Var) | Result SharedValidator::OnRethrow(const Location& loc, Var depth) {
Result result = CheckInstr(Opcode::Rethrow, loc);
result |= typechecker_.OnRethrow(depth.index());
return result;
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %r14
movl $0x9, %esi
callq 0x4ec5a
cmpl $0x0, 0x20(%rbx)
jne 0x50ad4
movl %eax, %ebp
addq $0x20, %r14
movl 0x28(%rbx), %esi
movq %r14, %rdi
callq 0x556aa
cmpl $0x1, %ebp
sete %cl
cmpl $0x1, %eax
sete %al
orb %cl, %al
movzbl %al, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x6801(%rip), %rdi # 0x572dc
leaq 0x67a3(%rip), %rsi # 0x57285
leaq 0x67fe(%rip), %rcx # 0x572e7
movl $0x3b, %edx
callq 0x15160
nop
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnReturnCallIndirect(wabt::Location const&, wabt::Var, wabt::Var) | Result SharedValidator::OnReturnCallIndirect(const Location& loc,
Var sig_var,
Var table_var) {
Result result = CheckInstr(Opcode::CallIndirect, loc);
FuncType func_type;
TableType table_type;
result |= CheckFuncTypeIndex(sig_var, &func_type);
result |= CheckTableIndex(table_var, &table_type);
if (table_type.element != Type::FuncRef) {
result |= PrintError(loc,
"type mismatch: return_call_indirect must reference "
"table of funcref type");
}
result |=
typechecker_.OnReturnCallIndirect(func_type.params, func_type.results);
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rcx, 0x8(%rsp)
movq %rdx, %r13
movq %rsi, %rdx
movq %rdi, %rbx
movl $0x11, %esi
movq %rdx, (%rsp)
callq 0x4ec5a
movl %eax, %ebp
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
movaps %xmm0, 0x20(%r14)
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
leaq 0x50(%rsp), %r15
movups %xmm0, 0xb(%r15)
movaps %xmm0, (%r15)
leaq 0xc0(%rsp), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x3e72c
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x4d69e
cmpl $0x1, %ebp
sete %cl
cmpl $0x1, %eax
sete %r13b
orb %cl, %r13b
movq %r12, %rdi
callq 0x3e814
leaq 0x78(%rsp), %r14
movq %r14, %rdi
movq 0x8(%rsp), %rsi
callq 0x3e72c
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4e0cc
cmpl $0x1, %eax
sete %bpl
orb %r13b, %bpl
movq %r14, %rdi
callq 0x3e814
cmpl $-0x10, (%r15)
je 0x50cac
leaq 0x150a6(%rip), %rdx # 0x65d3b
movq %rbx, %rdi
movq (%rsp), %rsi
xorl %eax, %eax
callq 0x4d29a
cmpl $0x1, %eax
sete %al
orb %al, %bpl
addq $0x20, %rbx
leaq 0x28(%rsp), %rdx
leaq 0x10(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x54dec
movl %eax, %ebx
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x50cdd
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x50cf4
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
cmpl $0x1, %ebx
sete %al
orb %al, %bpl
movzbl %bpl, %eax
addq $0x108, %rsp # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnSelect(wabt::Location const&, unsigned int, wabt::Type*) | Result SharedValidator::OnSelect(const Location& loc,
Index result_count,
Type* result_types) {
Result result = CheckInstr(Opcode::Select, loc);
if (result_count > 1) {
result |=
PrintError(loc, "invalid arity in select instruction: %" PRIindex ".",
result_count);
} else {
result |= typechecker_.OnSelect(ToTypeVector(result_count, result_types));
}
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r14
movl $0x18, %esi
movq %r12, %rdx
callq 0x4ec5a
movl %eax, %ebx
cmpl $0x2, %ebp
jb 0x50d9f
leaq 0x15004(%rip), %rdx # 0x65d84
movq %r14, %rdi
movq %r12, %rsi
movl %ebp, %ecx
xorl %eax, %eax
callq 0x4d29a
cmpl $0x1, %ebx
sete %cl
cmpl $0x1, %eax
sete %bl
orb %cl, %bl
jmp 0x50df9
addq $0x20, %r14
movl %ebp, %eax
leaq (%r15,%rax,8), %rdx
xorps %xmm0, %xmm0
movq %rsp, %r12
movaps %xmm0, (%r12)
movq $0x0, 0x10(%r12)
movq %r12, %rdi
movq %r15, %rsi
callq 0x522b0
movq %r14, %rdi
movq %r12, %rsi
callq 0x557b6
cmpl $0x1, %ebx
sete %bl
cmpl $0x1, %eax
sete %bpl
movq (%r12), %rdi
testq %rdi, %rdi
je 0x50df6
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
orb %bpl, %bl
movzbl %bl, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnSimdStoreLane(wabt::Location const&, wabt::Opcode, wabt::Var, unsigned long, unsigned long, unsigned long) | Result SharedValidator::OnSimdStoreLane(const Location& loc,
Opcode opcode,
Var memidx,
Address alignment,
Address offset,
uint64_t value) {
Result result = CheckInstr(opcode, loc);
MemoryType mt;
result |= CheckMemoryIndex(memidx, &mt);
result |= CheckAlign(loc, alignment, opcode.GetMemorySize());
result |= CheckOffset(loc, offset, mt.limits);
result |= typechecker_.OnSimdStoreLane(opcode, mt.limits, value);
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %r9, %r12
movq %r8, 0x8(%rsp)
movq %rcx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsp, %rax
movl %edx, (%rax)
movl %edx, %esi
movq %r15, %rdx
callq 0x4ec5a
movl %eax, 0x4(%rsp)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rbp
movaps %xmm0, (%rbp)
movl $0x0, 0xf(%rbp)
leaq 0x28(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
callq 0x3e72c
movq %r14, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x4e11a
movl %eax, %ebx
movq %r13, %rdi
callq 0x3e814
leaq 0x70(%rsp), %r13
movq %r13, %rdi
movq %rsp, %rsi
callq 0x41380
movq 0x30(%r13), %rcx
movq %r14, %rdi
movq %r15, %rsi
movq 0x8(%rsp), %rdx
callq 0x4eb7c
movl %eax, %r13d
shrq $0x20, %r12
sete %r12b
orb 0x12(%rbp), %r12b
jne 0x5101f
leaq 0x14b58(%rip), %rdx # 0x65b6a
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x4d29a
xorb $0x1, %r12b
cmpl $0x1, 0x4(%rsp)
sete %al
cmpl $0x1, %ebx
sete %cl
orb %al, %cl
cmpl $0x1, %r13d
sete %bl
orb %cl, %bl
orb %r12b, %bl
addq $0x20, %r14
movl (%rsp), %esi
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
movq 0xf0(%rsp), %rcx
callq 0x55c5c
cmpl $0x1, %eax
sete %al
orb %bl, %al
movzbl %al, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnTableCopy(wabt::Location const&, wabt::Var, wabt::Var) | Result SharedValidator::OnTableCopy(const Location& loc,
Var dst_var,
Var src_var) {
Result result = CheckInstr(Opcode::TableCopy, loc);
TableType dst_table;
TableType src_table;
result |= CheckTableIndex(dst_var, &dst_table);
result |= CheckTableIndex(src_var, &src_table);
result |= typechecker_.OnTableCopy(dst_table.limits, src_table.limits);
result |= CheckType(loc, src_table.element, dst_table.element, "table.copy");
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rcx, (%rsp)
movq %rdx, %r13
movq %rsi, %rdx
movq %rsi, 0x8(%rsp)
movq %rdi, %r14
movl $0xd5, %esi
callq 0x4ec5a
movl %eax, %ebp
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rbx
movups %xmm0, 0xb(%rbx)
movaps %xmm0, (%rbx)
leaq 0x10(%rsp), %r12
movups %xmm0, 0xb(%r12)
movaps %xmm0, (%r12)
leaq 0xa0(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x3e72c
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x4e0cc
cmpl $0x1, %ebp
sete %cl
cmpl $0x1, %eax
sete %bpl
orb %cl, %bpl
movq %r15, %rdi
callq 0x3e814
leaq 0x58(%rsp), %rbx
movq %rbx, %rdi
movq (%rsp), %rsi
callq 0x3e72c
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x4e0cc
cmpl $0x1, %eax
sete %r12b
movq %rbx, %rdi
callq 0x3e814
leaq 0x20(%r14), %rdi
leaq 0x38(%rsp), %rbx
leaq 0x18(%rsp), %r15
movq %rbx, %rsi
movq %r15, %rdx
callq 0x554c4
cmpl $0x1, %eax
sete %r13b
orb %r12b, %r13b
orb %bpl, %r13b
movq -0x8(%r15), %rdx
movq -0x8(%rbx), %rcx
leaq 0x10456(%rip), %r8 # 0x61718
movq %r14, %rdi
movq 0x8(%rsp), %rsi
callq 0x4dcb2
cmpl $0x1, %eax
sete %al
orb %r13b, %al
movzbl %al, %eax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnTableFill(wabt::Location const&, wabt::Var) | Result SharedValidator::OnTableFill(const Location& loc, Var table_var) {
Result result = CheckInstr(Opcode::TableFill, loc);
TableType table_type;
result |= CheckTableIndex(table_var, &table_type);
result |= typechecker_.OnTableFill(table_type.element, table_type.limits);
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rdx, %r14
movq %rsi, %rdx
movq %rdi, %rbx
movl $0xda, %esi
callq 0x4ec5a
movl %eax, %ebp
xorps %xmm0, %xmm0
movq %rsp, %r15
movups %xmm0, 0xb(%r15)
movaps %xmm0, (%r15)
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x3e72c
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x4e0cc
cmpl $0x1, %ebp
sete %cl
cmpl $0x1, %eax
sete %bpl
orb %cl, %bpl
movq %r12, %rdi
callq 0x3e814
addq $0x20, %rbx
movq (%r15), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x555d8
cmpl $0x1, %eax
sete %al
orb %bpl, %al
movzbl %al, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnTableGet(wabt::Location const&, wabt::Var) | Result SharedValidator::OnTableGet(const Location& loc, Var table_var) {
Result result = CheckInstr(Opcode::TableGet, loc);
TableType table_type;
result |= CheckTableIndex(table_var, &table_type);
result |= typechecker_.OnTableGet(table_type.element, table_type.limits);
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rdx, %r14
movq %rsi, %rdx
movq %rdi, %rbx
movl $0xd6, %esi
callq 0x4ec5a
movl %eax, %ebp
xorps %xmm0, %xmm0
movq %rsp, %r15
movups %xmm0, 0xb(%r15)
movaps %xmm0, (%r15)
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x3e72c
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x4e0cc
cmpl $0x1, %ebp
sete %cl
cmpl $0x1, %eax
sete %bpl
orb %cl, %bpl
movq %r12, %rdi
callq 0x3e814
addq $0x20, %rbx
movq (%r15), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x5551e
cmpl $0x1, %eax
sete %al
orb %bpl, %al
movzbl %al, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnTableGrow(wabt::Location const&, wabt::Var) | Result SharedValidator::OnTableGrow(const Location& loc, Var table_var) {
Result result = CheckInstr(Opcode::TableGrow, loc);
TableType table_type;
result |= CheckTableIndex(table_var, &table_type);
result |= typechecker_.OnTableGrow(table_type.element, table_type.limits);
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rdx, %r14
movq %rsi, %rdx
movq %rdi, %rbx
movl $0xd8, %esi
callq 0x4ec5a
movl %eax, %ebp
xorps %xmm0, %xmm0
movq %rsp, %r15
movups %xmm0, 0xb(%r15)
movaps %xmm0, (%r15)
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x3e72c
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x4e0cc
cmpl $0x1, %ebp
sete %cl
cmpl $0x1, %eax
sete %bpl
orb %cl, %bpl
movq %r12, %rdi
callq 0x3e814
addq $0x20, %rbx
movq (%r15), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x5556a
cmpl $0x1, %eax
sete %al
orb %bpl, %al
movzbl %al, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnTableSet(wabt::Location const&, wabt::Var) | Result SharedValidator::OnTableSet(const Location& loc, Var table_var) {
Result result = CheckInstr(Opcode::TableSet, loc);
TableType table_type;
result |= CheckTableIndex(table_var, &table_type);
result |= typechecker_.OnTableSet(table_type.element, table_type.limits);
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rdx, %r14
movq %rsi, %rdx
movq %rdi, %rbx
movl $0xd7, %esi
callq 0x4ec5a
movl %eax, %ebp
xorps %xmm0, %xmm0
movq %rsp, %r15
movups %xmm0, 0xb(%r15)
movaps %xmm0, (%r15)
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x3e72c
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x4e0cc
cmpl $0x1, %ebp
sete %cl
cmpl $0x1, %eax
sete %bpl
orb %cl, %bpl
movq %r12, %rdi
callq 0x3e814
addq $0x20, %rbx
movq (%r15), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x55546
cmpl $0x1, %eax
sete %al
orb %bpl, %al
movzbl %al, %eax
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnThrow(wabt::Location const&, wabt::Var) | Result SharedValidator::OnThrow(const Location& loc, Var tag_var) {
Result result = CheckInstr(Opcode::Throw, loc);
TagType tag_type;
result |= CheckTagIndex(tag_var, &tag_type);
result |= typechecker_.OnThrow(tag_type.params);
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r15
movq %rsi, %rdx
movq %rdi, %r14
movl $0x8, %esi
callq 0x4ec5a
movl %eax, %ebx
xorps %xmm0, %xmm0
movq %rsp, %r12
movaps %xmm0, (%r12)
movq $0x0, 0x10(%r12)
leaq 0x20(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x3e72c
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x4e1b6
movl %eax, %ebp
movq %r13, %rdi
callq 0x3e814
addq $0x20, %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x556e0
movl %eax, %r14d
movq (%r12), %rdi
testq %rdi, %rdi
je 0x517bf
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
cmpl $0x1, %ebx
sete %al
cmpl $0x1, %ebp
sete %cl
orb %al, %cl
cmpl $0x1, %r14d
sete %al
orb %cl, %al
movzbl %al, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::BeginTryTable(wabt::Location const&, wabt::Type) | Result SharedValidator::BeginTryTable(const Location& loc, Type sig_type) {
Result result = CheckInstr(Opcode::TryTable, loc);
TypeVector param_types, result_types;
result |= CheckBlockSignature(loc, Opcode::TryTable, sig_type, ¶m_types,
&result_types);
result |= typechecker_.BeginTryTable(param_types);
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movl $0x1a, %esi
movq %r12, %rdx
callq 0x4ec5a
movl %eax, 0xc(%rsp)
xorl %eax, %eax
leaq 0x10(%rsp), %r13
movq %rax, 0x10(%r13)
xorps %xmm0, %xmm0
movaps %xmm0, (%r13)
leaq 0x30(%rsp), %rbx
movq %rax, 0x10(%rbx)
movaps %xmm0, (%rbx)
movq %r14, %rdi
movq %r12, %rsi
movl $0x1a, %edx
movq %r15, %rcx
movq %r13, %r8
movq %rbx, %r9
callq 0x4e760
movl %eax, %ebp
addq $0x20, %r14
movq %r14, %rdi
movq %r13, %rsi
callq 0x55a06
movl %eax, %r14d
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x51979
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x51990
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
cmpl $0x1, 0xc(%rsp)
sete %al
cmpl $0x1, %ebp
sete %cl
orb %al, %cl
cmpl $0x1, %r14d
sete %al
orb %cl, %al
movzbl %al, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::OnTryTableCatch(wabt::Location const&, wabt::TableCatch const&) | Result SharedValidator::OnTryTableCatch(const Location& loc,
const TableCatch& catch_) {
Result result = Result::Ok;
TagType tag_type;
expr_loc_ = loc;
if (!catch_.IsCatchAll()) {
result |= CheckTagIndex(catch_.tag, &tag_type);
}
if (catch_.IsRef()) {
tag_type.params.push_back(Type::ExnRef);
}
result |=
typechecker_.OnTryTableCatch(tag_type.params, catch_.target.index());
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups %xmm1, 0xa0(%rdi)
movups %xmm0, 0x90(%rdi)
movl 0xb0(%rdx), %eax
andl $-0x2, %eax
cmpl $0x2, %eax
jne 0x51a03
xorl %ebp, %ebp
jmp 0x51a31
leaq 0x20(%r14), %rsi
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x3e72c
movq %rsp, %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4e1b6
cmpl $0x1, %eax
sete %bpl
movq %r15, %rdi
callq 0x3e814
movl 0xb0(%r14), %eax
andl $-0x3, %eax
cmpl $0x1, %eax
jne 0x51a55
movl $0xffffffe9, %eax # imm = 0xFFFFFFE9
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
movq %rsp, %rdi
callq 0x47884
cmpl $0x0, 0x88(%r14)
jne 0x51aa7
addq $0x20, %rbx
movl 0x90(%r14), %edx
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x55a12
movl %eax, %ebx
movq (%r14), %rdi
testq %rdi, %rdi
je 0x51a8f
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
cmpl $0x1, %ebx
sete %al
orb %al, %bpl
movzbl %bpl, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x582e(%rip), %rdi # 0x572dc
leaq 0x57d0(%rip), %rsi # 0x57285
leaq 0x582b(%rip), %rcx # 0x572e7
movl $0x3b, %edx
callq 0x15160
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::SharedValidator::EndTryTable(wabt::Location const&, wabt::Type) | Result SharedValidator::EndTryTable(const Location& loc, Type sig_type) {
Result result = CheckInstr(Opcode::TryTable, loc);
TypeVector param_types, result_types;
result |= CheckBlockSignature(loc, Opcode::TryTable, sig_type, ¶m_types,
&result_types);
result |= typechecker_.EndTryTable(param_types, result_types);
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movl $0x1a, %esi
movq %r12, %rdx
callq 0x4ec5a
movl %eax, 0xc(%rsp)
xorl %eax, %eax
leaq 0x10(%rsp), %r13
movq %rax, 0x10(%r13)
xorps %xmm0, %xmm0
movaps %xmm0, (%r13)
leaq 0x30(%rsp), %rbx
movq %rax, 0x10(%rbx)
movaps %xmm0, (%rbx)
movq %r14, %rdi
movq %r12, %rsi
movl $0x1a, %edx
movq %r15, %rcx
movq %r13, %r8
movq %rbx, %r9
callq 0x4e760
movl %eax, %ebp
addq $0x20, %r14
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x55aee
movl %eax, %r14d
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x51b52
movq 0x40(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x51b69
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
cmpl $0x1, 0xc(%rsp)
sete %al
cmpl $0x1, %ebp
sete %cl
orb %al, %cl
cmpl $0x1, %r14d
sete %al
orb %cl, %al
movzbl %al, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::Result wabt::SharedValidator::CheckIndexWithValue<wabt::SharedValidator::FuncType>(wabt::Var, std::vector<wabt::SharedValidator::FuncType, std::allocator<wabt::SharedValidator::FuncType>> const&, wabt::SharedValidator::FuncType*, char const*) | Result SharedValidator::CheckIndexWithValue(Var var,
const std::vector<T>& values,
T* out,
const char* desc) {
Result result = CheckIndex(var, values.size(), desc);
if (out) {
*out = Succeeded(result) ? values[var.index()] : T{};
}
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
leaq 0x40(%rsp), %rbp
movq %rbp, %rdi
callq 0x3e72c
movq 0x8(%r15), %rax
subq (%r15), %rax
shrq $0x3, %rax
imull $0xb6db6db7, %eax, %edx # imm = 0xB6DB6DB7
movq %r13, %rdi
movq %rbp, %rsi
movq %rbx, %rcx
callq 0x4e5a6
movl %eax, %ebx
movq %rbp, %rdi
callq 0x3e814
testq %r14, %r14
je 0x51daa
testl %ebx, %ebx
je 0x51d17
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq $0x0, 0x30(%rsp)
jmp 0x51d5b
cmpl $0x0, 0x20(%r12)
jne 0x51dbe
movl 0x28(%r12), %eax
movq (%r15), %r12
imulq $0x38, %rax, %r13
leaq (%r12,%r13), %rsi
movq %rsp, %rdi
callq 0x238fe
leaq 0x18(%rsp), %r15
addq %r13, %r12
addq $0x18, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x238fe
movl 0x18(%r12), %eax
movl %eax, 0x18(%r15)
movq %rsp, %rsi
movq %r14, %rdi
callq 0x20e42
leaq 0x18(%r14), %rdi
leaq 0x18(%rsp), %r15
movq %r15, %rsi
callq 0x20e42
movl 0x18(%r15), %eax
movl %eax, 0x30(%r14)
movq (%r15), %rdi
testq %rdi, %rdi
je 0x51d94
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x51daa
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
movl %ebx, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5517(%rip), %rdi # 0x572dc
leaq 0x54b9(%rip), %rsi # 0x57285
leaq 0x5514(%rip), %rcx # 0x572e7
movl $0x3b, %edx
callq 0x15160
nop
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::Result wabt::SharedValidator::CheckIndexWithValue<wabt::SharedValidator::MemoryType>(wabt::Var, std::vector<wabt::SharedValidator::MemoryType, std::allocator<wabt::SharedValidator::MemoryType>> const&, wabt::SharedValidator::MemoryType*, char const*) | Result SharedValidator::CheckIndexWithValue(Var var,
const std::vector<T>& values,
T* out,
const char* desc) {
Result result = CheckIndex(var, values.size(), desc);
if (out) {
*out = Succeeded(result) ? values[var.index()] : T{};
}
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r12
movq %rcx, %rbx
movq %rdx, %r14
movq %rdi, %r13
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %rsi, 0x18(%rsp)
callq 0x3e72c
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %edx # imm = 0xAAAAAAAB
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rcx
callq 0x4e5a6
movl %eax, %ebp
movq %r15, %rdi
callq 0x3e814
testq %rbx, %rbx
je 0x51e85
testl %ebp, %ebp
je 0x51e4e
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
jmp 0x51e75
movq 0x18(%rsp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x51e96
movl 0x28(%rax), %eax
movq (%r14), %rcx
leaq (%rax,%rax,2), %rax
movq 0x10(%rcx,%rax,8), %rdx
movq %rdx, 0x10(%rsp)
movups (%rcx,%rax,8), %xmm0
movaps %xmm0, (%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
movaps (%rsp), %xmm0
movups %xmm0, (%rbx)
movl %ebp, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x543f(%rip), %rdi # 0x572dc
leaq 0x53e1(%rip), %rsi # 0x57285
leaq 0x543c(%rip), %rcx # 0x572e7
movl $0x3b, %edx
callq 0x15160
nop
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::Result wabt::SharedValidator::CheckIndexWithValue<wabt::SharedValidator::TableType>(wabt::Var, std::vector<wabt::SharedValidator::TableType, std::allocator<wabt::SharedValidator::TableType>> const&, wabt::SharedValidator::TableType*, char const*) | Result SharedValidator::CheckIndexWithValue(Var var,
const std::vector<T>& values,
T* out,
const char* desc) {
Result result = CheckIndex(var, values.size(), desc);
if (out) {
*out = Succeeded(result) ? values[var.index()] : T{};
}
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r8, %r12
movq %rcx, 0x8(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
callq 0x3e72c
movq 0x8(%r14), %rdx
subq (%r14), %rdx
shrq $0x5, %rdx
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rcx
callq 0x4e5a6
movl %eax, %ebp
movq %rbx, %rdi
callq 0x3e814
movq 0x8(%rsp), %rdx
testq %rdx, %rdx
je 0x51f53
testl %ebp, %ebp
je 0x51f1d
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
jmp 0x51f3d
cmpl $0x0, 0x20(%r15)
jne 0x51f64
movl 0x28(%r15), %eax
movq (%r14), %rcx
shlq $0x5, %rax
movups (%rcx,%rax), %xmm0
movups 0x10(%rcx,%rax), %xmm1
movaps %xmm1, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps 0x10(%rsp), %xmm0
movaps 0x20(%rsp), %xmm1
movups %xmm1, 0x10(%rdx)
movups %xmm0, (%rdx)
movl %ebp, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5371(%rip), %rdi # 0x572dc
leaq 0x5313(%rip), %rsi # 0x57285
leaq 0x536e(%rip), %rcx # 0x572e7
movl $0x3b, %edx
callq 0x15160
nop
| /WebAssembly[P]wabt/src/shared-validator.cc |
wabt::Result wabt::SharedValidator::CheckIndexWithValue<wabt::SharedValidator::TagType>(wabt::Var, std::vector<wabt::SharedValidator::TagType, std::allocator<wabt::SharedValidator::TagType>> const&, wabt::SharedValidator::TagType*, char const*) | Result SharedValidator::CheckIndexWithValue(Var var,
const std::vector<T>& values,
T* out,
const char* desc) {
Result result = CheckIndex(var, values.size(), desc);
if (out) {
*out = Succeeded(result) ? values[var.index()] : T{};
}
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r12
movq %rcx, %rbp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x3e72c
movq 0x8(%r14), %rax
subq (%r14), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %edx # imm = 0xAAAAAAAB
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rcx
movq %rbp, %r12
callq 0x4e5a6
movl %eax, %ebp
movq %rbx, %rdi
callq 0x3e814
testq %r12, %r12
je 0x520f0
testl %ebp, %ebp
je 0x520af
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
jmp 0x520cd
cmpl $0x0, 0x20(%r15)
jne 0x52101
movl 0x28(%r15), %eax
leaq (%rax,%rax,2), %rsi
shlq $0x3, %rsi
addq (%r14), %rsi
movq %rsp, %rdi
callq 0x238fe
movq %rsp, %rbx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x20e42
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x520f0
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
movl %ebp, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x51d4(%rip), %rdi # 0x572dc
leaq 0x5176(%rip), %rsi # 0x57285
leaq 0x51d1(%rip), %rcx # 0x572e7
movl $0x3b, %edx
callq 0x15160
| /WebAssembly[P]wabt/src/shared-validator.cc |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.