name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
wabt::(anonymous namespace)::BinaryReaderIR::OnDelegateExpr(unsigned int) | Result BinaryReaderIR::OnDelegateExpr(Index depth) {
LabelNode* label = nullptr;
CHECK_RESULT(TopLabel(&label));
if (label->label_type != LabelType::Try) {
PrintError("delegate not inside try block");
return Result::Error;
}
auto* try_ = cast<TryExpr>(label->context);
if (try_->kind == TryKind::Plain) {
try_->kind = TryKind::Delegate;
} else if (try_->kind != TryKind::Delegate) {
PrintError("delegate not allowed in try-catch");
return Result::Error;
}
try_->delegate_target = Var(depth, GetLocation());
PopLabel();
return Result::Ok;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq 0x28(%rdi), %r15
movq 0x30(%rdi), %r12
movq %r12, %rax
subq %r15, %rax
je 0x1ab1f
leaq (%r15,%rax), %r13
addq $-0x18, %r13
jmp 0x1ab47
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
leaq 0x3cd1a(%rip), %rsi # 0x57852
xorl %r13d, %r13d
movq %rbx, %rdi
xorl %edx, %edx
xorl %eax, %eax
callq 0x1f148
movl $0x1, %r14d
cmpq %r15, %r12
je 0x1ac20
cmpl $0x6, (%r13)
jne 0x1abfa
movq 0x10(%r13), %r15
cmpl $0x3d, 0x38(%r15)
jne 0x1ac32
movl 0x3c(%r15), %eax
cmpl $0x2, %eax
je 0x1ab89
testl %eax, %eax
jne 0x1ac03
movl $0x2, 0x3c(%r15)
xorps %xmm0, %xmm0
movq %rsp, %r14
movups %xmm0, 0xc(%r14)
movaps %xmm0, (%r14)
movq 0x40(%rbx), %r12
movq %r12, %rdi
callq 0x15100
movq %rax, (%r14)
movq %r12, 0x8(%r14)
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%r14)
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x3e686
addq $0x130, %r15 # imm = 0x130
movq %r15, %rdi
movq %r12, %rsi
callq 0x3e6f2
movq %r12, %rdi
callq 0x3e814
movq 0x30(%rbx), %rax
cmpq 0x28(%rbx), %rax
je 0x1ac0c
addq $-0x18, %rax
movq %rax, 0x30(%rbx)
xorl %r14d, %r14d
jmp 0x1ac20
leaq 0x3ce52(%rip), %rsi # 0x57a53
jmp 0x1ac16
leaq 0x3ce67(%rip), %rsi # 0x57a71
jmp 0x1ac16
leaq 0x3ce80(%rip), %rsi # 0x57a93
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1f148
movl %r14d, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3cd65(%rip), %rdi # 0x5799e
leaq 0x3cd71(%rip), %rsi # 0x579b1
leaq 0x3cdc3(%rip), %rcx # 0x57a0a
movl $0x4e, %edx
callq 0x15160
nop
| /WebAssembly[P]wabt/src/binary-reader-ir.cc |
wabt::(anonymous namespace)::BinaryReaderIR::OnElseExpr() | Result BinaryReaderIR::OnElseExpr() {
LabelNode* label;
Expr* expr;
CHECK_RESULT(TopLabelExpr(&label, &expr));
if (label->label_type == LabelType::If) {
auto* if_expr = cast<IfExpr>(expr);
if_expr->true_.end_loc = GetLocation();
label->exprs = &if_expr->false_;
label->label_type = LabelType::Else;
} else {
PrintError("else expression without matching if");
return Result::Error;
}
return Result::Ok;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq %rsp, %rdx
callq 0x1f70c
movl $0x1, %ebp
cmpl $0x1, %eax
je 0x1ad52
movq 0x8(%rsp), %r15
cmpl $0x4, (%r15)
jne 0x1ad41
movq (%rsp), %r12
cmpl $0x16, 0x38(%r12)
jne 0x1ad61
movq 0x40(%rbx), %r14
movq %r14, %rdi
callq 0x15100
movq 0x8(%rbx), %rcx
movq 0x10(%rcx), %rcx
movq %rax, 0xf8(%r12)
movq %r14, 0x100(%r12)
movq %rcx, 0x108(%r12)
movq $0x0, 0x110(%r12)
addq $0x118, %r12 # imm = 0x118
movq %r12, 0x8(%r15)
movl $0x5, (%r15)
xorl %ebp, %ebp
jmp 0x1ad52
leaq 0x3cd65(%rip), %rsi # 0x57aad
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1f148
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3cc36(%rip), %rdi # 0x5799e
leaq 0x3cc42(%rip), %rsi # 0x579b1
leaq 0x3cd8a(%rip), %rcx # 0x57b00
movl $0x4e, %edx
callq 0x15160
| /WebAssembly[P]wabt/src/binary-reader-ir.cc |
wabt::(anonymous namespace)::BinaryReaderIR::OnEndExpr() | Result BinaryReaderIR::OnEndExpr() {
if (label_stack_.size() > 1) {
LabelNode* label;
Expr* expr;
CHECK_RESULT(TopLabelExpr(&label, &expr));
switch (label->label_type) {
case LabelType::Block:
cast<BlockExpr>(expr)->block.end_loc = GetLocation();
break;
case LabelType::Loop:
cast<LoopExpr>(expr)->block.end_loc = GetLocation();
break;
case LabelType::If:
cast<IfExpr>(expr)->true_.end_loc = GetLocation();
break;
case LabelType::Else:
cast<IfExpr>(expr)->false_end_loc = GetLocation();
break;
case LabelType::Try:
cast<TryExpr>(expr)->block.end_loc = GetLocation();
break;
case LabelType::TryTable:
cast<TryTableExpr>(expr)->block.end_loc = GetLocation();
break;
case LabelType::InitExpr:
case LabelType::Func:
case LabelType::Catch:
break;
}
}
return PopLabel();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rax
subq 0x28(%rdi), %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
cmpq $0x2, %rcx
jb 0x1af09
leaq 0x8(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x1f70c
cmpl $0x1, %eax
je 0x1af30
movl %eax, %ebp
movq 0x8(%rsp), %rax
movl (%rax), %eax
addl $-0x2, %eax
cmpl $0x5, %eax
ja 0x1aeff
leaq 0x3c718(%rip), %rcx # 0x57500
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rsp), %r15
cmpl $0x8, 0x38(%r15)
je 0x1aec8
leaq 0x3cb97(%rip), %rdi # 0x5799e
leaq 0x3cba3(%rip), %rsi # 0x579b1
leaq 0x3cd33(%rip), %rcx # 0x57b48
jmp 0x1af6e
movq (%rsp), %r15
cmpl $0x3d, 0x38(%r15)
je 0x1aec8
leaq 0x3cb6e(%rip), %rdi # 0x5799e
leaq 0x3cb7a(%rip), %rsi # 0x579b1
leaq 0x3cbcc(%rip), %rcx # 0x57a0a
jmp 0x1af6e
movq (%rsp), %r15
cmpl $0x16, 0x38(%r15)
je 0x1aec8
jmp 0x1af42
movq (%rsp), %r15
cmpl $0x16, 0x38(%r15)
jne 0x1af42
movq 0x8(%rbx), %rax
movq 0x40(%rbx), %r14
movq 0x10(%rax), %r12
movq %r14, %rdi
callq 0x15100
movq %rax, 0x130(%r15)
movq %r14, 0x138(%r15)
movq %r12, 0x140(%r15)
addq $0x148, %r15 # imm = 0x148
jmp 0x1aef8
movq (%rsp), %r15
cmpl $0x1b, 0x38(%r15)
je 0x1aec8
leaq 0x3caf8(%rip), %rdi # 0x5799e
leaq 0x3cb04(%rip), %rsi # 0x579b1
leaq 0x3ccfa(%rip), %rcx # 0x57bae
jmp 0x1af6e
movq (%rsp), %r15
cmpl $0x3e, 0x38(%r15)
jne 0x1af59
movq 0x8(%rbx), %rax
movq 0x40(%rbx), %r14
movq 0x10(%rax), %r12
movq %r14, %rdi
callq 0x15100
movq %rax, 0xf8(%r15)
movq %r14, 0x100(%r15)
movq %r12, 0x108(%r15)
addq $0x110, %r15 # imm = 0x110
movq $0x0, (%r15)
movl $0x1, %eax
cmpl $0x1, %ebp
je 0x1af35
movq 0x30(%rbx), %rax
cmpq 0x28(%rbx), %rax
je 0x1af1f
addq $-0x18, %rax
movq %rax, 0x30(%rbx)
xorl %eax, %eax
jmp 0x1af35
leaq 0x3cb6d(%rip), %rsi # 0x57a93
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1f148
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3ca55(%rip), %rdi # 0x5799e
leaq 0x3ca61(%rip), %rsi # 0x579b1
leaq 0x3cba9(%rip), %rcx # 0x57b00
jmp 0x1af6e
leaq 0x3ca3e(%rip), %rdi # 0x5799e
leaq 0x3ca4a(%rip), %rsi # 0x579b1
leaq 0x3cca5(%rip), %rcx # 0x57c13
movl $0x4e, %edx
callq 0x15160
| /WebAssembly[P]wabt/src/binary-reader-ir.cc |
wabt::(anonymous namespace)::BinaryReaderIR::OnF32ConstExpr(unsigned int) | Result BinaryReaderIR::OnF32ConstExpr(uint32_t value_bits) {
return AppendExpr(
std::make_unique<ConstExpr>(Const::F32(value_bits, GetLocation())));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq 0x40(%rdi), %r14
movq %r14, %rdi
callq 0x15100
movq %rax, %r15
movq 0x8(%rbx), %rax
movq 0x10(%rax), %r12
movl $0x90, %edi
callq 0x151f0
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x24(%rax)
movl $0x11, 0x38(%rax)
leaq 0x66b11(%rip), %rcx # 0x81ad8
movq %rcx, (%rax)
movq %r15, 0x40(%rax)
movq %r14, 0x48(%rax)
movq %r12, 0x50(%rax)
movq $0x0, 0x58(%rax)
movl $0xfffffffd, %ecx # imm = 0xFFFFFFFD
movq %rcx, 0x60(%rax)
movl %ebp, 0x70(%rax)
movl $0x0, 0x80(%rax)
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1f410
movl %eax, %ebx
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1b017
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/binary-reader-ir.cc |
wabt::(anonymous namespace)::BinaryReaderIR::OnV128ConstExpr(v128) | Result BinaryReaderIR::OnV128ConstExpr(v128 value_bits) {
return AppendExpr(
std::make_unique<ConstExpr>(Const::V128(value_bits, GetLocation())));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq 0x40(%rdi), %r12
movq %r12, %rdi
callq 0x15100
movq %rax, %r13
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rbp
movl $0x90, %edi
callq 0x151f0
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x24(%rax)
movl $0x11, 0x38(%rax)
leaq 0x6699a(%rip), %rcx # 0x81ad8
movq %rcx, (%rax)
movq %r13, 0x40(%rax)
movq %r12, 0x48(%rax)
movq %rbp, 0x50(%rax)
movq $0x0, 0x58(%rax)
movl $0xfffffffb, %ecx # imm = 0xFFFFFFFB
movq %rcx, 0x60(%rax)
movq %r15, 0x70(%rax)
movq %r14, 0x78(%rax)
movl $0x0, 0x80(%rax)
movq %rsp, %r14
movq %rax, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1f410
movl %eax, %ebx
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1b191
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rsp)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/src/binary-reader-ir.cc |
wabt::(anonymous namespace)::BinaryReaderIR::OnI64ConstExpr(unsigned long) | Result BinaryReaderIR::OnI64ConstExpr(uint64_t value) {
return AppendExpr(
std::make_unique<ConstExpr>(Const::I64(value, GetLocation())));
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x40(%rdi), %r15
movq %r15, %rdi
callq 0x15100
movq %rax, %r12
movq 0x8(%rbx), %rax
movq 0x10(%rax), %r13
movl $0x90, %edi
callq 0x151f0
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x24(%rax)
movl $0x11, 0x38(%rax)
leaq 0x66689(%rip), %rcx # 0x81ad8
movq %rcx, (%rax)
movq %r12, 0x40(%rax)
movq %r15, 0x48(%rax)
movq %r13, 0x50(%rax)
movq $0x0, 0x58(%rax)
movl $0xfffffffe, %ecx # imm = 0xFFFFFFFE
movq %rcx, 0x60(%rax)
movq %r14, 0x70(%rax)
movl $0x0, 0x80(%rax)
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1f410
movl %eax, %ebx
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1b4a0
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
| /WebAssembly[P]wabt/src/binary-reader-ir.cc |
wabt::(anonymous namespace)::BinaryReaderIR::OnLocalSetExpr(unsigned int) | Result BinaryReaderIR::OnLocalSetExpr(Index local_index) {
return AppendExpr(
std::make_unique<LocalSetExpr>(Var(local_index, GetLocation())));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movl %esi, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
movups %xmm0, 0xc(%r14)
movaps %xmm0, (%r14)
movq 0x40(%rdi), %r15
movq %r15, %rdi
callq 0x15100
movq %rax, (%r14)
movq %r15, 0x8(%r14)
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%r14)
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x3e686
movl $0x88, %edi
callq 0x151f0
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x24(%rax)
movl $0x19, 0x38(%rax)
leaq 0x664af(%rip), %rax # 0x81cf0
movq %rax, (%r14)
leaq 0x40(%r14), %rdi
movq %r15, %rsi
callq 0x3e72c
leaq 0x8(%rsp), %r15
movq %r14, (%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1f410
movl %eax, %ebx
movq (%r15), %rdi
testq %rdi, %rdi
je 0x1b873
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x3e814
movl %ebx, %eax
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/binary-reader-ir.cc |
wabt::(anonymous namespace)::BinaryReaderIR::OnMemoryInitExpr(unsigned int, unsigned int) | Result BinaryReaderIR::OnMemoryInitExpr(Index segment, Index memidx) {
return AppendExpr(std::make_unique<MemoryInitExpr>(
Var(segment, GetLocation()), Var(memidx, GetLocation())));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %r12
movups %xmm0, 0xc(%r12)
movaps %xmm0, (%r12)
movq 0x40(%rdi), %r14
movq %r14, %rdi
callq 0x15100
movq %rax, (%r12)
movq %r14, 0x8(%r12)
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%r12)
leaq 0xb8(%rsp), %r14
movq %r14, %rdi
movl %r15d, %esi
movq %r12, %rdx
callq 0x3e686
leaq 0x10(%rsp), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0xc(%r15)
movaps %xmm0, (%r15)
movq 0x40(%rbx), %r12
movq %r12, %rdi
callq 0x15100
movq %rax, (%r15)
movq %r12, 0x8(%r15)
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%r15)
leaq 0x70(%rsp), %r12
movq %r12, %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0x3e686
movl $0xd0, %edi
callq 0x151f0
movq %rax, %r15
leaq 0x100(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x3e6d4
leaq 0x50(%rsp), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0xc(%rcx)
movaps %xmm0, (%rcx)
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x232ca
movq %r13, %rdi
callq 0x3e814
leaq 0x8(%rsp), %r14
movq %r15, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1f410
movl %eax, %ebx
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1bfc0
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x3e814
leaq 0xb8(%rsp), %rdi
callq 0x3e814
movl %ebx, %eax
addq $0x148, %rsp # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/src/binary-reader-ir.cc |
wabt::(anonymous namespace)::BinaryReaderIR::OnTableSetExpr(unsigned int) | Result BinaryReaderIR::OnTableSetExpr(Index table_index) {
return AppendExpr(
std::make_unique<TableSetExpr>(Var(table_index, GetLocation())));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movl %esi, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
movups %xmm0, 0xc(%r14)
movaps %xmm0, (%r14)
movq 0x40(%rdi), %r15
movq %r15, %rdi
callq 0x15100
movq %rax, (%r14)
movq %r15, 0x8(%r14)
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%r14)
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x3e686
movl $0x88, %edi
callq 0x151f0
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x24(%rax)
movl $0x38, 0x38(%rax)
leaq 0x65bb5(%rip), %rax # 0x82138
movq %rax, (%r14)
leaq 0x40(%r14), %rdi
movq %r15, %rsi
callq 0x3e72c
leaq 0x8(%rsp), %r15
movq %r14, (%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1f410
movl %eax, %ebx
movq (%r15), %rdi
testq %rdi, %rdi
je 0x1c5b5
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x3e814
movl %ebx, %eax
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/binary-reader-ir.cc |
wabt::(anonymous namespace)::BinaryReaderIR::OnTableGrowExpr(unsigned int) | Result BinaryReaderIR::OnTableGrowExpr(Index table_index) {
return AppendExpr(
std::make_unique<TableGrowExpr>(Var(table_index, GetLocation())));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movl %esi, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
movups %xmm0, 0xc(%r14)
movaps %xmm0, (%r14)
movq 0x40(%rdi), %r15
movq %r15, %rdi
callq 0x15100
movq %rax, (%r14)
movq %r15, 0x8(%r14)
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%r14)
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x3e686
movl $0x88, %edi
callq 0x151f0
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x24(%rax)
movl $0x36, 0x38(%rax)
leaq 0x65b37(%rip), %rax # 0x82188
movq %rax, (%r14)
leaq 0x40(%r14), %rdi
movq %r15, %rsi
callq 0x3e72c
leaq 0x8(%rsp), %r15
movq %r14, (%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1f410
movl %eax, %ebx
movq (%r15), %rdi
testq %rdi, %rdi
je 0x1c683
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x3e814
movl %ebx, %eax
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/binary-reader-ir.cc |
wabt::(anonymous namespace)::BinaryReaderIR::OnRefNullExpr(wabt::Type) | Result BinaryReaderIR::OnRefNullExpr(Type type) {
module_->features_used.exceptions |= (type == Type::ExnRef);
return AppendExpr(std::make_unique<RefNullExpr>(type));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpl $-0x17, %ebx
sete %al
movq 0x18(%rdi), %rcx
orb %al, 0x389(%rcx)
movl $0x48, %edi
callq 0x151f0
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x24(%rax)
movl $0x25, 0x38(%rax)
leaq 0x6595e(%rip), %rcx # 0x822c8
movq %rcx, (%rax)
movq %rbx, 0x3c(%rax)
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x1f410
movl %eax, %ebx
movq (%r15), %rdi
testq %rdi, %rdi
je 0x1c994
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
| /WebAssembly[P]wabt/src/binary-reader-ir.cc |
wabt::(anonymous namespace)::BinaryReaderIR::OnRefIsNullExpr() | Result BinaryReaderIR::OnRefIsNullExpr() {
return AppendExpr(std::make_unique<RefIsNullExpr>());
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x40, %edi
callq 0x151f0
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x24(%rax)
movl $0x23, 0x38(%rax)
leaq 0x65940(%rip), %rcx # 0x82318
movq %rcx, (%rax)
movq %rsp, %r14
movq %rax, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1f410
movl %eax, %ebx
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1c9fc
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rsp)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /WebAssembly[P]wabt/src/binary-reader-ir.cc |
wabt::(anonymous namespace)::BinaryReaderIR::OnStoreExpr(wabt::Opcode, unsigned int, unsigned long, unsigned long) | Result BinaryReaderIR::OnStoreExpr(Opcode opcode,
Index memidx,
Address alignment_log2,
Address offset) {
return AppendExpr(std::make_unique<StoreExpr>(
opcode, Var(memidx, GetLocation()), 1ull << alignment_log2, offset));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %r8, (%rsp)
movq %rcx, %r15
movl %edx, %r12d
movl %esi, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r13
movups %xmm0, 0xc(%r13)
movaps %xmm0, (%r13)
movq 0x40(%rdi), %r14
movq %r14, %rdi
callq 0x15100
movq %rax, (%r13)
movq %r14, 0x8(%r13)
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%r13)
leaq 0x58(%rsp), %r14
movq %r14, %rdi
movl %r12d, %esi
movq %r13, %rdx
callq 0x3e686
movl $0x1, %r12d
movl %r15d, %ecx
shlq %cl, %r12
movl $0xa0, %edi
callq 0x151f0
movq %rax, %r15
leaq 0xa0(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x3e6d4
leaq 0x30(%rsp), %r9
xorps %xmm0, %xmm0
movups %xmm0, 0xc(%r9)
movaps %xmm0, (%r9)
movq %r15, %rdi
movl %ebp, %esi
movq %r13, %rdx
movq %r12, %rcx
movq (%rsp), %r8
callq 0x239d4
movq %r13, %rdi
callq 0x3e814
leaq 0x8(%rsp), %r14
movq %r15, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1f410
movl %eax, %ebx
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1d047
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x3e814
movl %ebx, %eax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/src/binary-reader-ir.cc |
wabt::(anonymous namespace)::BinaryReaderIR::OnLoadZeroExpr(wabt::Opcode, unsigned int, unsigned long, unsigned long) | Result BinaryReaderIR::OnLoadZeroExpr(Opcode opcode,
Index memidx,
Address alignment_log2,
Address offset) {
return AppendExpr(std::make_unique<LoadZeroExpr>(
opcode, Var(memidx, GetLocation()), 1ull << alignment_log2, offset));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %r8, (%rsp)
movq %rcx, %r15
movl %edx, %r12d
movl %esi, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r13
movups %xmm0, 0xc(%r13)
movaps %xmm0, (%r13)
movq 0x40(%rdi), %r14
movq %r14, %rdi
callq 0x15100
movq %rax, (%r13)
movq %r14, 0x8(%r13)
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%r13)
leaq 0x58(%rsp), %r14
movq %r14, %rdi
movl %r12d, %esi
movq %r13, %rdx
callq 0x3e686
movl $0x1, %r12d
movl %r15d, %ecx
shlq %cl, %r12
movl $0xa0, %edi
callq 0x151f0
movq %rax, %r15
leaq 0xa0(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x3e6d4
leaq 0x30(%rsp), %r9
xorps %xmm0, %xmm0
movups %xmm0, 0xc(%r9)
movaps %xmm0, (%r9)
movq %r15, %rdi
movl %ebp, %esi
movq %r13, %rdx
movq %r12, %rcx
movq (%rsp), %r8
callq 0x24582
movq %r13, %rdi
callq 0x3e814
leaq 0x8(%rsp), %r14
movq %r15, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1f410
movl %eax, %ebx
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1db83
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x3e814
movl %ebx, %eax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/src/binary-reader-ir.cc |
wabt::(anonymous namespace)::BinaryReaderIR::BeginElemSegment(unsigned int, unsigned int, unsigned char) | Result BinaryReaderIR::BeginElemSegment(Index index,
Index table_index,
uint8_t flags) {
auto field = std::make_unique<ElemSegmentModuleField>(GetLocation());
ElemSegment& elem_segment = field->elem_segment;
elem_segment.table_var = Var(table_index, GetLocation());
if ((flags & SegDeclared) == SegDeclared) {
elem_segment.kind = SegmentKind::Declared;
} else if ((flags & SegPassive) == SegPassive) {
elem_segment.kind = SegmentKind::Passive;
} else {
elem_segment.kind = SegmentKind::Active;
}
module_->AppendField(std::move(field));
return Result::Ok;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %ecx, %ebp
movl %edx, 0x4(%rsp)
movq %rdi, %rbx
movq 0x40(%rdi), %r12
movq %r12, %rdi
callq 0x15100
movq %rax, %r13
movq 0x8(%rbx), %rax
movq 0x10(%rax), %r15
movl $0xe8, %edi
callq 0x151f0
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq %r13, 0x18(%rax)
movq %r12, 0x20(%rax)
movq %r15, 0x28(%rax)
xorl %eax, %eax
movq %rax, 0x30(%r14)
movl $0x6, 0x38(%r14)
leaq 0x64e23(%rip), %rcx # 0x82a48
movq %rcx, (%r14)
movl $0x0, 0x40(%r14)
leaq 0x58(%r14), %rcx
movq %rcx, 0x48(%r14)
movq %rax, 0x50(%r14)
movb $0x0, 0x58(%r14)
leaq 0x68(%r14), %r12
movq %r12, %rdi
callq 0x3e66c
xorps %xmm0, %xmm0
movups %xmm0, 0xd8(%r14)
movups %xmm0, 0xc8(%r14)
movups %xmm0, 0xb8(%r14)
leaq 0x10(%rsp), %r13
movups %xmm0, 0xc(%r13)
movaps %xmm0, (%r13)
movq 0x40(%rbx), %r15
movq %r15, %rdi
callq 0x15100
movq %rax, (%r13)
movq %r15, 0x8(%r13)
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%r13)
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movl 0x4(%rsp), %esi
movq %r13, %rdx
callq 0x3e686
movq %r12, %rdi
movq %r15, %rsi
callq 0x3e6f2
movq %r15, %rdi
callq 0x3e814
movl %ebp, %eax
notl %eax
andl $0x1, %ebp
testb $0x3, %al
movl $0x2, %eax
cmovnel %ebp, %eax
movl %eax, 0x40(%r14)
movq 0x18(%rbx), %rdi
leaq 0x8(%rsp), %rbx
movq %r14, (%rbx)
movq %rbx, %rsi
callq 0x3d942
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1dcf5
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/binary-reader-ir.cc |
wabt::(anonymous namespace)::BinaryReaderIR::OnElemSegmentElemExprCount(unsigned int, unsigned int) | Result BinaryReaderIR::OnElemSegmentElemExprCount(Index index, Index count) {
assert(index == module_->elem_segments.size() - 1);
ElemSegment* segment = module_->elem_segments[index];
WABT_TRY
segment->elem_exprs.reserve(count);
WABT_CATCH_BAD_ALLOC
return Result::Ok;
} | pushq %rax
movl %esi, %eax
movq 0x18(%rdi), %rsi
movq 0x118(%rsi), %rcx
movq 0x120(%rsi), %rsi
subq %rcx, %rsi
sarq $0x3, %rsi
decq %rsi
cmpq %rax, %rsi
jne 0x1de14
movl $0x90, %edi
addq (%rcx,%rax,8), %rdi
movl %edx, %esi
callq 0x248b0
xorl %eax, %eax
popq %rcx
retq
leaq 0x39f8a(%rip), %rdi # 0x57da5
leaq 0x398a3(%rip), %rsi # 0x576c5
leaq 0x39f12(%rip), %rcx # 0x57d3b
movl $0x592, %edx # imm = 0x592
callq 0x15160
nop
| /WebAssembly[P]wabt/src/binary-reader-ir.cc |
wabt::(anonymous namespace)::BinaryReaderIR::OnFunctionSymbol(unsigned int, unsigned int, std::basic_string_view<char, std::char_traits<char>>, unsigned int) | Result BinaryReaderIR::OnFunctionSymbol(Index index,
uint32_t flags,
std::string_view name,
Index func_index) {
if (name.empty()) {
return Result::Ok;
}
if (func_index >= module_->funcs.size()) {
PrintError("invalid function index: %" PRIindex, func_index);
return Result::Error;
}
Func* func = module_->funcs[func_index];
if (!func->name.empty()) {
// The name section has already named this function.
return Result::Ok;
}
std::string dollar_name =
GetUniqueName(&module_->func_bindings, MakeDollarName(name));
func->name = dollar_name;
module_->func_bindings.emplace(dollar_name, Binding(func_index));
return Result::Ok;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
xorl %r15d, %r15d
testq %rcx, %rcx
je 0x1eb1e
movl %r9d, %ebx
movq %rdi, %r14
movl %r9d, %eax
movq 0x18(%rdi), %r13
movq 0x88(%r13), %rdx
movq 0x90(%r13), %rsi
subq %rdx, %rsi
sarq $0x3, %rsi
cmpq %rax, %rsi
jbe 0x1eb05
movq (%rdx,%rax,8), %r12
cmpq $0x0, 0x8(%r12)
jne 0x1eb1e
addq $0x1c8, %r13 # imm = 0x1C8
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %rcx, %rsi
movq %r8, %rdx
callq 0x1f7e5
movq %rsp, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x1f920
movq (%r15), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x1eab2
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x15200
movq %rsp, %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x15130
movl $0x1c8, %edi # imm = 0x1C8
addq 0x18(%r14), %rdi
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rcx
movups %xmm0, 0xc(%rcx)
movaps %xmm0, (%rcx)
movl %ebx, 0x20(%rcx)
xorl %r15d, %r15d
xorl %esi, %esi
movq %r13, %rdx
callq 0x2511e
movq (%r13), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x1eb1e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x15200
jmp 0x1eb1e
leaq 0x39474(%rip), %rsi # 0x57f80
movq %r14, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x1f148
movl $0x1, %r15d
movl %r15d, %eax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
| /WebAssembly[P]wabt/src/binary-reader-ir.cc |
wabt::(anonymous namespace)::BinaryReaderIR::OnCodeMetadataCount(unsigned int, unsigned int) | Result BinaryReaderIR::OnCodeMetadataCount(Index function_index, Index count) {
code_metadata_queue_.push_func(module_->funcs[function_index]);
return Result::Ok;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %ecx
movq 0x18(%rdi), %rdx
movq 0x78(%rdi), %rax
movq 0x88(%rdx), %rdx
movq (%rdx,%rcx,8), %r13
movq 0x88(%rdi), %rcx
addq $-0x58, %rcx
cmpq %rcx, %rax
je 0x1ee19
movq %r13, (%rax)
leaq 0x8(%rax), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x38(%rax)
movups %xmm0, 0x48(%rax)
xorl %esi, %esi
callq 0x2587e
movq 0x78(%rbx), %rax
addq $0x58, %rax
jmp 0x1f002
movq 0x90(%rbx), %rdx
movq 0x68(%rbx), %rcx
movq 0x70(%rbx), %rsi
movq %rdx, %r14
subq %rsi, %r14
sarq $0x3, %r14
cmpq $0x1, %rdx
movq %r14, %rdi
adcq $-0x1, %rdi
subq 0x80(%rbx), %rax
leaq (%rdi,%rdi,4), %rdi
sarq $0x3, %rax
movabsq $0x2e8ba2e8ba2e8ba3, %r8 # imm = 0x2E8BA2E8BA2E8BA3
imulq %r8, %rax
addq %rdi, %rax
subq 0x58(%rbx), %rcx
sarq $0x3, %rcx
imulq %r8, %rcx
addq %rax, %rcx
movabsq $0x1745d1745d1745d, %rax # imm = 0x1745D1745D1745D
cmpq %rax, %rcx
je 0x1f01f
movq 0x48(%rbx), %rax
movq 0x50(%rbx), %rbp
movq %rdx, %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movq %rbp, %rdi
subq %rcx, %rdi
cmpq $0x1, %rdi
ja 0x1ef99
leaq 0x1(%r14), %r15
leaq 0x4(,%r14,2), %rcx
cmpq %rcx, %rbp
jbe 0x1eedc
addq $0x2, %r14
subq %r14, %rbp
andq $-0x2, %rbp
leaq (%rax,%rbp,4), %r14
addq $0x8, %rdx
cmpq %rsi, %r14
jae 0x1ef4e
subq %rsi, %rdx
je 0x1ef5f
movq %r14, %rdi
jmp 0x1ef5a
movq %r15, (%rsp)
cmpq $0x1, %rbp
adcq %rbp, %rbp
leaq 0x2(%rbp), %r15
movq %r15, %rax
shrq $0x3c, %rax
jne 0x1f017
leaq (,%r15,8), %rdi
callq 0x151f0
movq %rax, %r12
subq %r14, %rbp
andq $-0x2, %rbp
leaq (%rax,%rbp,4), %r14
movq 0x70(%rbx), %rsi
movq 0x90(%rbx), %rdx
addq $0x8, %rdx
subq %rsi, %rdx
je 0x1ef2f
movq %r14, %rdi
callq 0x153d0
movq 0x48(%rbx), %rdi
movq 0x50(%rbx), %rsi
shlq $0x3, %rsi
callq 0x15200
movq %r12, 0x48(%rbx)
movq %r15, 0x50(%rbx)
movq (%rsp), %r15
jmp 0x1ef5f
subq %rsi, %rdx
je 0x1ef5f
leaq (%r14,%r15,8), %rdi
subq %rdx, %rdi
callq 0x153d0
movq %r14, 0x70(%rbx)
movq (%r14), %rax
movq %rax, 0x60(%rbx)
movl $0x1b8, %ecx # imm = 0x1B8
addq %rcx, %rax
movq %rax, 0x68(%rbx)
leaq (%r14,%r15,8), %rax
addq $-0x8, %rax
movq %rax, 0x90(%rbx)
movq (%rax), %rax
movq %rax, 0x80(%rbx)
addq %rcx, %rax
movq %rax, 0x88(%rbx)
movl $0x1b8, %edi # imm = 0x1B8
callq 0x151f0
movq 0x90(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x78(%rbx), %rax
movq %r13, (%rax)
leaq 0x8(%rax), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rax)
movups %xmm0, 0x38(%rax)
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x8(%rax)
xorl %esi, %esi
callq 0x2587e
movq 0x90(%rbx), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x90(%rbx)
movq 0x8(%rax), %rax
movq %rax, 0x80(%rbx)
leaq 0x1b8(%rax), %rcx
movq %rcx, 0x88(%rbx)
movq %rax, 0x78(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
callq 0x15484
leaq 0x390db(%rip), %rdi # 0x58101
callq 0x15120
nop
| /WebAssembly[P]wabt/src/binary-reader-ir.cc |
wabt::(anonymous namespace)::BinaryReaderIR::OnCodeMetadata(unsigned long, void const*, unsigned long) | Result BinaryReaderIR::OnCodeMetadata(Offset offset,
const void* data,
Address size) {
std::vector<uint8_t> data_(static_cast<const uint8_t*>(data),
static_cast<const uint8_t*>(data) + size);
auto meta = std::make_unique<CodeMetadataExpr>(current_metadata_name_,
std::move(data_));
meta->loc.offset = offset;
code_metadata_queue_.push_metadata(std::move(meta));
return Result::Ok;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq (%rcx,%rdx), %rax
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r15
movaps %xmm0, (%r15)
xorl %r12d, %r12d
movq %r12, 0x10(%r15)
movq %r15, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x2595c
movl $0x68, %edi
callq 0x151f0
movups 0x98(%rbx), %xmm0
movaps (%r15), %xmm1
movq 0x10(%r15), %rcx
movq %r12, 0x10(%r15)
xorps %xmm2, %xmm2
movaps %xmm2, (%r15)
movups %xmm2, 0x24(%rax)
movups %xmm2, 0x8(%rax)
movups %xmm2, 0x18(%rax)
movl $0xf, 0x38(%rax)
leaq 0x63a98(%rip), %rdx # 0x82b38
movq %rdx, (%rax)
movups %xmm0, 0x40(%rax)
movups %xmm1, 0x50(%rax)
movq %rcx, 0x60(%rax)
movq %r14, 0x28(%rax)
movq %rax, 0x8(%rsp)
movq 0x78(%rbx), %rdi
cmpq 0x58(%rbx), %rdi
je 0x1f128
cmpq 0x80(%rbx), %rdi
jne 0x1f0db
movq 0x90(%rbx), %rax
movl $0x1b8, %edi # imm = 0x1B8
addq -0x8(%rax), %rdi
addq $-0x50, %rdi
leaq 0x8(%rsp), %rbx
movq %rbx, %rsi
callq 0x25a14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1f0fa
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1f11a
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x39002(%rip), %rdi # 0x58131
leaq 0x3858f(%rip), %rsi # 0x576c5
leaq 0x39005(%rip), %rcx # 0x58142
movl $0x3c, %edx
callq 0x15160
nop
| /WebAssembly[P]wabt/src/binary-reader-ir.cc |
wabt::(anonymous namespace)::BinaryReaderIR::AppendExpr(std::unique_ptr<wabt::Expr, std::default_delete<wabt::Expr>>) | Result BinaryReaderIR::AppendExpr(std::unique_ptr<Expr> expr) {
expr->loc = GetLocation();
LabelNode* label;
CHECK_RESULT(TopLabel(&label));
label->exprs->push_back(std::move(expr));
return Result::Ok;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x40(%rdi), %r15
movq %r15, %rdi
callq 0x15100
movq 0x8(%r14), %rcx
movq 0x10(%rcx), %rcx
movq (%rbx), %rdx
movq %rax, 0x18(%rdx)
movq %r15, 0x20(%rdx)
movq %rcx, 0x28(%rdx)
movq $0x0, 0x30(%rdx)
movq 0x28(%r14), %r15
movq 0x30(%r14), %r12
movq %r12, %rax
subq %r15, %rax
je 0x1f462
addq %r15, %rax
addq $-0x18, %rax
jmp 0x1f487
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
leaq 0x383d7(%rip), %rsi # 0x57852
movq %r14, %rdi
xorl %edx, %edx
xorl %eax, %eax
callq 0x1f148
cmpq %r15, %r12
je 0x1f4ce
movq 0x8(%rax), %rax
movq (%rbx), %rcx
movq $0x0, (%rbx)
cmpq $0x0, 0x10(%rcx)
jne 0x1f4df
cmpq $0x0, 0x8(%rcx)
jne 0x1f4df
movq 0x8(%rax), %rdx
movq %rax, %rsi
testq %rdx, %rdx
je 0x1f4bf
movq %rdx, 0x10(%rcx)
addq $0x8, %rdx
movq %rdx, %rsi
movq %rcx, (%rsi)
movq %rcx, 0x8(%rax)
incq 0x10(%rax)
xorl %eax, %eax
jmp 0x1f4d3
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x38392(%rip), %rdi # 0x57878
leaq 0x37f3f(%rip), %rsi # 0x5742c
leaq 0x383b5(%rip), %rcx # 0x578a9
movl $0x1bd, %edx # imm = 0x1BD
callq 0x15160
| /WebAssembly[P]wabt/src/binary-reader-ir.cc |
wabt::(anonymous namespace)::BinaryReaderIR::SetBlockDeclaration(wabt::FuncDeclaration*, wabt::Type) | void BinaryReaderIR::SetBlockDeclaration(BlockDeclaration* decl,
Type sig_type) {
if (sig_type.IsIndex()) {
Index type_index = sig_type.GetIndex();
SetFuncDeclaration(decl, Var(type_index, GetLocation()));
} else {
decl->has_func_type = false;
decl->sig.param_types.clear();
decl->sig.result_types = sig_type.GetInlineVector();
}
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdx, 0x8(%rsp)
testl %r15d, %r15d
js 0x1f581
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r12
movups %xmm0, 0xc(%r12)
movaps %xmm0, (%r12)
movq 0x40(%rdi), %r13
movq %r13, %rdi
callq 0x15100
movq %rax, (%r12)
movq %r13, 0x8(%r12)
movq 0x8(%r14), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%r12)
leaq 0x38(%rsp), %r13
movq %r13, %rdi
movl %r15d, %esi
movq %r12, %rdx
callq 0x3e686
movq %r14, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x1f25a
movq %r13, %rdi
callq 0x3e814
jmp 0x1f5c8
movb $0x0, (%rbx)
movq 0x50(%rbx), %rax
cmpq %rax, 0x58(%rbx)
je 0x1f592
movq %rax, 0x58(%rbx)
leaq 0x10(%rsp), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x2242e
addq $0x68, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x224cc
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1f5c8
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
| /WebAssembly[P]wabt/src/binary-reader-ir.cc |
wabt::(anonymous namespace)::BinaryReaderIR::AppendCatch(wabt::Catch&&) | Result BinaryReaderIR::AppendCatch(Catch&& catch_) {
LabelNode* label = nullptr;
CHECK_RESULT(TopLabel(&label));
if (label->label_type != LabelType::Try) {
PrintError("catch not inside try block");
return Result::Error;
}
auto* try_ = cast<TryExpr>(label->context);
if (catch_.IsCatchAll() && !try_->catches.empty() &&
try_->catches.back().IsCatchAll()) {
PrintError("only one catch_all allowed in try block");
return Result::Error;
}
if (try_->kind == TryKind::Plain) {
try_->kind = TryKind::Catch;
} else if (try_->kind != TryKind::Catch) {
PrintError("catch not allowed in try-delegate");
return Result::Error;
}
try_->catches.push_back(std::move(catch_));
label->exprs = &try_->catches.back().exprs;
return Result::Ok;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rdi), %r12
movq 0x30(%rdi), %r13
movq %r13, %rax
subq %r12, %rax
je 0x1f605
leaq (%r12,%rax), %r15
addq $-0x18, %r15
jmp 0x1f62d
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
leaq 0x38234(%rip), %rsi # 0x57852
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %edx, %edx
xorl %eax, %eax
callq 0x1f148
movl $0x1, %ebp
cmpq %r12, %r13
je 0x1f6db
cmpl $0x6, (%r15)
jne 0x1f686
movq 0x10(%r15), %r12
cmpl $0x3d, 0x38(%r12)
jne 0x1f6ec
cmpl $0x0, 0x40(%r14)
jne 0x1f68f
cmpl $-0x1, 0x48(%r14)
jne 0x1f68f
movq 0x120(%r12), %rax
cmpq %rax, 0x118(%r12)
je 0x1f68f
cmpl $0x0, -0x40(%rax)
jne 0x1f68f
cmpl $-0x1, -0x38(%rax)
jne 0x1f68f
leaq 0x382d0(%rip), %rsi # 0x57954
jmp 0x1f6d1
leaq 0x382ac(%rip), %rsi # 0x57939
jmp 0x1f6d1
movl 0x3c(%r12), %eax
cmpl $0x1, %eax
je 0x1f6a6
testl %eax, %eax
jne 0x1f6ca
movl $0x1, 0x3c(%r12)
leaq 0x118(%r12), %rdi
movq %r14, %rsi
callq 0x22988
movq 0x120(%r12), %rax
addq $-0x18, %rax
movq %rax, 0x8(%r15)
xorl %ebp, %ebp
jmp 0x1f6db
leaq 0x382ab(%rip), %rsi # 0x5797c
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1f148
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x382ab(%rip), %rdi # 0x5799e
leaq 0x382b7(%rip), %rsi # 0x579b1
leaq 0x38309(%rip), %rcx # 0x57a0a
movl $0x4e, %edx
callq 0x15160
nop
| /WebAssembly[P]wabt/src/binary-reader-ir.cc |
wabt::FuncType::~FuncType() | static bool classof(const TypeEntry* entry) {
return entry->kind() == TypeEntryKind::Func;
} | pushq %rbx
movq %rdi, %rbx
leaq 0x60991(%rip), %rax # 0x80ee0
movq %rax, (%rdi)
movq 0x68(%rdi), %rdi
testq %rdi, %rdi
je 0x20567
movq 0x78(%rbx), %rsi
subq %rdi, %rsi
callq 0x15200
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x2057c
movq 0x60(%rbx), %rsi
subq %rdi, %rsi
callq 0x15200
leaq 0x609a5(%rip), %rax # 0x80f28
movq %rax, (%rbx)
movq 0x28(%rbx), %rdi
addq $0x38, %rbx
cmpq %rbx, %rdi
je 0x2059f
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x15200
popq %rbx
retq
nop
| /WebAssembly[P]wabt/include/wabt/ir.h |
wabt::FuncType::~FuncType() | static bool classof(const TypeEntry* entry) {
return entry->kind() == TypeEntryKind::Func;
} | pushq %rbx
movq %rdi, %rbx
leaq 0x60933(%rip), %rax # 0x80ee0
movq %rax, (%rdi)
movq 0x68(%rdi), %rdi
testq %rdi, %rdi
je 0x205c5
movq 0x78(%rbx), %rsi
subq %rdi, %rsi
callq 0x15200
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x205da
movq 0x60(%rbx), %rsi
subq %rdi, %rsi
callq 0x15200
leaq 0x60947(%rip), %rax # 0x80f28
movq %rax, (%rbx)
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x205fc
movq (%rax), %rsi
incq %rsi
callq 0x15200
movl $0x88, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x15200
| /WebAssembly[P]wabt/include/wabt/ir.h |
wabt::TypeEntry::~TypeEntry() | virtual ~TypeEntry() = default; | movq %rdi, %rax
leaq 0x60914(%rip), %rcx # 0x80f28
movq %rcx, (%rdi)
movq 0x28(%rdi), %rdi
addq $0x38, %rax
cmpq %rax, %rdi
je 0x2062f
movq (%rax), %rsi
incq %rsi
jmp 0x15200
retq
| /WebAssembly[P]wabt/include/wabt/ir.h |
wabt::StructType::~StructType() | static bool classof(const TypeEntry* entry) {
return entry->kind() == TypeEntryKind::Struct;
} | pushq %rbx
movq %rdi, %rbx
leaq 0x60747(%rip), %rax # 0x80f48
movq %rax, (%rdi)
addq $0x50, %rdi
callq 0x2083e
leaq 0x60714(%rip), %rax # 0x80f28
movq %rax, (%rbx)
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x2082f
movq (%rax), %rsi
incq %rsi
callq 0x15200
movl $0x68, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x15200
nop
| /WebAssembly[P]wabt/include/wabt/ir.h |
wabt::ArrayType::~ArrayType() | static bool classof(const TypeEntry* entry) {
return entry->kind() == TypeEntryKind::Array;
} | pushq %rbx
movq %rdi, %rbx
leaq 0x60413(%rip), %rax # 0x80f80
movq %rax, (%rdi)
movq 0x50(%rdi), %rdi
leaq 0x60(%rbx), %rax
cmpq %rax, %rdi
je 0x20b88
movq (%rax), %rsi
incq %rsi
callq 0x15200
leaq 0x60399(%rip), %rax # 0x80f28
movq %rax, (%rbx)
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x20baa
movq (%rax), %rsi
incq %rsi
callq 0x15200
movl $0x80, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x15200
| /WebAssembly[P]wabt/include/wabt/ir.h |
wabt::Func::Func(std::basic_string_view<char, std::char_traits<char>>) | explicit Func(std::string_view name) : name(name) {} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
leaq (%rsi,%rdx), %rax
movq %rdx, %rsi
movq %rax, %rdx
callq 0x16a80
xorl %ebp, %ebp
movb %bpl, 0x20(%rbx)
leaq 0x28(%rbx), %rdi
callq 0x3e66c
leaq 0xe8(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0xa0(%rbx)
movups %xmm0, 0x90(%rbx)
movups %xmm0, 0x80(%rbx)
movups %xmm0, 0x70(%rbx)
movq $0x0, 0xb0(%rbx)
movq %rax, 0xb8(%rbx)
movq $0x1, 0xc0(%rbx)
movups %xmm0, 0xc8(%rbx)
movl $0x3f800000, 0xd8(%rbx) # imm = 0x3F800000
movb %bpl, 0x128(%rbx)
movups %xmm0, 0xe0(%rbx)
movups %xmm0, 0xf0(%rbx)
movups %xmm0, 0x100(%rbx)
movups %xmm0, 0x110(%rbx)
movl $0x0, 0x120(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
| /WebAssembly[P]wabt/include/wabt/ir.h |
wabt::Func::~Func() | explicit Func(std::string_view name) : name(name) {} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xf0(%rdi), %r14
movq 0xf0(%rdi), %rdi
testq %rdi, %rdi
je 0x20dad
movq (%rdi), %rax
movq 0x8(%rdi), %r15
callq *0x8(%rax)
movq %r15, %rdi
testq %r15, %r15
jne 0x20d9b
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
leaq 0xb8(%rbx), %rdi
callq 0x1699c
movq 0xa0(%rbx), %rdi
testq %rdi, %rdi
je 0x20de3
movq 0xb0(%rbx), %rsi
subq %rdi, %rsi
callq 0x15200
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0x20dfe
movq 0x98(%rbx), %rsi
subq %rdi, %rsi
callq 0x15200
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x20e16
movq 0x80(%rbx), %rsi
subq %rdi, %rsi
callq 0x15200
leaq 0x28(%rbx), %rdi
callq 0x3e814
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x20e3b
movq (%rbx), %rsi
incq %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x15200
popq %rbx
popq %r14
popq %r15
retq
nop
| /WebAssembly[P]wabt/include/wabt/ir.h |
wabt::TableImport::~TableImport() | explicit TableImport(std::string_view name = std::string_view())
: ImportMixin<ExternalKind::Table>(), table(name) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x60109(%rip), %rax # 0x81088
movq %rax, (%rdi)
movq 0x50(%rdi), %rdi
leaq 0x60(%rbx), %rax
cmpq %rax, %rdi
je 0x20f9a
movq (%rax), %rsi
incq %rsi
callq 0x15200
movq %rbx, %rdi
popq %rbx
jmp 0x2129e
nop
| /WebAssembly[P]wabt/include/wabt/ir.h |
wabt::TableImport::~TableImport() | explicit TableImport(std::string_view name = std::string_view())
: ImportMixin<ExternalKind::Table>(), table(name) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x600d9(%rip), %rax # 0x81088
movq %rax, (%rdi)
movq 0x50(%rdi), %rdi
leaq 0x60(%rbx), %rax
cmpq %rax, %rdi
je 0x20fca
movq (%rax), %rsi
incq %rsi
callq 0x15200
movq %rbx, %rdi
callq 0x2129e
movl $0x90, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x15200
| /WebAssembly[P]wabt/include/wabt/ir.h |
wabt::MemoryImport::~MemoryImport() | explicit MemoryImport(std::string_view name = std::string_view())
: ImportMixin<ExternalKind::Memory>(), memory(name) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x600ed(%rip), %rax # 0x810d8
movq %rax, (%rdi)
movq 0x50(%rdi), %rdi
leaq 0x60(%rbx), %rax
cmpq %rax, %rdi
je 0x21006
movq (%rax), %rsi
incq %rsi
callq 0x15200
movq %rbx, %rdi
popq %rbx
jmp 0x2129e
nop
| /WebAssembly[P]wabt/include/wabt/ir.h |
wabt::MemoryImport::~MemoryImport() | explicit MemoryImport(std::string_view name = std::string_view())
: ImportMixin<ExternalKind::Memory>(), memory(name) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x600bd(%rip), %rax # 0x810d8
movq %rax, (%rdi)
movq 0x50(%rdi), %rdi
leaq 0x60(%rbx), %rax
cmpq %rax, %rdi
je 0x21036
movq (%rax), %rsi
incq %rsi
callq 0x15200
movq %rbx, %rdi
callq 0x2129e
movl $0x90, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x15200
| /WebAssembly[P]wabt/include/wabt/ir.h |
wabt::GlobalImport::~GlobalImport() | explicit GlobalImport(std::string_view name = std::string_view())
: ImportMixin<ExternalKind::Global>(), global(name) {} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x600cd(%rip), %rax # 0x81128
movq %rax, (%rdi)
leaq 0x80(%rdi), %r14
movq 0x80(%rdi), %rdi
testq %rdi, %rdi
je 0x21083
movq (%rdi), %rax
movq 0x8(%rdi), %r15
callq *0x8(%rax)
movq %r15, %rdi
testq %r15, %r15
jne 0x21071
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0x50(%rbx), %rdi
leaq 0x60(%rbx), %rax
cmpq %rax, %rdi
je 0x210aa
movq (%rax), %rsi
incq %rsi
callq 0x15200
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2129e
nop
| /WebAssembly[P]wabt/include/wabt/ir.h |
wabt::TagImport::TagImport(std::basic_string_view<char, std::char_traits<char>>) | explicit TagImport(std::string_view name = std::string_view())
: ImportMixin<ExternalKind::Tag>(), tag(name) {} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
xorl %r14d, %r14d
movq %r14, 0x10(%rdi)
movb %r14b, 0x18(%rdi)
leaq 0x38(%rdi), %rax
movq %rax, 0x28(%rdi)
movq %r14, 0x30(%rdi)
movb %r14b, 0x38(%rdi)
movl $0x4, 0x48(%rdi)
leaq 0x60010(%rip), %rax # 0x81178
movq %rax, (%rdi)
addq $0x50, %rdi
leaq 0x60(%rbx), %rax
movq %rax, 0x50(%rbx)
leaq (%rsi,%rdx), %rax
movq %rdx, %rsi
movq %rax, %rdx
callq 0x16a80
movb %r14b, 0x70(%rbx)
leaq 0x78(%rbx), %rdi
callq 0x3e66c
xorps %xmm0, %xmm0
movups %xmm0, 0xe0(%rbx)
movups %xmm0, 0xd0(%rbx)
movups %xmm0, 0xc0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /WebAssembly[P]wabt/include/wabt/ir.h |
wabt::GlobalModuleField::~GlobalModuleField() | explicit GlobalModuleField(const Location& loc = Location(),
std::string_view name = std::string_view())
: ModuleFieldMixin<ModuleFieldType::Global>(loc), global(name) {} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x5fbaf(%rip), %rax # 0x812b8
movq %rax, (%rdi)
leaq 0x70(%rdi), %r14
movq 0x70(%rdi), %rdi
testq %rdi, %rdi
je 0x2172b
movq (%rdi), %rax
movq 0x8(%rdi), %r15
callq *0x8(%rax)
movq %r15, %rdi
testq %r15, %r15
jne 0x21719
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0x40(%rbx), %rdi
leaq 0x50(%rbx), %rax
cmpq %rax, %rdi
je 0x21752
movq (%rax), %rsi
incq %rsi
callq 0x15200
movl $0x88, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x15200
| /WebAssembly[P]wabt/include/wabt/ir.h |
wabt::LoadStoreExpr<(wabt::ExprType)1>::LoadStoreExpr(wabt::Opcode, wabt::Var, unsigned long, unsigned long, wabt::Location const&) | LoadStoreExpr(Opcode opcode,
Var memidx,
Address align,
Address offset,
const Location& loc = Location())
: MemoryExpr<TypeEnum>(memidx, loc),
opcode(opcode),
align(align),
offset(offset) {} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %r12
movq %r8, %rbx
movq %rcx, %r14
movl %esi, %ebp
movq %rdi, %r15
movq %rsp, %r13
movq %r13, %rdi
movq %rdx, %rsi
callq 0x3e72c
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r15)
leaq 0x5f585(%rip), %rax # 0x81468
movq %rax, (%r15)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm0, 0x18(%r15)
movups %xmm1, 0x28(%r15)
movl $0x1, 0x38(%r15)
leaq 0x5f66e(%rip), %rax # 0x81578
movq %rax, (%r15)
leaq 0x40(%r15), %rdi
movq %r13, %rsi
callq 0x3e72c
movq %r13, %rdi
callq 0x3e814
leaq 0x5f5e8(%rip), %rax # 0x81510
movq %rax, (%r15)
movl %ebp, 0x88(%r15)
movq %r14, 0x90(%r15)
movq %rbx, 0x98(%r15)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/include/wabt/ir.h |
wabt::BlockExprBase<(wabt::ExprType)8>::~BlockExprBase() | explicit BlockExprBase(const Location& loc = Location())
: ExprMixin<TypeEnum>(loc) {} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x5f443(%rip), %rax # 0x817d0
movq %rax, (%rdi)
leaq 0xe0(%rdi), %r14
movq 0xe0(%rdi), %rdi
testq %rdi, %rdi
je 0x223b5
movq (%rdi), %rax
movq 0x8(%rdi), %r15
callq *0x8(%rax)
movq %r15, %rdi
testq %r15, %r15
jne 0x223a3
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0xc8(%rbx), %rdi
testq %rdi, %rdi
je 0x223df
movq 0xd8(%rbx), %rsi
subq %rdi, %rsi
callq 0x15200
movq 0xb0(%rbx), %rdi
testq %rdi, %rdi
je 0x223fa
movq 0xc0(%rbx), %rsi
subq %rdi, %rsi
callq 0x15200
leaq 0x68(%rbx), %rdi
callq 0x3e814
movq 0x40(%rbx), %rdi
leaq 0x50(%rbx), %rax
cmpq %rax, %rdi
je 0x2241b
movq (%rax), %rsi
incq %rsi
callq 0x15200
movl $0x118, %esi # imm = 0x118
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x15200
nop
| /WebAssembly[P]wabt/include/wabt/ir.h |
wabt::Type::GetInlineVector() const | bool IsIndex() const { return static_cast<int32_t>(enum_) >= 0; } | pushq %r14
pushq %rbx
pushq %rax
movl (%rsi), %eax
testl %eax, %eax
jns 0x224a7
addl $0x40, %eax
cmpl $0x3f, %eax
ja 0x224c6
movq %rdi, %rbx
movabsq $-0x7fe760000000000, %rcx # imm = 0xF8018A0000000000
btq %rax, %rcx
jae 0x22492
movq %rsi, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movl $0x8, %edi
callq 0x151f0
movq %rax, (%rbx)
leaq 0x8(%rax), %rcx
movq %rcx, 0x10(%rbx)
movq (%r14), %rdx
movq %rdx, (%rax)
movq %rcx, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
testq %rax, %rax
jne 0x224c6
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
jmp 0x22487
leaq 0x35451(%rip), %rdi # 0x578ff
leaq 0x35192(%rip), %rsi # 0x57647
leaq 0x3544e(%rip), %rcx # 0x5790a
movl $0xa1, %edx
callq 0x15160
callq 0x15150
nop
| /WebAssembly[P]wabt/include/wabt/type.h |
wabt::LoadStoreExpr<(wabt::ExprType)23>::LoadStoreExpr(wabt::Opcode, wabt::Var, unsigned long, unsigned long, wabt::Location const&) | LoadStoreExpr(Opcode opcode,
Var memidx,
Address align,
Address offset,
const Location& loc = Location())
: MemoryExpr<TypeEnum>(memidx, loc),
opcode(opcode),
align(align),
offset(offset) {} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %r12
movq %r8, %rbx
movq %rcx, %r14
movl %esi, %ebp
movq %rdi, %r15
movq %rsp, %r13
movq %r13, %rdi
movq %rdx, %rsi
callq 0x3e72c
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r15)
leaq 0x5e579(%rip), %rax # 0x81468
movq %rax, (%r15)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm0, 0x18(%r15)
movups %xmm1, 0x28(%r15)
movl $0x17, 0x38(%r15)
leaq 0x5ed6a(%rip), %rax # 0x81c80
movq %rax, (%r15)
leaq 0x40(%r15), %rdi
movq %r13, %rsi
callq 0x3e72c
movq %r13, %rdi
callq 0x3e814
leaq 0x5ece4(%rip), %rax # 0x81c18
movq %rax, (%r15)
movl %ebp, 0x88(%r15)
movq %r14, 0x90(%r15)
movq %rbx, 0x98(%r15)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/include/wabt/ir.h |
wabt::BlockExprBase<(wabt::ExprType)27>::~BlockExprBase() | explicit BlockExprBase(const Location& loc = Location())
: ExprMixin<TypeEnum>(loc) {} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x5ed17(%rip), %rax # 0x81d90
movq %rax, (%rdi)
leaq 0xe0(%rdi), %r14
movq 0xe0(%rdi), %rdi
testq %rdi, %rdi
je 0x230a1
movq (%rdi), %rax
movq 0x8(%rdi), %r15
callq *0x8(%rax)
movq %r15, %rdi
testq %r15, %r15
jne 0x2308f
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0xc8(%rbx), %rdi
testq %rdi, %rdi
je 0x230cb
movq 0xd8(%rbx), %rsi
subq %rdi, %rsi
callq 0x15200
movq 0xb0(%rbx), %rdi
testq %rdi, %rdi
je 0x230e6
movq 0xc0(%rbx), %rsi
subq %rdi, %rsi
callq 0x15200
leaq 0x68(%rbx), %rdi
callq 0x3e814
movq 0x40(%rbx), %rdi
addq $0x50, %rbx
cmpq %rbx, %rdi
je 0x2310c
movq (%rbx), %rsi
incq %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x15200
popq %rbx
popq %r14
popq %r15
retq
| /WebAssembly[P]wabt/include/wabt/ir.h |
wabt::TryExpr::~TryExpr() | explicit TryExpr(const Location& loc = Location())
: ExprMixin<ExprType::Try>(loc), kind(TryKind::Plain) {} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x5ea2f(%rip), %rax # 0x82610
movq %rax, (%rdi)
addq $0x130, %rdi # imm = 0x130
callq 0x3e814
leaq 0x118(%rbx), %rdi
callq 0x23caa
leaq 0xe0(%rbx), %r14
movq 0xe0(%rbx), %rdi
testq %rdi, %rdi
je 0x23c21
movq (%rdi), %rax
movq 0x8(%rdi), %r15
callq *0x8(%rax)
movq %r15, %rdi
testq %r15, %r15
jne 0x23c0f
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0xc8(%rbx), %rdi
testq %rdi, %rdi
je 0x23c4b
movq 0xd8(%rbx), %rsi
subq %rdi, %rsi
callq 0x15200
movq 0xb0(%rbx), %rdi
testq %rdi, %rdi
je 0x23c66
movq 0xc0(%rbx), %rsi
subq %rdi, %rsi
callq 0x15200
leaq 0x68(%rbx), %rdi
callq 0x3e814
movq 0x40(%rbx), %rdi
addq $0x50, %rbx
cmpq %rbx, %rdi
je 0x23c8c
movq (%rbx), %rsi
incq %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x15200
popq %rbx
popq %r14
popq %r15
retq
| /WebAssembly[P]wabt/include/wabt/ir.h |
wabt::(anonymous namespace)::BinaryReader::ReadFunctionSection(unsigned long) | Result BinaryReader::ReadFunctionSection(Offset section_size) {
CALLBACK(BeginFunctionSection, section_size);
CHECK_RESULT(
ReadCount(&num_function_signatures_, "function signature count"));
CALLBACK(OnFunctionCount, num_function_signatures_);
for (Index i = 0; i < num_function_signatures_; ++i) {
Index func_index = num_func_imports_ + i;
Index sig_index;
CHECK_RESULT(ReadIndex(&sig_index, "function signature index"));
CALLBACK(OnFunction, func_index, sig_index);
}
CALLBACK0(EndFunctionSection);
return Result::Ok;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
movq (%rdi), %rax
callq *0xc0(%rax)
testl %eax, %eax
je 0x27ee4
leaq 0x33a8d(%rip), %rsi # 0x5b951
movq %rbx, %rdi
xorl %eax, %eax
callq 0x25f98
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xec(%rbx), %r14
leaq 0x33a84(%rip), %rdx # 0x5b976
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a04a
movl $0x1, %ebp
cmpl $0x1, %eax
je 0x27ed3
movq 0x48(%rbx), %rdi
movl 0xec(%rbx), %esi
movq (%rdi), %rax
callq *0xc8(%rax)
testl %eax, %eax
je 0x27f27
leaq 0x33a6a(%rip), %rsi # 0x5b98f
jmp 0x27ec4
cmpl $0x0, (%r14)
setne %r15b
je 0x27f98
xorl %r12d, %r12d
movl 0xd8(%rbx), %r13d
movq %rbx, %rdi
leaq 0x4(%rsp), %rsi
leaq 0x33a65(%rip), %rdx # 0x5b9af
callq 0x29166
cmpl $0x1, %eax
je 0x27f8e
movl 0x4(%rsp), %edx
addl %r12d, %r13d
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
movl %r13d, %esi
callq *0xd0(%rax)
testl %eax, %eax
jne 0x27f7d
incl %r12d
cmpl (%r14), %r12d
setb %r15b
jb 0x27f34
jmp 0x27f98
leaq 0x33a44(%rip), %rsi # 0x5b9c8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x25f98
testb $0x1, %r15b
jne 0x27ed3
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
callq *0xd8(%rax)
testl %eax, %eax
je 0x27fb5
leaq 0x33a33(%rip), %rsi # 0x5b9e3
jmp 0x27ec4
xorl %ebp, %ebp
jmp 0x27ed3
| /WebAssembly[P]wabt/src/binary-reader.cc |
wabt::(anonymous namespace)::BinaryReader::ReadMemorySection(unsigned long) | Result BinaryReader::ReadMemorySection(Offset section_size) {
CALLBACK(BeginMemorySection, section_size);
Index num_memories;
CHECK_RESULT(ReadCount(&num_memories, "memory count"));
CALLBACK(OnMemoryCount, num_memories);
for (Index i = 0; i < num_memories; ++i) {
Index memory_index = num_memory_imports_ + i;
Limits page_limits;
uint32_t page_size;
CHECK_RESULT(ReadMemory(&page_limits, &page_size));
CALLBACK(OnMemory, memory_index, &page_limits, page_size);
}
CALLBACK0(EndMemorySection);
return Result::Ok;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq 0x48(%rdi), %rdi
movq (%rdi), %rax
callq *0x100(%rax)
testl %eax, %eax
je 0x28116
leaq 0x33984(%rip), %rsi # 0x5ba89
movq %r14, %rdi
xorl %eax, %eax
callq 0x25f98
movl $0x1, %ebx
jmp 0x2815c
leaq 0x3398f(%rip), %rdx # 0x5baac
leaq 0xc(%rsp), %rsi
movq %r14, %rdi
callq 0x2a04a
movl $0x1, %ebx
cmpl $0x1, %eax
je 0x2815c
movq 0x48(%r14), %rdi
movl 0xc(%rsp), %ebp
movq (%rdi), %rax
movl %ebp, %esi
callq *0x108(%rax)
testl %eax, %eax
je 0x2816d
leaq 0x33967(%rip), %rsi # 0x5bab9
movq %r14, %rdi
xorl %eax, %eax
callq 0x25f98
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %ebp, %ebp
je 0x281cb
xorl %r12d, %r12d
leaq 0x10(%rsp), %r15
movl 0xe0(%r14), %r13d
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movl $0x0, 0x1f(%rsp)
movq %r14, %rdi
movq %r15, %rsi
leaq 0x8(%rsp), %rdx
callq 0x2a436
cmpl $0x1, %eax
je 0x2815c
addl %r12d, %r13d
movq 0x48(%r14), %rdi
movl 0x8(%rsp), %ecx
movq (%rdi), %rax
movl %r13d, %esi
movq %r15, %rdx
callq *0x110(%rax)
testl %eax, %eax
jne 0x281ef
incl %r12d
cmpl %r12d, %ebp
jne 0x28179
movq 0x48(%r14), %rdi
movq (%rdi), %rax
callq *0x118(%rax)
testl %eax, %eax
je 0x281e8
leaq 0x3390d(%rip), %rsi # 0x5baf0
jmp 0x28152
xorl %ebx, %ebx
jmp 0x2815c
leaq 0x338e1(%rip), %rsi # 0x5bad7
jmp 0x28152
nop
| /WebAssembly[P]wabt/src/binary-reader.cc |
wabt::(anonymous namespace)::BinaryReader::ReadGlobalSection(unsigned long) | Result BinaryReader::ReadGlobalSection(Offset section_size) {
CALLBACK(BeginGlobalSection, section_size);
Index num_globals;
CHECK_RESULT(ReadCount(&num_globals, "global count"));
CALLBACK(OnGlobalCount, num_globals);
for (Index i = 0; i < num_globals; ++i) {
Index global_index = num_global_imports_ + i;
Type global_type;
bool mutable_;
CHECK_RESULT(ReadGlobalHeader(&global_type, &mutable_));
CALLBACK(BeginGlobal, global_index, global_type, mutable_);
CALLBACK(BeginGlobalInitExpr, global_index);
CHECK_RESULT(ReadInitExpr(global_index));
CALLBACK(EndGlobalInitExpr, global_index);
CALLBACK(EndGlobal, global_index);
}
CALLBACK0(EndGlobalSection);
return Result::Ok;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movq 0x48(%rdi), %rdi
movq (%rdi), %rax
callq *0x120(%rax)
testl %eax, %eax
je 0x28236
leaq 0x338ec(%rip), %rsi # 0x5bb11
movq %r14, %rdi
xorl %eax, %eax
callq 0x25f98
movl $0x1, %ebx
jmp 0x2827c
leaq 0x338f7(%rip), %rdx # 0x5bb34
leaq 0xc(%rsp), %rsi
movq %r14, %rdi
callq 0x2a04a
movl $0x1, %ebx
cmpl $0x1, %eax
je 0x2827c
movq 0x48(%r14), %rdi
movl 0xc(%rsp), %ebp
movq (%rdi), %rax
movl %ebp, %esi
callq *0x128(%rax)
testl %eax, %eax
je 0x2828d
leaq 0x338cf(%rip), %rsi # 0x5bb41
movq %r14, %rdi
xorl %eax, %eax
callq 0x25f98
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %ebp, %ebp
je 0x2832f
xorl %r12d, %r12d
leaq 0xb(%rsp), %r13
movl 0xe4(%r14), %r15d
addl %r12d, %r15d
movq %r14, %rdi
leaq 0x10(%rsp), %rsi
movq %r13, %rdx
callq 0x2a642
cmpl $0x1, %eax
je 0x2827c
movq 0x48(%r14), %rdi
movq 0x10(%rsp), %rdx
movzbl 0xb(%rsp), %ecx
movq (%rdi), %rax
movl %r15d, %esi
callq *0x130(%rax)
testl %eax, %eax
jne 0x28353
movq 0x48(%r14), %rdi
movq (%rdi), %rax
movl %r15d, %esi
callq *0x138(%rax)
testl %eax, %eax
jne 0x2835f
movq %r14, %rdi
callq 0x2a812
cmpl $0x1, %eax
je 0x2827c
movq 0x48(%r14), %rdi
movq (%rdi), %rax
movl %r15d, %esi
callq *0x140(%rax)
testl %eax, %eax
jne 0x2836b
movq 0x48(%r14), %rdi
movq (%rdi), %rax
movl %r15d, %esi
callq *0x148(%rax)
testl %eax, %eax
jne 0x28377
incl %r12d
cmpl %r12d, %ebp
jne 0x2829d
movq 0x48(%r14), %rdi
movq (%rdi), %rax
callq *0x150(%rax)
testl %eax, %eax
je 0x2834c
leaq 0x33894(%rip), %rsi # 0x5bbdb
jmp 0x28272
xorl %ebx, %ebx
jmp 0x2827c
leaq 0x33805(%rip), %rsi # 0x5bb5f
jmp 0x28272
leaq 0x33815(%rip), %rsi # 0x5bb7b
jmp 0x28272
leaq 0x3382d(%rip), %rsi # 0x5bb9f
jmp 0x28272
leaq 0x33843(%rip), %rsi # 0x5bbc1
jmp 0x28272
nop
| /WebAssembly[P]wabt/src/binary-reader.cc |
wabt::(anonymous namespace)::BinaryReader::ReadExportSection(unsigned long) | Result BinaryReader::ReadExportSection(Offset section_size) {
CALLBACK(BeginExportSection, section_size);
Index num_exports;
CHECK_RESULT(ReadCount(&num_exports, "export count"));
CALLBACK(OnExportCount, num_exports);
for (Index i = 0; i < num_exports; ++i) {
std::string_view name;
CHECK_RESULT(ReadStr(&name, "export item name"));
ExternalKind kind;
CHECK_RESULT(ReadExternalKind(&kind, "export kind"));
Index item_index;
CHECK_RESULT(ReadIndex(&item_index, "export item index"));
if (kind == ExternalKind::Tag) {
ERROR_UNLESS(options_.features.exceptions_enabled(),
"invalid export tag kind: exceptions not allowed");
}
CALLBACK(OnExport, i, static_cast<ExternalKind>(kind), item_index, name);
}
CALLBACK0(EndExportSection);
return Result::Ok;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq 0x48(%rdi), %rdi
movq (%rdi), %rax
callq *0x158(%rax)
testl %eax, %eax
je 0x283be
leaq 0x34b2a(%rip), %rsi # 0x5ced7
movq %r14, %rdi
xorl %eax, %eax
callq 0x25f98
movl $0x1, %ebx
jmp 0x28404
leaq 0x34b35(%rip), %rdx # 0x5cefa
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x2a04a
movl $0x1, %ebx
cmpl $0x1, %eax
je 0x28404
movq 0x48(%r14), %rdi
movl 0x8(%rsp), %ebp
movq (%rdi), %rax
movl %ebp, %esi
callq *0x160(%rax)
testl %eax, %eax
je 0x28415
leaq 0x34b0d(%rip), %rsi # 0x5cf07
movq %r14, %rdi
xorl %eax, %eax
callq 0x25f98
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %ebp, %ebp
je 0x284b8
xorl %r12d, %r12d
leaq 0x10(%rsp), %r15
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq %r14, %rdi
movq %r15, %rsi
leaq 0x34aeb(%rip), %rdx # 0x5cf25
callq 0x291b4
cmpl $0x1, %eax
je 0x28404
movq %r14, %rdi
leaq 0x4(%rsp), %rsi
callq 0x2d138
cmpl $0x1, %eax
je 0x28404
movq %r14, %rdi
leaq 0xc(%rsp), %rsi
leaq 0x34add(%rip), %rdx # 0x5cf42
callq 0x29166
cmpl $0x1, %eax
je 0x28474
movl 0xc(%rsp), %r13d
je 0x28404
movl 0x4(%rsp), %edx
cmpl $0x4, %edx
jne 0x2848b
movq 0xc8(%r14), %rax
cmpb $0x1, (%rax)
jne 0x284e8
movq 0x48(%r14), %rdi
movq 0x10(%rsp), %r8
movq 0x18(%rsp), %r9
movq (%rdi), %rax
movl %r12d, %esi
movl %r13d, %ecx
callq *0x168(%rax)
testl %eax, %eax
jne 0x284dc
incl %r12d
cmpl %r12d, %ebp
jne 0x28425
movq 0x48(%r14), %rdi
movq (%rdi), %rax
callq *0x170(%rax)
testl %eax, %eax
je 0x284d5
leaq 0x34acd(%rip), %rsi # 0x5cf9d
jmp 0x283fa
xorl %ebx, %ebx
jmp 0x28404
leaq 0x34aa1(%rip), %rsi # 0x5cf84
jmp 0x283fa
leaq 0x34a65(%rip), %rsi # 0x5cf54
jmp 0x283fa
| /WebAssembly[P]wabt/src/binary-reader.cc |
wabt::(anonymous namespace)::BinaryReader::ReadStartSection(unsigned long) | Result BinaryReader::ReadStartSection(Offset section_size) {
CALLBACK(BeginStartSection, section_size);
Index func_index;
CHECK_RESULT(ReadIndex(&func_index, "start function index"));
CALLBACK(OnStartFunction, func_index);
CALLBACK0(EndStartSection);
return Result::Ok;
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
movq (%rdi), %rax
callq *0x178(%rax)
testl %eax, %eax
je 0x28529
leaq 0x34acb(%rip), %rsi # 0x5cfdf
movq %rbx, %rdi
xorl %eax, %eax
callq 0x25f98
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
retq
leaq 0x34ad1(%rip), %rdx # 0x5d001
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x29166
movl %eax, %ecx
movl $0x1, %eax
cmpl $0x1, %ecx
je 0x28523
movl 0xc(%rsp), %esi
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
callq *0x180(%rax)
testl %eax, %eax
je 0x28567
leaq 0x34ab1(%rip), %rsi # 0x5d016
jmp 0x28514
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
callq *0x188(%rax)
testl %eax, %eax
je 0x28581
leaq 0x34ab7(%rip), %rsi # 0x5d036
jmp 0x28514
xorl %eax, %eax
jmp 0x28523
nop
| /WebAssembly[P]wabt/src/binary-reader.cc |
wabt::(anonymous namespace)::BinaryReader::ReadTagSection(unsigned long) | Result BinaryReader::ReadTagSection(Offset section_size) {
CALLBACK(BeginTagSection, section_size);
Index num_tags;
CHECK_RESULT(ReadCount(&num_tags, "tag count"));
CALLBACK(OnTagCount, num_tags);
for (Index i = 0; i < num_tags; ++i) {
Index tag_index = num_tag_imports_ + i;
Index sig_index;
CHECK_RESULT(ReadTagType(&sig_index));
CALLBACK(OnTagType, tag_index, sig_index);
}
CALLBACK(EndTagSection);
return Result::Ok;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x48(%rdi), %rdi
movq (%rdi), %rax
callq *0x6c8(%rax)
testl %eax, %eax
je 0x28ff5
leaq 0x34663(%rip), %rsi # 0x5d647
movq %r14, %rdi
xorl %eax, %eax
callq 0x25f98
movl $0x1, %ebx
jmp 0x2903b
leaq 0x3466b(%rip), %rdx # 0x5d667
leaq 0x4(%rsp), %rsi
movq %r14, %rdi
callq 0x2a04a
movl $0x1, %ebx
cmpl $0x1, %eax
je 0x2903b
movq 0x48(%r14), %rdi
movl 0x4(%rsp), %ebp
movq (%rdi), %rax
movl %ebp, %esi
callq *0x6d0(%rax)
testl %eax, %eax
je 0x2904c
leaq 0x34640(%rip), %rsi # 0x5d671
movq %r14, %rdi
xorl %eax, %eax
callq 0x25f98
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testl %ebp, %ebp
je 0x2908f
xorl %r13d, %r13d
movq %rsp, %r15
movl 0xe8(%r14), %r12d
movq %r14, %rdi
movq %r15, %rsi
callq 0x2a6f8
cmpl $0x1, %eax
je 0x2903b
addl %r13d, %r12d
movq 0x48(%r14), %rdi
movl (%rsp), %edx
movq (%rdi), %rax
movl %r12d, %esi
callq *0x6d8(%rax)
testl %eax, %eax
jne 0x290ad
incl %r13d
cmpl %r13d, %ebp
jne 0x29056
movq 0x48(%r14), %rdi
movq (%rdi), %rax
callq *0x6e0(%rax)
testl %eax, %eax
je 0x290a9
leaq 0x345ff(%rip), %rsi # 0x5d6a6
jmp 0x29031
xorl %ebx, %ebx
jmp 0x2903b
leaq 0x345d8(%rip), %rsi # 0x5d68c
jmp 0x29031
nop
| /WebAssembly[P]wabt/src/binary-reader.cc |
wabt::(anonymous namespace)::BinaryReader::ReadType(wabt::Type*, char const*) | Result BinaryReader::ReadType(Type* out_value, const char* desc) {
uint32_t type = 0;
CHECK_RESULT(ReadS32Leb128(&type, desc));
if (static_cast<Type::Enum>(type) == Type::Reference) {
uint32_t heap_type = 0;
CHECK_RESULT(ReadS32Leb128(&heap_type, desc));
*out_value = Type(Type::Reference, heap_type);
} else {
*out_value = static_cast<Type>(type);
}
return Result::Ok;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x4(%rsp), %rsi
movl $0x0, (%rsi)
callq 0x2a0a4
movl $0x1, %ebp
cmpl $0x1, %eax
je 0x2a1f6
movl 0x4(%rsp), %eax
movl $0xffffffeb, %ecx # imm = 0xFFFFFFEB
cmpq %rcx, %rax
jne 0x2a1f1
movq %rsp, %rsi
movl $0x0, (%rsi)
movq %r15, %rdi
movq %r14, %rdx
callq 0x2a0a4
cmpl $0x1, %eax
je 0x2a1f6
movl (%rsp), %eax
shlq $0x20, %rax
movl $0xffffffeb, %ecx # imm = 0xFFFFFFEB
orq %rax, %rcx
movq %rcx, (%rbx)
jmp 0x2a1f4
movq %rax, (%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/binary-reader.cc |
wabt::(anonymous namespace)::BinaryReader::ReadField(wabt::TypeMut*) | Result BinaryReader::ReadField(TypeMut* out_value) {
// TODO: Reuse for global header too?
Type field_type;
CHECK_RESULT(ReadType(&field_type, "field type"));
ERROR_UNLESS(IsConcreteType(field_type),
"expected valid field type (got " PRItypecode ")",
WABT_PRINTF_TYPE_CODE(field_type));
uint8_t mutable_ = 0;
CHECK_RESULT(ReadU8(&mutable_, "field mutability"));
ERROR_UNLESS(mutable_ <= 1, "field mutability must be 0 or 1");
out_value->type = field_type;
out_value->mutable_ = mutable_;
return Result::Ok;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x312a5(%rip), %rdx # 0x5b517
leaq 0x10(%rsp), %rsi
callq 0x2a18c
movl $0x1, %ebx
cmpl $0x1, %eax
je 0x2a2fe
movq 0x10(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x2a204
testb %al, %al
je 0x2a2ce
leaq 0xf(%rsp), %rsi
movb $0x0, (%rsi)
leaq 0x3129f(%rip), %rdx # 0x5b548
movq %r14, %rdi
callq 0x265a8
movl $0x1, %ebx
cmpl $0x1, %eax
je 0x2a2fe
movb 0xf(%rsp), %al
cmpb $0x2, %al
jae 0x2a30c
movq %r12, (%r15)
movb %al, 0x8(%r15)
xorl %ebx, %ebx
jmp 0x2a2fe
movl 0x10(%rsp), %eax
testl %eax, %eax
leaq 0x38ca5(%rip), %rcx # 0x62f80
leaq 0x33dd8(%rip), %rdx # 0x5e0ba
cmovsq %rcx, %rdx
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
leaq 0x3122e(%rip), %rsi # 0x5b522
movq %r14, %rdi
xorl %eax, %eax
callq 0x25f98
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x31246(%rip), %rsi # 0x5b559
movq %r14, %rdi
xorl %eax, %eax
callq 0x25f98
jmp 0x2a2fe
nop
| /WebAssembly[P]wabt/src/binary-reader.cc |
wabt::(anonymous namespace)::BinaryReader::ReadF64(unsigned long*, char const*) | Result BinaryReader::ReadT(T* out_value,
const char* type_name,
const char* desc) {
if (state_.offset + sizeof(T) > read_end_) {
PrintError("unable to read %s: %s", type_name, desc);
return Result::Error;
}
#if WABT_BIG_ENDIAN
uint8_t tmp[sizeof(T)];
memcpy(tmp, state_.data + state_.offset, sizeof(tmp));
SwapBytesSized(tmp, sizeof(tmp));
memcpy(out_value, tmp, sizeof(T));
#else
memcpy(out_value, state_.data + state_.offset, sizeof(T));
#endif
state_.offset += sizeof(T);
return Result::Ok;
} | movq 0x18(%rdi), %rax
leaq 0x8(%rax), %rcx
cmpq (%rdi), %rcx
jbe 0x2cf3c
pushq %rax
leaq 0x2d6cb(%rip), %rsi # 0x5a5e8
leaq 0x2ff32(%rip), %rdx # 0x5ce56
leaq 0x2f18e(%rip), %rcx # 0x5c0b9
xorl %eax, %eax
callq 0x25f98
movl $0x1, %eax
addq $0x8, %rsp
retq
movq 0x8(%rdi), %rcx
movq (%rcx,%rax), %rax
movq %rax, (%rsi)
addq $0x8, 0x18(%rdi)
xorl %eax, %eax
retq
nop
| /WebAssembly[P]wabt/src/binary-reader.cc |
wabt::(anonymous namespace)::BinaryReader::ReadV128(v128*, char const*) | Result BinaryReader::ReadV128(v128* out_value, const char* desc) {
return ReadT(out_value, "v128", desc);
} | movq %rdx, %rcx
movq 0x18(%rdi), %rax
leaq 0x10(%rax), %rdx
cmpq (%rdi), %rdx
jbe 0x2cf80
pushq %rax
leaq 0x2d680(%rip), %rsi # 0x5a5e8
leaq 0x2feee(%rip), %rdx # 0x5ce5d
xorl %eax, %eax
callq 0x25f98
movl $0x1, %eax
addq $0x8, %rsp
retq
movq 0x8(%rdi), %rcx
movups (%rcx,%rax), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x18(%rdi)
xorl %eax, %eax
retq
nop
| /WebAssembly[P]wabt/src/binary-reader.cc |
wabt::(anonymous namespace)::BinaryReader::ReadMemLocation(unsigned long*, unsigned int*, unsigned long*, char const*, char const*, char const*, unsigned char*) | Result BinaryReader::ReadMemLocation(Address* alignment_log2,
Index* memidx,
Address* offset,
const char* desc_align,
const char* desc_memidx,
const char* desc_offset,
uint8_t* lane_val) {
bool has_memidx = false;
CHECK_RESULT(ReadAlignment(alignment_log2, desc_align));
CHECK_RESULT(TakeHasMemidx(alignment_log2, &has_memidx));
CHECK_RESULT(CheckAlignment(alignment_log2, desc_align));
*memidx = 0;
if (has_memidx) {
ERROR_IF(!options_.features.multi_memory_enabled(),
"multi_memory not allowed");
CHECK_RESULT(ReadMemidx(memidx, desc_memidx));
}
CHECK_RESULT(ReadAddress(offset, 0, desc_offset));
if (lane_val) {
CHECK_RESULT(ReadU8(lane_val, "Lane idx"));
}
return Result::Ok;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r12
movq %r8, %r13
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbp
movq %rdi, %rbx
leaq 0xc(%rsp), %rsi
movq %r8, %rdx
callq 0x29166
cmpl $0x1, %eax
je 0x2cff1
movl 0xc(%rsp), %eax
movq %rax, (%rbp)
movl %eax, %ecx
andl $-0x41, %ecx
movq %rcx, (%rbp)
cmpq $0x20, %rcx
jb 0x2d007
leaq 0x2e1b7(%rip), %rsi # 0x5b19b
movq %rbx, %rdi
movq %r13, %rdx
xorl %eax, %eax
callq 0x25f98
movl $0x1, %ebp
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x0, (%r15)
testb $0x40, %al
jne 0x2d031
movq 0x50(%rsp), %rdx
movq 0xc8(%rbx), %rax
cmpb $0x1, 0xe(%rax)
jne 0x2d05c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2a7c4
jmp 0x2d072
movq 0xc8(%rbx), %rax
cmpb $0x0, 0xf(%rax)
je 0x2d0a9
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x29166
cmpl $0x1, %eax
je 0x2cff1
movl 0x10(%rsp), %eax
movl %eax, (%r15)
jmp 0x2d012
leaq 0x14(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x29166
movl (%r15), %ecx
movq %rcx, (%r14)
movl $0x1, %ebp
cmpl $0x1, %eax
je 0x2cff6
movq 0x58(%rsp), %rsi
testq %rsi, %rsi
je 0x2d0a2
leaq 0x2f50a(%rip), %rdx # 0x5c59b
movq %rbx, %rdi
callq 0x265a8
cmpl $0x1, %eax
je 0x2cff6
xorl %ebp, %ebp
jmp 0x2cff6
leaq 0x2fdb2(%rip), %rsi # 0x5ce62
movq %rbx, %rdi
xorl %eax, %eax
callq 0x25f98
jmp 0x2cff1
nop
| /WebAssembly[P]wabt/src/binary-reader.cc |
wabt::(anonymous namespace)::BinaryReader::ReadExternalKind(wabt::ExternalKind*, char const*) | Result BinaryReader::ReadExternalKind(ExternalKind* out_value,
const char* desc) {
uint8_t value = 0;
CHECK_RESULT(ReadU8(&value, desc));
ERROR_UNLESS(value < kExternalKindCount, "invalid export external kind: %d",
value);
*out_value = static_cast<ExternalKind>(value);
return Result::Ok;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0xf(%rsp), %rsi
movb $0x0, (%rsi)
leaq 0x2fde0(%rip), %rdx # 0x5cf36
callq 0x265a8
movl $0x1, %ebx
cmpl $0x1, %eax
je 0x2d187
movzbl 0xf(%rsp), %edx
cmpl $0x5, %edx
jae 0x2d176
movl %edx, (%r15)
xorl %ebx, %ebx
jmp 0x2d187
leaq 0x2fe41(%rip), %rsi # 0x5cfbe
movq %r14, %rdi
xorl %eax, %eax
callq 0x25f98
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
| /WebAssembly[P]wabt/src/binary-reader.cc |
wabt::StringPrintf[abi:cxx11](char const*, ...) | StringPrintf(const char* format, ...) {
va_list args;
va_list args_copy;
va_start(args, format);
va_copy(args_copy, args);
size_t len = wabt_vsnprintf(nullptr, 0, format, args) + 1; // For \0.
std::vector<char> buffer(len);
va_end(args);
wabt_vsnprintf(buffer.data(), len, format, args_copy);
va_end(args_copy);
return std::string(buffer.data(), len - 1);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x60(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x2d881
movaps %xmm0, 0x90(%rsp)
movaps %xmm1, 0xa0(%rsp)
movaps %xmm2, 0xb0(%rsp)
movaps %xmm3, 0xc0(%rsp)
movaps %xmm4, 0xd0(%rsp)
movaps %xmm5, 0xe0(%rsp)
movaps %xmm6, 0xf0(%rsp)
movaps %xmm7, 0x100(%rsp)
movabsq $0x3000000010, %rax # imm = 0x3000000010
leaq 0x40(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x150(%rsp), %rax
movq %rax, 0x8(%rcx)
movq %rsi, 0x10(%rcx)
leaq 0x20(%rsp), %r15
movq %rsi, 0x10(%r15)
movq (%rcx), %rax
movq %rax, (%r15)
movq 0x8(%rcx), %rax
movq %rax, 0x8(%r15)
xorl %edi, %edi
xorl %esi, %esi
movq %r14, %rdx
callq 0x15468
movslq %eax, %rbp
leaq 0x1(%rbp), %r12
leaq 0x8(%rsp), %r13
leaq 0x7(%rsp), %rdx
movq %r13, %rdi
movq %r12, %rsi
callq 0x2d93c
movq (%r13), %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x15468
movq (%r13), %rsi
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq (%rsi,%rbp), %rdx
incq %rdx
decq %rdx
movq %rbx, %rdi
callq 0x16a80
movq (%r13), %rdi
testq %rdi, %rdi
je 0x2d927
movq 0x18(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
movq %rbx, %rax
addq $0x118, %rsp # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/include/wabt/string-format.h |
wabt::Type::GetName[abi:cxx11]() const | std::string GetName() const {
switch (enum_) {
case Type::I32: return "i32";
case Type::I64: return "i64";
case Type::F32: return "f32";
case Type::F64: return "f64";
case Type::V128: return "v128";
case Type::I8: return "i8";
case Type::I16: return "i16";
case Type::ExnRef: return "exnref";
case Type::FuncRef: return "funcref";
case Type::Func: return "func";
case Type::Void: return "void";
case Type::Any: return "any";
case Type::ExternRef: return "externref";
case Type::Reference:
return StringPrintf("(ref %d)", type_index_);
default:
return StringPrintf("<type_index[%d]>", enum_);
}
} | pushq %rbx
movq %rdi, %rbx
movl (%rsi), %edx
leal 0x17(%rdx), %eax
cmpl $0x17, %eax
ja 0x2dfc0
leaq 0x2c4b3(%rip), %rcx # 0x5a450
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2f2bf(%rip), %rsi # 0x5d273
leaq 0x2f2be(%rip), %rdx # 0x5d279
jmp 0x2e11a
cmpl $-0x40, %edx
je 0x2e105
cmpl $-0x20, %edx
jne 0x2dfe8
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x300cc(%rip), %rsi # 0x5e0a8
leaq 0x300c9(%rip), %rdx # 0x5e0ac
jmp 0x2e11a
leaq 0x2f2ab(%rip), %rsi # 0x5d29a
movq %rbx, %rdi
jmp 0x2e0b7
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x333cd(%rip), %rsi # 0x613d2
leaq 0x333c9(%rip), %rdx # 0x613d5
jmp 0x2e11a
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2ee3e(%rip), %rsi # 0x5ce5d
leaq 0x2ee3b(%rip), %rdx # 0x5ce61
jmp 0x2e11a
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2f233(%rip), %rsi # 0x5d26c
leaq 0x2f22e(%rip), %rdx # 0x5d26e
jmp 0x2e11a
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x33478(%rip), %rsi # 0x614cb
leaq 0x33474(%rip), %rdx # 0x614ce
jmp 0x2e11a
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2f21a(%rip), %rsi # 0x5d287
leaq 0x2f21c(%rip), %rdx # 0x5d290
jmp 0x2e11a
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2f1f3(%rip), %rsi # 0x5d27a
leaq 0x2f1f3(%rip), %rdx # 0x5d281
jmp 0x2e11a
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x334be(%rip), %rsi # 0x6155f
leaq 0x334ba(%rip), %rdx # 0x61562
jmp 0x2e11a
movl 0x4(%rsi), %edx
leaq 0x2f1dd(%rip), %rsi # 0x5d291
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2d811
jmp 0x2e122
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x33455(%rip), %rsi # 0x61523
leaq 0x33451(%rip), %rdx # 0x61526
jmp 0x2e11a
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2f18a(%rip), %rsi # 0x5d26f
leaq 0x2f186(%rip), %rdx # 0x5d272
jmp 0x2e11a
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x35691(%rip), %rsi # 0x6378d
leaq 0x3568d(%rip), %rdx # 0x63790
jmp 0x2e11a
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2f16f(%rip), %rsi # 0x5d282
leaq 0x2f16c(%rip), %rdx # 0x5d286
movq %rbx, %rdi
callq 0x16a80
movq %rbx, %rax
popq %rbx
retq
nop
| /WebAssembly[P]wabt/include/wabt/type.h |
wabt::ReadFile(std::basic_string_view<char, std::char_traits<char>>, std::vector<unsigned char, std::allocator<unsigned char>>*) | Result ReadFile(std::string_view filename, std::vector<uint8_t>* out_data) {
std::string filename_str(filename);
const char* filename_cstr = filename_str.c_str();
if (filename == "-") {
return ReadAll(stdin, "stdin", out_data);
}
struct stat statbuf;
if (stat(filename_cstr, &statbuf) < 0) {
fprintf(stderr, "%s: %s\n", filename_cstr, strerror(errno));
return Result::Error;
}
if (statbuf.st_mode & S_IFDIR) {
fprintf(stderr, "%s: is a directory\n", filename_cstr);
return Result::Error;
}
FILE* infile = fopen(filename_cstr, "rb");
if (!infile) {
fprintf(stderr, "%s: %s\n", filename_cstr, strerror(errno));
return Result::Error;
}
if (fseek(infile, 0, SEEK_END) < 0) {
// not seekable, so we can't pre-allocate out_data, but let's try and read
// it anyway (for pipes, sockets, etc.)
auto res = ReadAll(infile, filename_cstr, out_data);
fclose(infile);
return res;
}
long size = ftell(infile);
if (size < 0) {
perror("ftell failed");
fclose(infile);
return Result::Error;
}
if (fseek(infile, 0, SEEK_SET) < 0) {
perror("fseek to beginning failed");
fclose(infile);
return Result::Error;
}
out_data->resize(size);
if (size != 0 && fread(out_data->data(), size, 1, infile) != 1) {
fprintf(stderr, "%s: fread failed: %s\n", filename_cstr, strerror(errno));
fclose(infile);
return Result::Error;
}
fclose(infile);
return Result::Ok;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq (%rsi,%rdi), %rdx
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x16a80
movq (%rbx), %rbx
cmpq $0x1, %r15
jne 0x2e1ce
leaq 0x34dc5(%rip), %rsi # 0x62f80
movq %r12, %rdi
movq %r15, %rdx
callq 0x15220
testl %eax, %eax
je 0x2e297
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x151d0
testl %eax, %eax
js 0x2e2b4
testb $0x40, 0x39(%rsp)
jne 0x2e2be
leaq 0x2f8f0(%rip), %rsi # 0x5dae5
movq %rbx, %rdi
callq 0x152d0
testq %rax, %rax
je 0x2e2db
movq %rax, %r15
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x15260
movq %r15, %rdi
testl %eax, %eax
js 0x2e280
callq 0x15030
testq %rax, %rax
js 0x2e2e5
movq %rax, %r12
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x15260
testl %eax, %eax
js 0x2e2ee
movq %r14, %rdi
movq %r12, %rsi
callq 0x24dc8
testq %r12, %r12
je 0x2e271
movq (%r14), %rdi
movl $0x1, %edx
movq %r12, %rsi
movq %r15, %rcx
callq 0x15360
cmpq $0x1, %rax
jne 0x2e304
movq %r15, %rdi
callq 0x151e0
xorl %ebx, %ebx
jmp 0x2e314
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2e33d
movl %eax, %ebx
movq %r15, %rdi
callq 0x151e0
jmp 0x2e314
movq 0x55d3a(%rip), %rax # 0x83fd8
movq (%rax), %rdi
leaq 0x2f823(%rip), %rsi # 0x5dacb
movq %r14, %rdx
callq 0x2e33d
movl %eax, %ebx
jmp 0x2e314
movq %rbx, %rdi
callq 0x15711
jmp 0x2e30f
movq 0x55d1b(%rip), %rax # 0x83fe0
movq (%rax), %rdi
leaq 0x2f802(%rip), %rsi # 0x5dad1
movq %rbx, %rdx
xorl %eax, %eax
callq 0x15350
jmp 0x2e30f
movq %rbx, %rdi
callq 0x156d5
jmp 0x2e30f
leaq 0x2f7fc(%rip), %rdi # 0x5dae8
jmp 0x2e2f5
leaq 0x2f800(%rip), %rdi # 0x5daf5
callq 0x151b0
movq %r15, %rdi
callq 0x151e0
jmp 0x2e30f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1568f
movl $0x1, %ebx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x2e32a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x15200
movl %ebx, %eax
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /WebAssembly[P]wabt/src/common.cc |
wabt::Decompile[abi:cxx11](wabt::Module const&, wabt::DecompileOptions const&) | std::string Decompile(const Module& module, const DecompileOptions& options) {
Decompiler decompiler(module, options);
return decompiler.Decompile();
} | pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
leaq 0x58(%rsp), %rax
movq %rsi, -0x58(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x50(%rax)
movups %xmm0, -0x40(%rax)
movq %rdx, -0x30(%rax)
movq $0x2, -0x28(%rax)
movq $0x46, -0x20(%rax)
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movups %xmm0, -0x18(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %rsp, %rsi
callq 0x2e8c6
leaq 0x50(%rsp), %rdi
movq 0x10(%rdi), %rsi
callq 0x38b72
leaq 0x10(%rsp), %rdi
callq 0x38bf4
movq %rbx, %rax
addq $0x80, %rsp
popq %rbx
retq
nop
| /WebAssembly[P]wabt/src/decompiler.cc |
wabt::Decompiler::CheckImportExport(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, wabt::ExternalKind, unsigned int, std::basic_string_view<char, std::char_traits<char>>) | bool CheckImportExport(std::string& s,
ExternalKind kind,
Index index,
std::string_view name) {
// Figure out if this thing is imported, exported, or neither.
auto is_import = mc.module.IsImport(kind, Var(index, Location()));
// TODO: is this the best way to check for export?
// FIXME: this doesn't work for functions that get renamed in some way,
// as the export has the original name..
auto xport = mc.module.GetExport(name);
auto is_export = xport && xport->kind == kind;
if (is_export)
s += "export ";
if (is_import)
s += "import ";
return is_import;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r9, %r15
movq %r8, %r12
movl %edx, %r14d
movq %rsi, 0x8(%rsp)
movq %rdi, %r13
movq (%rdi), %rbp
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movups %xmm0, 0xc(%rdx)
movaps %xmm0, (%rdx)
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
movl %ecx, %esi
callq 0x3e686
movq %rbp, %rdi
movl %r14d, %esi
movq %rbx, %rdx
callq 0x3d226
movl %eax, %ebp
movq %rbx, %rdi
callq 0x3e814
movq (%r13), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3d190
testq %rax, %rax
je 0x2fc01
cmpl %r14d, 0x20(%rax)
jne 0x2fc01
leaq 0x2e4c4(%rip), %rsi # 0x5e0bb
movq 0x8(%rsp), %rdi
callq 0x15430
testb %bpl, %bpl
je 0x2fc17
leaq 0x2e4b6(%rip), %rsi # 0x5e0c3
movq 0x8(%rsp), %rdi
callq 0x15430
movl %ebp, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/src/decompiler.cc |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> wabt::cat<char [8], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [2], char const*>(char const (&) [8], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [2], char const* const&) | std::string cat(const Ts&... args) {
std::string s;
s.reserve(cat_compute_size(args...));
cat_concatenate(s, args...);
return s;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
callq 0x32e45
movq %r14, %rdi
movq %rax, %rsi
callq 0x153b0
movq %r14, %rdi
movq %r13, %rsi
callq 0x15430
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x32e87
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /WebAssembly[P]wabt/include/wabt/string-util.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> wabt::cat<char [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [2]>(char const (&) [10], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [2]) | std::string cat(const Ts&... args) {
std::string s;
s.reserve(cat_compute_size(args...));
cat_concatenate(s, args...);
return s;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x15100
movq %rax, %r13
addq 0x8(%r15), %r13
movq %rbx, %rdi
callq 0x15100
addq %rax, %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0x153b0
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x3566f
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /WebAssembly[P]wabt/include/wabt/string-util.h |
unsigned long wabt::cat_compute_size<char [8], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [2], char const*>(char const (&) [8], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [2], char const* const&) | size_t cat_compute_size(const T& t, const Ts&... args) {
return std::string_view(t).size() + cat_compute_size(args...);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
callq 0x15100
movq %rax, %r12
addq 0x8(%r15), %r12
movq %r14, %rdi
callq 0x15100
movq %rax, %r14
movq (%rbx), %rdi
callq 0x15100
addq %r14, %rax
addq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /WebAssembly[P]wabt/include/wabt/string-util.h |
void wabt::AST::Get<(wabt::ExprType)26>(wabt::VarExpr<(wabt::ExprType)26> const&, bool) | void Get(const VarExpr<T>& ve, bool local) {
if (local) {
auto ret = vars_defined.insert({ve.var.name(), {cur_block_id, false}});
if (ret.second) {
// Use before def, may happen since locals are guaranteed 0.
PreDecl(ve);
} else if (blocks_closed[ret.first->second.block_id]) {
// This is a use of a variable that was defined in a block that has
// already ended. This happens rarely, but we should cater for this
// case by lifting it to the top scope.
PreDecl(ve);
}
}
InsertNode(NodeType::Expr, T, &ve, 0);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
testl %edx, %edx
je 0x33e6a
cmpl $0x1, 0x60(%rbx)
jne 0x33e91
leaq 0x48(%r14), %r15
movq 0x80(%r14), %r13
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq 0x68(%rbx), %rsi
movq 0x70(%rbx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x17e60
movq %r13, 0x20(%r12)
movb $0x0, 0x28(%r12)
movq %r15, %rdi
movq %r12, %rsi
callq 0x33038
movq %rax, %r15
movl %edx, %ebp
movq (%r12), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x33e16
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x15200
testb $0x1, %bpl
jne 0x33e5f
movq 0x40(%r15), %rax
leaq 0x3f(%rax), %rcx
testq %rax, %rax
cmovnsq %rax, %rcx
sarq $0x6, %rcx
shlq $0x3, %rcx
addq 0xa0(%r14), %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
leaq 0x3f(%rdx), %rsi
andq %rax, %rsi
xorl %edi, %edi
cmpq %rdx, %rsi
setbe %dil
movq -0x8(%rcx,%rdi,8), %rcx
btq %rax, %rcx
jae 0x33e6a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x343a4
movq %r14, %rdi
movl $0x7, %esi
movl $0x1a, %edx
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0x33466
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2a4af(%rip), %rdi # 0x5e347
leaq 0x233e6(%rip), %rsi # 0x57285
leaq 0x2a4ab(%rip), %rcx # 0x5e351
movl $0x3f, %edx
callq 0x15160
| /WebAssembly[P]wabt/include/wabt/decompiler-ast.h |
void wabt::AST::Block<(wabt::ExprType)8>(wabt::BlockExprBase<(wabt::ExprType)8> const&, wabt::LabelType) | void Block(const BlockExprBase<T>& be, LabelType label) {
mc.BeginBlock(label, be.block);
Construct(be.block.exprs, be.block.decl.GetNumResults(),
be.block.decl.GetNumParams(), false);
mc.EndBlock();
InsertNode(NodeType::Expr, T, &be, 1);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
leaq 0x40(%rsi), %rax
movl %edx, %esi
movq %rax, %rdx
callq 0x3c886
leaq 0xe0(%rbx), %rsi
movq 0xb8(%rbx), %rcx
movq 0xd0(%rbx), %rdx
subq 0xc8(%rbx), %rdx
shrq $0x3, %rdx
subq 0xb0(%rbx), %rcx
shrq $0x3, %rcx
movq %r14, %rdi
xorl %r8d, %r8d
callq 0x30462
movq (%r14), %rdi
callq 0x3c8a8
movq %r14, %rdi
movl $0x7, %esi
movl $0x8, %edx
movq %rbx, %rcx
movl $0x1, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x33466
nop
| /WebAssembly[P]wabt/include/wabt/decompiler-ast.h |
void wabt::AST::Block<(wabt::ExprType)27>(wabt::BlockExprBase<(wabt::ExprType)27> const&, wabt::LabelType) | void Block(const BlockExprBase<T>& be, LabelType label) {
mc.BeginBlock(label, be.block);
Construct(be.block.exprs, be.block.decl.GetNumResults(),
be.block.decl.GetNumParams(), false);
mc.EndBlock();
InsertNode(NodeType::Expr, T, &be, 1);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
leaq 0x40(%rsi), %rax
movl %edx, %esi
movq %rax, %rdx
callq 0x3c886
leaq 0xe0(%rbx), %rsi
movq 0xb8(%rbx), %rcx
movq 0xd0(%rbx), %rdx
subq 0xc8(%rbx), %rdx
shrq $0x3, %rdx
subq 0xb0(%rbx), %rcx
shrq $0x3, %rcx
movq %r14, %rdi
xorl %r8d, %r8d
callq 0x30462
movq (%r14), %rdi
callq 0x3c8a8
movq %r14, %rdi
movl $0x7, %esi
movl $0x1b, %edx
movq %rbx, %rcx
movl $0x1, %r8d
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x33466
nop
| /WebAssembly[P]wabt/include/wabt/decompiler-ast.h |
void wabt::AST::PreDecl<(wabt::ExprType)24>(wabt::VarExpr<(wabt::ExprType)24> const&) | void PreDecl(const VarExpr<T>& ve) {
// FIXME: this is slow, and would be better to avoid in callers.
// See https://github.com/WebAssembly/wabt/issues/1565
// And https://github.com/WebAssembly/wabt/issues/1665
for (auto& n : predecls) {
if (n.u.var->name() == ve.var.name()) {
return;
}
}
predecls.emplace_back(NodeType::Decl, ExprType::Nop, nullptr, &ve.var);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, (%rsp)
movq 0x20(%rdi), %r12
movq %rdi, 0x8(%rsp)
movq 0x28(%rdi), %r13
cmpq %r13, %r12
sete %bpl
je 0x3402c
movq (%rsp), %rax
movl 0x60(%rax), %r14d
movq 0x70(%rax), %rbx
movq 0x68(%rax), %r15
movq 0x28(%r12), %rax
cmpl $0x1, 0x20(%rax)
jne 0x3407b
cmpl $0x1, %r14d
jne 0x3407b
movq 0x30(%rax), %rdx
cmpq %rbx, %rdx
jne 0x34017
testq %rdx, %rdx
je 0x34026
movq 0x28(%rax), %rdi
movq %r15, %rsi
callq 0x15220
testl %eax, %eax
je 0x34026
addq $0x30, %r12
cmpq %r13, %r12
sete %bpl
jne 0x33fe0
jmp 0x3402c
testb $0x1, %bpl
je 0x3406c
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
leaq 0x14(%rsp), %rsi
movl $0x5, (%rsi)
leaq 0x10(%rsp), %rdx
movl $0x22, (%rdx)
leaq 0x20(%rsp), %rcx
movq $0x0, (%rcx)
movq (%rsp), %rax
addq $0x40, %rax
leaq 0x18(%rsp), %r8
movq %rax, (%r8)
callq 0x3409a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2a2c5(%rip), %rdi # 0x5e347
leaq 0x231fc(%rip), %rsi # 0x57285
leaq 0x2a2c1(%rip), %rcx # 0x5e351
movl $0x3f, %edx
callq 0x15160
| /WebAssembly[P]wabt/include/wabt/decompiler-ast.h |
void wabt::AST::PreDecl<(wabt::ExprType)25>(wabt::VarExpr<(wabt::ExprType)25> const&) | void PreDecl(const VarExpr<T>& ve) {
// FIXME: this is slow, and would be better to avoid in callers.
// See https://github.com/WebAssembly/wabt/issues/1565
// And https://github.com/WebAssembly/wabt/issues/1665
for (auto& n : predecls) {
if (n.u.var->name() == ve.var.name()) {
return;
}
}
predecls.emplace_back(NodeType::Decl, ExprType::Nop, nullptr, &ve.var);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, (%rsp)
movq 0x20(%rdi), %r12
movq %rdi, 0x8(%rsp)
movq 0x28(%rdi), %r13
cmpq %r13, %r12
sete %bpl
je 0x34336
movq (%rsp), %rax
movl 0x60(%rax), %r14d
movq 0x70(%rax), %rbx
movq 0x68(%rax), %r15
movq 0x28(%r12), %rax
cmpl $0x1, 0x20(%rax)
jne 0x34385
cmpl $0x1, %r14d
jne 0x34385
movq 0x30(%rax), %rdx
cmpq %rbx, %rdx
jne 0x34321
testq %rdx, %rdx
je 0x34330
movq 0x28(%rax), %rdi
movq %r15, %rsi
callq 0x15220
testl %eax, %eax
je 0x34330
addq $0x30, %r12
cmpq %r13, %r12
sete %bpl
jne 0x342ea
jmp 0x34336
testb $0x1, %bpl
je 0x34376
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
leaq 0x14(%rsp), %rsi
movl $0x5, (%rsi)
leaq 0x10(%rsp), %rdx
movl $0x22, (%rdx)
leaq 0x20(%rsp), %rcx
movq $0x0, (%rcx)
movq (%rsp), %rax
addq $0x40, %rax
leaq 0x18(%rsp), %r8
movq %rax, (%r8)
callq 0x3409a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x29fbb(%rip), %rdi # 0x5e347
leaq 0x22ef2(%rip), %rsi # 0x57285
leaq 0x29fb7(%rip), %rcx # 0x5e351
movl $0x3f, %edx
callq 0x15160
| /WebAssembly[P]wabt/include/wabt/decompiler-ast.h |
void wabt::AST::PreDecl<(wabt::ExprType)26>(wabt::VarExpr<(wabt::ExprType)26> const&) | void PreDecl(const VarExpr<T>& ve) {
// FIXME: this is slow, and would be better to avoid in callers.
// See https://github.com/WebAssembly/wabt/issues/1565
// And https://github.com/WebAssembly/wabt/issues/1665
for (auto& n : predecls) {
if (n.u.var->name() == ve.var.name()) {
return;
}
}
predecls.emplace_back(NodeType::Decl, ExprType::Nop, nullptr, &ve.var);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, (%rsp)
movq 0x20(%rdi), %r12
movq %rdi, 0x8(%rsp)
movq 0x28(%rdi), %r13
cmpq %r13, %r12
sete %bpl
je 0x34428
movq (%rsp), %rax
movl 0x60(%rax), %r14d
movq 0x70(%rax), %rbx
movq 0x68(%rax), %r15
movq 0x28(%r12), %rax
cmpl $0x1, 0x20(%rax)
jne 0x34477
cmpl $0x1, %r14d
jne 0x34477
movq 0x30(%rax), %rdx
cmpq %rbx, %rdx
jne 0x34413
testq %rdx, %rdx
je 0x34422
movq 0x28(%rax), %rdi
movq %r15, %rsi
callq 0x15220
testl %eax, %eax
je 0x34422
addq $0x30, %r12
cmpq %r13, %r12
sete %bpl
jne 0x343dc
jmp 0x34428
testb $0x1, %bpl
je 0x34468
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
leaq 0x14(%rsp), %rsi
movl $0x5, (%rsi)
leaq 0x10(%rsp), %rdx
movl $0x22, (%rdx)
leaq 0x20(%rsp), %rcx
movq $0x0, (%rcx)
movq (%rsp), %rax
addq $0x40, %rax
leaq 0x18(%rsp), %r8
movq %rax, (%r8)
callq 0x3409a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x29ec9(%rip), %rdi # 0x5e347
leaq 0x22e00(%rip), %rsi # 0x57285
leaq 0x29ec5(%rip), %rcx # 0x5e351
movl $0x3f, %edx
callq 0x15160
| /WebAssembly[P]wabt/include/wabt/decompiler-ast.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> wabt::cat<char const*, char [5], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const* const&, char const (&) [5], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string cat(const Ts&... args) {
std::string s;
s.reserve(cat_compute_size(args...));
cat_concatenate(s, args...);
return s;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rsi), %rdi
callq 0x15100
movq %rax, %r13
movq %r15, %rdi
callq 0x15100
addq %rax, %r13
addq 0x8(%rbx), %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0x153b0
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x35c35
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /WebAssembly[P]wabt/include/wabt/string-util.h |
wabt::Decompiler::TempVarName[abi:cxx11](unsigned int) | std::string TempVarName(Index n) {
// FIXME: this needs much better variable naming. Problem is, the code
// in generate-names.cc has allready run, its dictionaries deleted, so it
// is not easy to integrate with it.
return "t" + std::to_string(n);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movl $0x1, %eax
cmpl $0xa, %edx
jb 0x35d8d
movl $0x4, %eax
movl $0xd1b71759, %ecx # imm = 0xD1B71759
movl %ebp, %edx
cmpl $0x63, %edx
jbe 0x35d86
cmpl $0x3e7, %edx # imm = 0x3E7
jbe 0x35d8b
cmpl $0x2710, %edx # imm = 0x2710
jb 0x35d8d
movl %edx, %esi
imulq %rcx, %rsi
shrq $0x2d, %rsi
addl $0x4, %eax
cmpl $0x1869f, %edx # imm = 0x1869F
movl %esi, %edx
ja 0x35d55
addl $-0x3, %eax
jmp 0x35d8d
addl $-0x2, %eax
jmp 0x35d8d
decl %eax
movl %eax, %esi
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %edx, %edx
callq 0x152b0
movq (%r14), %rdi
movl 0x8(%r14), %esi
movl %ebp, %edx
callq 0x250b0
leaq 0x2482a(%rip), %rcx # 0x5a5e6
movl $0x1, %r8d
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x15290
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x35df0
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x35df6
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x35e24
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x15200
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/src/decompiler.cc |
wabt::Decompiler::Value wabt::Decompiler::Set<(wabt::ExprType)26>(wabt::Decompiler::Value&, wabt::VarExpr<(wabt::ExprType)26> const&) | Value Set(Value& child, const VarExpr<T>& ve) {
return WrapChild(child, VarName(ve.var.name()) + " = ", "",
Precedence::Assign);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, 0x10(%rsp)
cmpl $0x1, 0x60(%rcx)
jne 0x36bb2
movq %rsi, %r15
movq %rdi, %rbx
movq 0x68(%rcx), %rdx
movq 0x70(%rcx), %rsi
movq %r15, %rdi
callq 0x35a26
movq %rax, %r13
movq %rdx, %rbp
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
xorl %eax, %eax
movq %rax, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x3(%r13), %rsi
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x153b0
movq %r12, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x15070
leaq 0x27522(%rip), %rsi # 0x5e064
movl $0x3, %edx
movq %r12, %rdi
callq 0x15070
movq (%r12), %r8
movq 0x8(%r12), %rcx
xorl %eax, %eax
movq %rax, 0x18(%rsp)
leaq 0x27554(%rip), %rax # 0x5e0ba
movq %rax, 0x20(%rsp)
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
movq 0x10(%rsp), %rdx
movl $0x1, %r9d
callq 0x36274
movq (%r12), %rdi
cmpq %r14, %rdi
je 0x36ba0
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x15200
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2778e(%rip), %rdi # 0x5e347
leaq 0x206c5(%rip), %rsi # 0x57285
leaq 0x2778a(%rip), %rcx # 0x5e351
movl $0x3f, %edx
callq 0x15160
nop
| /WebAssembly[P]wabt/src/decompiler.cc |
wabt::Decompiler::OpcodeToToken[abi:cxx11](wabt::Opcode) | std::string OpcodeToToken(Opcode opcode) {
std::string s = opcode.GetDecomp();
std::replace(s.begin(), s.end(), '.', '_');
return s;
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rdi
movl %edx, (%rdi)
callq 0x38150
leaq 0xb(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x300e2
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x36c16
movq (%rbx), %rcx
xorl %edx, %edx
cmpb $0x2e, (%rcx,%rdx)
jne 0x36c0e
movb $0x5f, (%rcx,%rdx)
incq %rdx
cmpq %rdx, %rax
jne 0x36c04
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
nop
| /WebAssembly[P]wabt/src/decompiler.cc |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> wabt::cat<char [3], char const*, char [2], std::basic_string_view<char, std::char_traits<char>>>(char const (&) [3], char const* const&, char const (&) [2], std::basic_string_view<char, std::char_traits<char>> const&) | std::string cat(const Ts&... args) {
std::string s;
s.reserve(cat_compute_size(args...));
cat_concatenate(s, args...);
return s;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
callq 0x38afc
movq %r14, %rdi
movq %rax, %rsi
callq 0x153b0
movq %r14, %rdi
movq %r13, %rsi
callq 0x15430
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x38b3d
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /WebAssembly[P]wabt/include/wabt/string-util.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> wabt::cat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [2], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [2], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string cat(const Ts&... args) {
std::string s;
s.reserve(cat_compute_size(args...));
cat_concatenate(s, args...);
return s;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %r13
movq %rdx, %rdi
callq 0x15100
addq %rax, %r13
addq 0x8(%rbx), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x153b0
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x38652
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /WebAssembly[P]wabt/include/wabt/string-util.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> wabt::cat<char [2], char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const (&) [2], char const* const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string cat(const Ts&... args) {
std::string s;
s.reserve(cat_compute_size(args...));
cat_concatenate(s, args...);
return s;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x15100
movq %rax, %r13
movq (%r15), %rdi
callq 0x15100
addq %rax, %r13
addq 0x8(%rbx), %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0x153b0
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x386ca
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /WebAssembly[P]wabt/include/wabt/string-util.h |
wabt::ExprVisitor::PushCatch(wabt::Expr*, unsigned int, wabt::intrusive_list<wabt::Expr>&) | void ExprVisitor::PushCatch(Expr* expr,
Index catch_index,
ExprList& expr_list) {
state_stack_.emplace_back(State::Catch);
expr_stack_.emplace_back(expr);
expr_iter_stack_.emplace_back(expr_list.begin());
catch_index_stack_.emplace_back(catch_index);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdi, %rbx
movq %rsi, 0x20(%rsp)
movl %edx, 0xc(%rsp)
movl $0x7, 0x10(%rsp)
movq 0x10(%rdi), %rsi
cmpq 0x18(%rdi), %rsi
je 0x3a3da
movl $0x7, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x10(%rbx)
jmp 0x3a3e8
leaq 0x8(%rbx), %rdi
leaq 0x10(%rsp), %rdx
callq 0x3a552
leaq 0x20(%rbx), %rdi
leaq 0x20(%rsp), %rsi
callq 0x3a522
movq (%r14), %rax
movq %r14, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movq 0x40(%rbx), %rsi
cmpq 0x48(%rbx), %rsi
je 0x3a41c
movups 0x10(%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x40(%rbx)
jmp 0x3a42a
leaq 0x38(%rbx), %rdi
leaq 0x10(%rsp), %rdx
callq 0x3a8a6
movq 0x58(%rbx), %rsi
cmpq 0x60(%rbx), %rsi
je 0x3a444
movl 0xc(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x58(%rbx)
jmp 0x3a455
addq $0x50, %rbx
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
callq 0x3a9e6
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
| /WebAssembly[P]wabt/src/expr-visitor.cc |
wabt::GenerateNames(wabt::Module*, wabt::NameOpts) | Result GenerateNames(Module* module, NameOpts opts) {
NameGenerator generator(opts);
return generator.VisitModule(module);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movl %esi, %ebp
movq %rdi, %r15
leaq 0x47607(%rip), %rax # 0x82db8
leaq 0x60(%rsp), %r12
movq %rax, -0x10(%r12)
xorl %ebx, %ebx
movq %rbx, -0x8(%r12)
leaq 0x50(%rsp), %r14
movq %r12, %rdi
movq %r14, %rsi
callq 0x398c0
movq %rbx, 0x78(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x78(%r14)
movl %ebp, 0x90(%r14)
movq %r15, 0x8(%r14)
movq 0xb8(%r15), %r12
movq %r15, 0x20(%rsp)
movq 0xc0(%r15), %rcx
cmpq %rcx, %r12
je 0x3ba17
movq %rcx, 0x28(%rsp)
movq (%r12), %rbx
movl 0x48(%rbx), %eax
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
cmpq $0x4, %rax
ja 0x3b90c
leaq 0x24474(%rip), %rdx # 0x5fc9c
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
testq %rbx, %rbx
je 0x3b90c
movq 0x58(%rsp), %r14
movl $0x1c8, %eax # imm = 0x1C8
addq %rax, %r14
leaq 0x50(%rbx), %r13
movl 0xcc(%rsp), %esi
leal 0x1(%rsi), %eax
movl %eax, 0xcc(%rsp)
jmp 0x3b912
testq %rbx, %rbx
je 0x3b90c
movq 0x58(%rsp), %r14
movl $0x190, %eax # imm = 0x190
addq %rax, %r14
leaq 0x50(%rbx), %r13
movl 0xdc(%rsp), %esi
leal 0x1(%rsi), %eax
movl %eax, 0xdc(%rsp)
jmp 0x3b912
testq %rbx, %rbx
je 0x3b90c
movq 0x58(%rsp), %r14
movl $0x2e0, %eax # imm = 0x2E0
addq %rax, %r14
leaq 0x50(%rbx), %r13
movl 0xd4(%rsp), %esi
leal 0x1(%rsi), %eax
movl %eax, 0xd4(%rsp)
jmp 0x3b912
testq %rbx, %rbx
je 0x3b90c
movq 0x58(%rsp), %r14
movl $0x200, %eax # imm = 0x200
addq %rax, %r14
leaq 0x50(%rbx), %r13
movl 0xd8(%rsp), %esi
leal 0x1(%rsi), %eax
movl %eax, 0xd8(%rsp)
jmp 0x3b912
testq %rbx, %rbx
je 0x3b90c
movq 0x58(%rsp), %r14
movl $0x2a8, %eax # imm = 0x2A8
addq %rax, %r14
leaq 0x50(%rbx), %r13
movl 0xd0(%rsp), %esi
leal 0x1(%rsi), %eax
movl %eax, 0xd0(%rsp)
jmp 0x3b912
xorl %r13d, %r13d
xorl %r14d, %r14d
testq %r14, %r14
je 0x3ba0a
testq %r13, %r13
je 0x3ba0a
cmpl $-0x1, %esi
je 0x3c082
movq %rsi, %rbp
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
addq %rsi, %rdx
movq %rsp, %r15
movq %r15, %rdi
callq 0x17e60
movq 0x8(%rsp), %rsi
movl $0x1, %ecx
movq %r15, %rdi
xorl %edx, %edx
movl $0x2e, %r8d
callq 0x15410
movq 0x28(%rbx), %rsi
movq 0x30(%rbx), %rdx
movq %r15, %rdi
callq 0x150c0
leaq 0x40(%rsp), %rbx
movq %rbx, 0x30(%rsp)
movq (%rax), %rdx
leaq 0x10(%rax), %rcx
cmpq %rcx, %rdx
je 0x3b99e
movq %rdx, 0x30(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x40(%rsp)
jmp 0x3b9a4
movups (%rcx), %xmm0
movups %xmm0, (%rbx)
movq 0x8(%rax), %rdx
movq %rdx, 0x38(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x3b9d7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x15200
movq 0x30(%rsp), %rdx
leaq 0x50(%rsp), %rdi
movq %r14, %rsi
movl %ebp, %ecx
movq %r13, %r8
callq 0x3c544
movq 0x30(%rsp), %rdi
cmpq %rbx, %rdi
je 0x3ba05
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x15200
movq 0x28(%rsp), %rcx
addq $0x8, %r12
cmpq %rcx, %r12
jne 0x3b80b
movq 0x20(%rsp), %rax
movq 0xd0(%rax), %r13
movq 0xd8(%rax), %rbx
cmpq %rbx, %r13
je 0x3bb9d
movq (%r13), %r15
movl 0x20(%r15), %eax
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
cmpq $0x4, %rax
ja 0x3bb73
leaq 0x2425f(%rip), %rcx # 0x5fcb0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x58(%rsp), %rdi
leaq 0x28(%r15), %r12
movq %r12, %rsi
callq 0x3d510
testq %rax, %rax
je 0x3bb73
movq %rax, %r14
movq 0x58(%rsp), %rdi
movq %r12, %rsi
callq 0x3d1c6
movl %eax, %ebp
movq 0x58(%rsp), %rsi
movl $0x1c8, %eax # imm = 0x1C8
jmp 0x3bb6e
movq 0x58(%rsp), %rdi
leaq 0x28(%r15), %r12
movq %r12, %rsi
callq 0x3d68a
testq %rax, %rax
je 0x3bb73
movq %rax, %r14
movq 0x58(%rsp), %rdi
movq %r12, %rsi
callq 0x3d202
movl %eax, %ebp
movq 0x58(%rsp), %rsi
movl $0x190, %eax # imm = 0x190
jmp 0x3bb6e
movq 0x58(%rsp), %rdi
leaq 0x28(%r15), %r12
movq %r12, %rsi
callq 0x3d654
testq %rax, %rax
je 0x3bb73
movq %rax, %r14
movq 0x58(%rsp), %rdi
movq %r12, %rsi
callq 0x3d1ea
movl %eax, %ebp
movq 0x58(%rsp), %rsi
movl $0x2e0, %eax # imm = 0x2E0
jmp 0x3bb6e
movq 0x58(%rsp), %rdi
leaq 0x28(%r15), %r12
movq %r12, %rsi
callq 0x3d57c
testq %rax, %rax
je 0x3bb73
movq %rax, %r14
movq 0x58(%rsp), %rdi
movq %r12, %rsi
callq 0x3d1d2
movl %eax, %ebp
movq 0x58(%rsp), %rsi
movl $0x200, %eax # imm = 0x200
jmp 0x3bb6e
movq 0x58(%rsp), %rdi
leaq 0x28(%r15), %r12
movq %r12, %rsi
callq 0x3d5e8
testq %rax, %rax
je 0x3bb73
movq %rax, %r14
movq 0x58(%rsp), %rdi
movq %r12, %rsi
callq 0x3d1de
movl %eax, %ebp
movq 0x58(%rsp), %rsi
movl $0x2a8, %eax # imm = 0x2A8
addq %rax, %rsi
jmp 0x3bb78
xorl %r14d, %r14d
xorl %esi, %esi
testq %r14, %r14
je 0x3bb94
testq %rsi, %rsi
je 0x3bb94
movq (%r15), %rdx
leaq 0x50(%rsp), %rdi
movl %ebp, %ecx
movq %r14, %r8
callq 0x3c544
addq $0x8, %r13
jmp 0x3ba2a
movq 0x20(%rsp), %r13
movq 0xa0(%r13), %rax
cmpq %rax, 0xa8(%r13)
je 0x3bc04
xorl %r14d, %r14d
movl $0x200, %ebx # imm = 0x200
leaq 0x21b99(%rip), %r15 # 0x5d75a
leaq 0x50(%rsp), %r12
movq (%rax,%r14,8), %r8
cmpq $0x0, 0x8(%r8)
jne 0x3bbe7
movq 0x58(%rsp), %rsi
addq %rbx, %rsi
movq %r12, %rdi
movq %r15, %rdx
movl %r14d, %ecx
callq 0x3c5c0
incl %r14d
movq 0xa0(%r13), %rax
movq 0xa8(%r13), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
ja 0x3bbc6
movq 0xe8(%r13), %rax
cmpq %rax, 0xf0(%r13)
je 0x3bc6a
xorl %r14d, %r14d
movl $0x270, %ebx # imm = 0x270
leaq 0x1e9c3(%rip), %r15 # 0x5a5e6
leaq 0x50(%rsp), %r12
movq (%rax,%r14,8), %r8
cmpq $0x0, 0x30(%r8)
jne 0x3bc4d
addq $0x28, %r8
movq 0x58(%rsp), %rsi
addq %rbx, %rsi
movq %r12, %rdi
movq %r15, %rdx
movl %r14d, %ecx
callq 0x3c5c0
incl %r14d
movq 0xe8(%r13), %rax
movq 0xf0(%r13), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
ja 0x3bc28
movq 0x88(%r13), %rax
cmpq %rax, 0x90(%r13)
je 0x3be05
xorl %r14d, %r14d
movq %rsp, %rbx
movq (%rax,%r14,8), %r12
cmpq $0x0, 0x8(%r12)
jne 0x3bcb4
movq 0x58(%rsp), %rsi
movl $0x1c8, %eax # imm = 0x1C8
addq %rax, %rsi
leaq 0x50(%rsp), %rdi
leaq 0x22ef4(%rip), %rdx # 0x5eb9d
movl %r14d, %ecx
movq %r12, %r8
callq 0x3c5c0
movq %r14, 0x28(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x78(%r12), %r13
subq 0x70(%r12), %r13
shrq $0x3, %r13
leaq 0xa0(%r12), %rdi
callq 0x3d37e
addl %eax, %r13d
leaq 0xb8(%r12), %rbp
movq %r13, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x3e5ee
movq (%rsp), %rax
cmpq %rax, 0x8(%rsp)
je 0x3bdb2
xorl %ebx, %ebx
xorl %r13d, %r13d
cmpq $0x0, 0x8(%rax,%rbx)
jne 0x3bd92
movq 0x78(%r12), %rax
subq 0x70(%r12), %rax
shrq $0x3, %rax
movl %eax, %eax
leaq 0x2462d(%rip), %rdx # 0x6035d
cmpq %rax, %r13
jb 0x3bd3c
leaq 0x21a25(%rip), %rdx # 0x5d761
leaq 0x40(%rsp), %r14
movq %r14, 0x30(%rsp)
movq $0x0, 0x38(%rsp)
movb $0x0, 0x40(%rsp)
leaq 0x50(%rsp), %rdi
movq %rbp, %rsi
movl %r13d, %ecx
leaq 0x30(%rsp), %r15
movq %r15, %r8
callq 0x3c5c0
movq (%rsp), %rdi
addq %rbx, %rdi
movq %r15, %rsi
callq 0x15130
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x3bd92
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x15200
incq %r13
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
addq $0x20, %rbx
cmpq %rcx, %r13
jb 0x3bd11
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x17f50
movl $0x0, 0xc8(%rsp)
leaq 0x60(%rsp), %rdi
movq %r12, %rsi
callq 0x3a4ae
cmpl $0x1, %eax
movq 0x20(%rsp), %r13
movq 0x28(%rsp), %r14
je 0x3be05
incl %r14d
movq 0x88(%r13), %rax
movq 0x90(%r13), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
ja 0x3bc84
movq 0x100(%r13), %rax
cmpq %rax, 0x108(%r13)
je 0x3be67
xorl %r14d, %r14d
movl $0x2a8, %ebx # imm = 0x2A8
leaq 0x23ec5(%rip), %r15 # 0x5fce9
leaq 0x50(%rsp), %r12
movq (%rax,%r14,8), %r8
cmpq $0x0, 0x8(%r8)
jne 0x3be4a
movq 0x58(%rsp), %rsi
addq %rbx, %rsi
movq %r12, %rdi
movq %r15, %rdx
movl %r14d, %ecx
callq 0x3c5c0
incl %r14d
movq 0x100(%r13), %rax
movq 0x108(%r13), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
ja 0x3be29
movq 0x130(%r13), %rax
cmpq %rax, 0x138(%r13)
je 0x3bec9
xorl %r14d, %r14d
movl $0x2e0, %ebx # imm = 0x2E0
leaq 0x23f0b(%rip), %r15 # 0x5fd91
leaq 0x50(%rsp), %r12
movq (%rax,%r14,8), %r8
cmpq $0x0, 0x8(%r8)
jne 0x3beac
movq 0x58(%rsp), %rsi
addq %rbx, %rsi
movq %r12, %rdi
movq %r15, %rdx
movl %r14d, %ecx
callq 0x3c5c0
incl %r14d
movq 0x130(%r13), %rax
movq 0x138(%r13), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
ja 0x3be8b
movq 0x70(%r13), %rax
cmpq %rax, 0x78(%r13)
je 0x3bf1f
xorl %r14d, %r14d
movl $0x190, %ebx # imm = 0x190
leaq 0x242ef(%rip), %r15 # 0x601d1
leaq 0x50(%rsp), %r12
movq (%rax,%r14,8), %r8
cmpq $0x0, 0x8(%r8)
jne 0x3bf08
movq 0x58(%rsp), %rsi
addq %rbx, %rsi
movq %r12, %rdi
movq %r15, %rdx
movl %r14d, %ecx
callq 0x3c5c0
incl %r14d
movq 0x70(%r13), %rax
movq 0x78(%r13), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
ja 0x3bee7
movq 0x148(%r13), %rax
cmpq %rax, 0x150(%r13)
je 0x3bf85
xorl %r14d, %r14d
movl $0x318, %ebx # imm = 0x318
leaq 0x2109f(%rip), %r15 # 0x5cfdd
leaq 0x50(%rsp), %r12
movq (%rax,%r14,8), %r8
cmpq $0x0, 0x10(%r8)
jne 0x3bf68
addq $0x8, %r8
movq 0x58(%rsp), %rsi
addq %rbx, %rsi
movq %r12, %rdi
movq %r15, %rdx
movl %r14d, %ecx
callq 0x3c5c0
incl %r14d
movq 0x148(%r13), %rax
movq 0x150(%r13), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
ja 0x3bf43
movq 0x118(%r13), %rax
cmpq %rax, 0x120(%r13)
je 0x3bfeb
xorl %r14d, %r14d
movl $0x350, %ebx # imm = 0x350
leaq 0x2422d(%rip), %r15 # 0x601d1
leaq 0x50(%rsp), %r12
movq (%rax,%r14,8), %r8
cmpq $0x0, 0x10(%r8)
jne 0x3bfce
addq $0x8, %r8
movq 0x58(%rsp), %rsi
addq %rbx, %rsi
movq %r12, %rdi
movq %r15, %rdx
movl %r14d, %ecx
callq 0x3c5c0
incl %r14d
movq 0x118(%r13), %rax
movq 0x120(%r13), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
ja 0x3bfa9
movq $0x0, 0x58(%rsp)
leaq 0x46dbd(%rip), %rax # 0x82db8
movq %rax, 0x50(%rsp)
movq 0xb0(%rsp), %rdi
testq %rdi, %rdi
je 0x3c01d
movq 0xc0(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
movq 0x98(%rsp), %rdi
testq %rdi, %rdi
je 0x3c03a
movq 0xa8(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x3c057
movq 0x90(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x3c06e
movq 0x78(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
xorl %eax, %eax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x24041(%rip), %rdi # 0x600ca
leaq 0x23c5d(%rip), %rsi # 0x5fced
leaq 0x23cb1(%rip), %rcx # 0x5fd48
movl $0x152, %edx # imm = 0x152
callq 0x15160
nop
| /WebAssembly[P]wabt/src/generate-names.cc |
wabt::ModuleContext::GetLabelArity(wabt::Var const&) const | Index ModuleContext::GetLabelArity(const Var& var) const {
auto label = GetLabel(var);
if (!label) {
return 0;
}
return label->label_type == LabelType::Loop ? label->param_types.size()
: label->result_types.size();
} | pushq %rax
callq 0x3c718
testq %rax, %rax
je 0x3c834
leaq 0x40(%rax), %rcx
leaq 0x28(%rax), %rdx
leaq 0x48(%rax), %rsi
movq %rax, %rdi
addq $0x30, %rdi
cmpl $0x3, 0x20(%rax)
cmoveq %rdx, %rcx
cmovneq %rsi, %rdi
movq (%rdi), %rax
subq (%rcx), %rax
shrq $0x3, %rax
jmp 0x3c836
xorl %eax, %eax
popq %rcx
retq
| /WebAssembly[P]wabt/src/ir-util.cc |
wabt::Module::AppendField(std::unique_ptr<wabt::ImportModuleField, std::default_delete<wabt::ImportModuleField>>) | void Module::AppendField(std::unique_ptr<ImportModuleField> field) {
Import* import = field->import.get();
const std::string* name = nullptr;
BindingHash* bindings = nullptr;
Index index = kInvalidIndex;
switch (import->kind()) {
case ExternalKind::Func: {
Func& func = cast<FuncImport>(import)->func;
name = &func.name;
bindings = &func_bindings;
index = funcs.size();
funcs.push_back(&func);
++num_func_imports;
break;
}
case ExternalKind::Table: {
Table& table = cast<TableImport>(import)->table;
name = &table.name;
bindings = &table_bindings;
index = tables.size();
tables.push_back(&table);
++num_table_imports;
break;
}
case ExternalKind::Memory: {
Memory& memory = cast<MemoryImport>(import)->memory;
name = &memory.name;
bindings = &memory_bindings;
index = memories.size();
memories.push_back(&memory);
++num_memory_imports;
break;
}
case ExternalKind::Global: {
Global& global = cast<GlobalImport>(import)->global;
name = &global.name;
bindings = &global_bindings;
index = globals.size();
globals.push_back(&global);
++num_global_imports;
break;
}
case ExternalKind::Tag: {
Tag& tag = cast<TagImport>(import)->tag;
name = &tag.name;
bindings = &tag_bindings;
index = tags.size();
tags.push_back(&tag);
++num_tag_imports;
break;
}
}
assert(name && bindings && index != kInvalidIndex);
if (!name->empty()) {
bindings->emplace(*name, Binding(field->loc, index));
}
imports.push_back(import);
fields.push_back(std::move(field));
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x40(%rax), %r15
movq %r15, 0x8(%rsp)
movl 0x48(%r15), %eax
cmpq $0x4, %rax
ja 0x3df50
leaq 0x2216c(%rip), %rcx # 0x5ffa8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addq $0x50, %r15
leaq 0x1c8(%rbx), %r12
movq 0x90(%rbx), %r13
subq 0x88(%rbx), %r13
leaq 0x88(%rbx), %rdi
shrq $0x3, %r13
leaq 0x10(%rsp), %rsi
movq %r15, (%rsi)
callq 0x3f0ae
incl 0x5c(%rbx)
jmp 0x3df5c
addq $0x50, %r15
leaq 0x190(%rbx), %r12
movq 0x78(%rbx), %r13
subq 0x70(%rbx), %r13
leaq 0x70(%rbx), %rdi
shrq $0x3, %r13
leaq 0x10(%rsp), %rsi
movq %r15, (%rsi)
callq 0x3edf2
incl 0x58(%rbx)
jmp 0x3df5c
addq $0x50, %r15
leaq 0x2e0(%rbx), %r12
movq 0x138(%rbx), %r13
subq 0x130(%rbx), %r13
leaq 0x130(%rbx), %rdi
shrq $0x3, %r13
leaq 0x10(%rsp), %rsi
movq %r15, (%rsi)
callq 0x3f5ee
incl 0x64(%rbx)
jmp 0x3df5c
addq $0x50, %r15
leaq 0x200(%rbx), %r12
movq 0xa8(%rbx), %r13
subq 0xa0(%rbx), %r13
leaq 0xa0(%rbx), %rdi
shrq $0x3, %r13
leaq 0x10(%rsp), %rsi
movq %r15, (%rsi)
callq 0x3f34e
incl 0x68(%rbx)
jmp 0x3df5c
addq $0x50, %r15
leaq 0x2a8(%rbx), %r12
movq 0x108(%rbx), %r13
subq 0x100(%rbx), %r13
leaq 0x100(%rbx), %rdi
shrq $0x3, %r13
leaq 0x10(%rsp), %rsi
movq %r15, (%rsi)
callq 0x3f49e
incl 0x60(%rbx)
jmp 0x3df5c
movl $0xffffffff, %r13d # imm = 0xFFFFFFFF
xorl %r12d, %r12d
xorl %r15d, %r15d
cmpl $-0x1, %r13d
je 0x3e041
testq %r15, %r15
je 0x3e041
testq %r12, %r12
je 0x3e041
cmpq $0x0, 0x8(%r15)
je 0x3dfa7
movq (%r14), %rax
movups 0x18(%rax), %xmm0
movups 0x28(%rax), %xmm1
leaq 0x10(%rsp), %rcx
movaps %xmm1, 0x10(%rcx)
movaps %xmm0, (%rcx)
movl %r13d, 0x20(%rcx)
movq %r12, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x3f73e
movq 0xc0(%rbx), %rsi
cmpq 0xc8(%rbx), %rsi
je 0x3dfc9
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0xc0(%rbx)
jmp 0x3dfda
leaq 0xb8(%rbx), %rdi
leaq 0x8(%rsp), %rdx
callq 0x3f7ce
movq (%r14), %rax
movq $0x0, (%r14)
cmpq $0x0, 0x10(%rax)
jne 0x3e022
cmpq $0x0, 0x8(%rax)
jne 0x3e022
movq 0x48(%rbx), %rcx
testq %rcx, %rcx
je 0x3e005
movq %rcx, 0x10(%rax)
addq $0x8, %rcx
jmp 0x3e009
leaq 0x40(%rbx), %rcx
movq %rax, (%rcx)
movq %rax, 0x48(%rbx)
incq 0x50(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x1984f(%rip), %rdi # 0x57878
leaq 0x193fc(%rip), %rsi # 0x5742c
leaq 0x223be(%rip), %rcx # 0x603f5
movl $0x1bd, %edx # imm = 0x1BD
callq 0x15160
leaq 0x2206e(%rip), %rdi # 0x600b6
leaq 0x21fa3(%rip), %rsi # 0x5fff2
leaq 0x2208b(%rip), %rcx # 0x600e1
movl $0x1d4, %edx # imm = 0x1D4
callq 0x15160
| /WebAssembly[P]wabt/src/ir.cc |
wabt::Module::AppendField(std::unique_ptr<wabt::MemoryModuleField, std::default_delete<wabt::MemoryModuleField>>) | void Module::AppendField(std::unique_ptr<MemoryModuleField> field) {
Memory& memory = field->memory;
if (!memory.name.empty()) {
memory_bindings.emplace(memory.name, Binding(field->loc, memories.size()));
}
memories.push_back(&memory);
fields.push_back(std::move(field));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x40(%rax), %r15
cmpq $0x0, 0x48(%rax)
je 0x3e0b5
movq 0x138(%rbx), %rdx
subq 0x130(%rbx), %rdx
leaq 0x2e0(%rbx), %rdi
shrq $0x3, %rdx
movups 0x18(%rax), %xmm0
movups 0x28(%rax), %xmm1
movq %rsp, %rcx
movaps %xmm1, 0x10(%rcx)
movaps %xmm0, (%rcx)
movl %edx, 0x20(%rcx)
xorl %esi, %esi
movq %r15, %rdx
callq 0x2511e
leaq 0x130(%rbx), %rdi
movq %rsp, %rsi
movq %r15, (%rsi)
callq 0x3f5ee
movq (%r14), %rax
movq $0x0, (%r14)
cmpq $0x0, 0x10(%rax)
jne 0x3e10b
cmpq $0x0, 0x8(%rax)
jne 0x3e10b
movq 0x48(%rbx), %rcx
testq %rcx, %rcx
je 0x3e0f2
movq %rcx, 0x10(%rax)
addq $0x8, %rcx
jmp 0x3e0f6
leaq 0x40(%rbx), %rcx
movq %rax, (%rcx)
movq %rax, 0x48(%rbx)
incq 0x50(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x19766(%rip), %rdi # 0x57878
leaq 0x19313(%rip), %rsi # 0x5742c
leaq 0x222d5(%rip), %rcx # 0x603f5
movl $0x1bd, %edx # imm = 0x1BD
callq 0x15160
| /WebAssembly[P]wabt/src/ir.cc |
wabt::Module::AppendField(std::unique_ptr<wabt::StartModuleField, std::default_delete<wabt::StartModuleField>>) | void Module::AppendField(std::unique_ptr<StartModuleField> field) {
starts.push_back(&field->start);
fields.push_back(std::move(field));
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
addq $0x160, %rdi # imm = 0x160
movq (%rsi), %rax
addq $0x40, %rax
movq %rsp, %rsi
movq %rax, (%rsi)
callq 0x3f8ee
movq (%r14), %rax
movq $0x0, (%r14)
cmpq $0x0, 0x10(%rax)
jne 0x3e18f
cmpq $0x0, 0x8(%rax)
jne 0x3e18f
movq 0x48(%rbx), %rcx
testq %rcx, %rcx
je 0x3e178
movq %rcx, 0x10(%rax)
addq $0x8, %rcx
jmp 0x3e17c
leaq 0x40(%rbx), %rcx
movq %rax, (%rcx)
movq %rax, 0x48(%rbx)
incq 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x196e2(%rip), %rdi # 0x57878
leaq 0x1928f(%rip), %rsi # 0x5742c
leaq 0x22251(%rip), %rcx # 0x603f5
movl $0x1bd, %edx # imm = 0x1BD
callq 0x15160
| /WebAssembly[P]wabt/src/ir.cc |
wabt::Module::AppendField(std::unique_ptr<wabt::ModuleField, std::default_delete<wabt::ModuleField>>) | void LocalTypes::Set(const TypeVector& types) {
decls_.clear();
if (types.empty()) {
return;
}
Type type = types[0];
Index count = 1;
for (Index i = 1; i < types.size(); ++i) {
if (types[i] != type) {
decls_.emplace_back(type, count);
type = types[i];
count = 1;
} else {
++count;
}
}
decls_.emplace_back(type, count);
} | pushq %rbx
subq $0x60, %rsp
movq (%rsi), %rax
movl 0x38(%rax), %ecx
cmpq $0xa, %rcx
ja 0x3e4c3
leaq 0x21d28(%rip), %rdx # 0x5ffbc
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq $0x0, (%rsi)
leaq 0x58(%rsp), %rbx
movq %rax, (%rbx)
movq %rbx, %rsi
callq 0x3dba8
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3e2c2
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x58(%rsp)
jmp 0x3e4c3
movq $0x0, (%rsi)
leaq 0x38(%rsp), %rbx
movq %rax, (%rbx)
movq %rbx, %rsi
callq 0x3dc72
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3e2f5
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x38(%rsp)
jmp 0x3e4c3
movq $0x0, (%rsi)
leaq 0x10(%rsp), %rbx
movq %rax, (%rbx)
movq %rbx, %rsi
callq 0x3e12a
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3e328
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x10(%rsp)
jmp 0x3e4c3
movq $0x0, (%rsi)
leaq 0x48(%rsp), %rbx
movq %rax, (%rbx)
movq %rbx, %rsi
callq 0x3de08
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3e35b
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x48(%rsp)
jmp 0x3e4c3
movq $0x0, (%rsi)
leaq 0x40(%rsp), %rbx
movq %rax, (%rbx)
movq %rbx, %rsi
callq 0x3dad2
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3e38e
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x40(%rsp)
jmp 0x3e4c3
movq $0x0, (%rsi)
leaq 0x20(%rsp), %rbx
movq %rax, (%rbx)
movq %rbx, %rsi
callq 0x3e060
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3e3c1
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x20(%rsp)
jmp 0x3e4c3
movq $0x0, (%rsi)
leaq 0x50(%rsp), %rbx
movq %rax, (%rbx)
movq %rbx, %rsi
callq 0x3dd3e
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3e3f4
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x50(%rsp)
jmp 0x3e4c3
movq $0x0, (%rsi)
leaq 0x30(%rsp), %rbx
movq %rax, (%rbx)
movq %rbx, %rsi
callq 0x3e1ae
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3e427
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x30(%rsp)
jmp 0x3e4c3
movq $0x0, (%rsi)
leaq 0x28(%rsp), %rbx
movq %rax, (%rbx)
movq %rbx, %rsi
callq 0x3d942
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3e45a
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x28(%rsp)
jmp 0x3e4c3
movq $0x0, (%rsi)
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
movq %rbx, %rsi
callq 0x3da10
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3e48a
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
jmp 0x3e4c3
movq $0x0, (%rsi)
leaq 0x18(%rsp), %rbx
movq %rax, (%rbx)
movq %rbx, %rsi
callq 0x3d874
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3e4ba
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x18(%rsp)
addq $0x60, %rsp
popq %rbx
retq
nop
| /WebAssembly[P]wabt/src/ir.cc |
wabt::Module::AppendFields(wabt::intrusive_list<wabt::ModuleField>*) | inline bool intrusive_list<T>::empty() const noexcept {
return size_ == 0;
} | movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x3e550
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq 0x8(%rsp), %r15
movq (%rbx), %rcx
cmpq 0x8(%rbx), %rcx
je 0x3e504
movq 0x8(%rcx), %rdx
movq %rdx, (%rbx)
movq $0x0, 0x10(%rdx)
jmp 0x3e507
movups %xmm0, (%rbx)
decq %rax
movups %xmm0, 0x8(%rcx)
movq %rax, 0x10(%rbx)
movq %rcx, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x3e278
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3e532
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
movq 0x10(%rbx), %rax
testq %rax, %rax
xorps %xmm0, %xmm0
jne 0x3e4ea
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
| /WebAssembly[P]wabt/include/wabt/intrusive-list.h |
wabt::Var::operator=(wabt::Var const&) | Var& Var::operator=(const Var& rhs) {
loc = rhs.loc;
if (rhs.is_index()) {
set_index(rhs.index_);
} else {
set_name(rhs.name_);
}
return *this;
} | pushq %rbx
movq %rdi, %rbx
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
cmpl $0x0, 0x20(%rsi)
je 0x3e774
movq 0x28(%rsi), %rdx
movq 0x30(%rsi), %rsi
movq %rbx, %rdi
callq 0x3e7c0
jmp 0x3e77f
movl 0x28(%rsi), %esi
movq %rbx, %rdi
callq 0x3e784
movq %rbx, %rax
popq %rbx
retq
| /WebAssembly[P]wabt/src/ir.cc |
wabt::WriteFixedU32Leb128(wabt::Stream*, unsigned int, char const*) | void WriteFixedU32Leb128(Stream* stream, uint32_t value, const char* desc) {
uint8_t data[MAX_U32_LEB128_BYTES];
Offset length =
WriteFixedU32Leb128Raw(data, data + MAX_U32_LEB128_BYTES, value);
stream->WriteData(data, length, desc);
} | pushq %rax
movq %rdx, %rcx
movl %esi, %edx
orb $-0x80, %dl
leaq 0x3(%rsp), %rax
movb %dl, (%rax)
movl %esi, %edx
shrl $0x7, %edx
orb $-0x80, %dl
movb %dl, 0x1(%rax)
movl %esi, %edx
shrl $0xe, %edx
orb $-0x80, %dl
movb %dl, 0x2(%rax)
movl %esi, %edx
shrl $0x15, %edx
orb $-0x80, %dl
movb %dl, 0x3(%rax)
shrl $0x1c, %esi
movb %sil, 0x4(%rax)
movl $0x5, %edx
movq %rax, %rsi
xorl %r8d, %r8d
callq 0x438c2
popq %rax
retq
| /WebAssembly[P]wabt/src/leb128.cc |
wabt::WriteU32Leb128Raw(unsigned char*, unsigned char*, unsigned int) | Offset WriteU32Leb128Raw(uint8_t* dest, uint8_t* dest_end, uint32_t value) {
uint8_t data[MAX_U32_LEB128_BYTES];
Offset length = 0;
LEB128_LOOP_UNTIL(value == 0);
if (static_cast<Offset>(dest_end - dest) < length) {
return 0;
}
memcpy(dest, data, length);
return length;
} | pushq %rbx
subq $0x10, %rsp
xorl %ebx, %ebx
movl %edx, %eax
shrl $0x7, %eax
movl %edx, %ecx
orb $-0x80, %cl
movzbl %cl, %ecx
cmpl $0x7f, %edx
cmovbel %edx, %ecx
movb %cl, 0xb(%rsp,%rbx)
leaq 0x1(%rbx), %rbx
movl %eax, %edx
ja 0x3fd65
subq %rdi, %rsi
leaq -0x1(%rbx), %rax
cmpq %rax, %rsi
jbe 0x3fd9d
leaq 0xb(%rsp), %rsi
movq %rbx, %rdx
callq 0x151a0
jmp 0x3fd9f
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
| /WebAssembly[P]wabt/src/leb128.cc |
wabt::WriteFixedS32Leb128(wabt::Stream*, unsigned int, char const*) | void WriteFixedS32Leb128(Stream* stream, uint32_t value, const char* desc) {
uint8_t data[MAX_U32_LEB128_BYTES];
data[0] = (value & 0x7f) | 0x80;
data[1] = ((value >> 7) & 0x7f) | 0x80;
data[2] = ((value >> 14) & 0x7f) | 0x80;
data[3] = ((value >> 21) & 0x7f) | 0x80;
// The last byte needs to be sign-extended.
data[4] = ((value >> 28) & 0x0f);
if (static_cast<int32_t>(value) < 0) {
data[4] |= 0x70;
}
stream->WriteData(data, MAX_U32_LEB128_BYTES, desc);
} | pushq %rax
movq %rdx, %rcx
movl %esi, %eax
movl %eax, %edx
orb $-0x80, %dl
leaq 0x3(%rsp), %rsi
movb %dl, (%rsi)
movl %eax, %edx
shrl $0x7, %edx
orb $-0x80, %dl
movb %dl, 0x1(%rsi)
movl %eax, %edx
shrl $0xe, %edx
orb $-0x80, %dl
movb %dl, 0x2(%rsi)
movl %eax, %edx
shrl $0x15, %edx
orb $-0x80, %dl
movb %dl, 0x3(%rsi)
movl %eax, %edx
shrl $0x1c, %edx
leal 0x70(%rdx), %r8d
testl %eax, %eax
movzbl %r8b, %eax
cmovnsl %edx, %eax
movb %al, 0x4(%rsi)
movl $0x5, %edx
xorl %r8d, %r8d
callq 0x438c2
popq %rax
retq
| /WebAssembly[P]wabt/src/leb128.cc |
wabt::ReadU32Leb128(unsigned char const*, unsigned char const*, unsigned int*) | size_t ReadU32Leb128(const uint8_t* p,
const uint8_t* end,
uint32_t* out_value) {
if (p < end && (p[0] & 0x80) == 0) {
*out_value = LEB128_1(uint32_t);
return 1;
} else if (p + 1 < end && (p[1] & 0x80) == 0) {
*out_value = LEB128_2(uint32_t);
return 2;
} else if (p + 2 < end && (p[2] & 0x80) == 0) {
*out_value = LEB128_3(uint32_t);
return 3;
} else if (p + 3 < end && (p[3] & 0x80) == 0) {
*out_value = LEB128_4(uint32_t);
return 4;
} else if (p + 4 < end && (p[4] & 0x80) == 0) {
// The top bits set represent values > 32 bits.
if (p[4] & 0xf0) {
return 0;
}
*out_value = LEB128_5(uint32_t);
return 5;
} else {
// past the end.
*out_value = 0;
return 0;
}
} | cmpq %rsi, %rdi
jae 0x3ff5d
movsbl (%rdi), %ecx
testl %ecx, %ecx
js 0x3ff5d
movl $0x1, %eax
jmp 0x40047
leaq 0x1(%rdi), %rax
cmpq %rsi, %rax
jae 0x3ff82
movsbl (%rax), %eax
testl %eax, %eax
js 0x3ff82
shll $0x7, %eax
movzbl (%rdi), %ecx
andl $0x7f, %ecx
orl %eax, %ecx
movl $0x2, %eax
jmp 0x40047
leaq 0x2(%rdi), %rax
cmpq %rsi, %rax
jae 0x3ffb3
movsbl (%rax), %eax
testl %eax, %eax
js 0x3ffb3
shll $0xe, %eax
movzbl 0x1(%rdi), %esi
andl $0x7f, %esi
shll $0x7, %esi
movzbl (%rdi), %ecx
andl $0x7f, %ecx
orl %esi, %ecx
orl %eax, %ecx
movl $0x3, %eax
jmp 0x40047
leaq 0x3(%rdi), %rax
cmpq %rsi, %rax
jae 0x3fff1
movsbl (%rax), %eax
testl %eax, %eax
js 0x3fff1
shll $0x15, %eax
movzbl 0x2(%rdi), %esi
andl $0x7f, %esi
shll $0xe, %esi
movzbl 0x1(%rdi), %r8d
andl $0x7f, %r8d
shll $0x7, %r8d
movzbl (%rdi), %ecx
andl $0x7f, %ecx
orl %r8d, %ecx
orl %esi, %ecx
orl %eax, %ecx
movl $0x4, %eax
jmp 0x40047
leaq 0x4(%rdi), %rax
cmpq %rsi, %rax
jae 0x40043
movzbl (%rax), %eax
testb %al, %al
js 0x40043
cmpb $0xf, %al
ja 0x4004a
shll $0x1c, %eax
movzbl 0x3(%rdi), %esi
andl $0x7f, %esi
shll $0x15, %esi
movzbl 0x2(%rdi), %r8d
andl $0x7f, %r8d
shll $0xe, %r8d
movzbl 0x1(%rdi), %r9d
andl $0x7f, %r9d
shll $0x7, %r9d
movzbl (%rdi), %ecx
andl $0x7f, %ecx
orl %r9d, %ecx
orl %r8d, %ecx
orl %esi, %ecx
orl %eax, %ecx
movl $0x5, %eax
jmp 0x40047
xorl %ecx, %ecx
xorl %eax, %eax
movl %ecx, (%rdx)
retq
xorl %eax, %eax
retq
| /WebAssembly[P]wabt/src/leb128.cc |
wabt::ReadU64Leb128(unsigned char const*, unsigned char const*, unsigned long*) | size_t ReadU64Leb128(const uint8_t* p,
const uint8_t* end,
uint64_t* out_value) {
if (p < end && (p[0] & 0x80) == 0) {
*out_value = LEB128_1(uint64_t);
return 1;
} else if (p + 1 < end && (p[1] & 0x80) == 0) {
*out_value = LEB128_2(uint64_t);
return 2;
} else if (p + 2 < end && (p[2] & 0x80) == 0) {
*out_value = LEB128_3(uint64_t);
return 3;
} else if (p + 3 < end && (p[3] & 0x80) == 0) {
*out_value = LEB128_4(uint64_t);
return 4;
} else if (p + 4 < end && (p[4] & 0x80) == 0) {
*out_value = LEB128_5(uint64_t);
return 5;
} else if (p + 5 < end && (p[5] & 0x80) == 0) {
*out_value = LEB128_6(uint64_t);
return 6;
} else if (p + 6 < end && (p[6] & 0x80) == 0) {
*out_value = LEB128_7(uint64_t);
return 7;
} else if (p + 7 < end && (p[7] & 0x80) == 0) {
*out_value = LEB128_8(uint64_t);
return 8;
} else if (p + 8 < end && (p[8] & 0x80) == 0) {
*out_value = LEB128_9(uint64_t);
return 9;
} else if (p + 9 < end && (p[9] & 0x80) == 0) {
// The top bits set represent values > 64 bits.
if (p[9] & 0xfe) {
return 0;
}
*out_value = LEB128_10(uint64_t);
return 10;
} else {
// past the end.
*out_value = 0;
return 0;
}
} | cmpq %rsi, %rdi
jae 0x40065
movsbq (%rdi), %rcx
testq %rcx, %rcx
js 0x40065
movl $0x1, %eax
jmp 0x40410
leaq 0x1(%rdi), %rax
cmpq %rsi, %rax
jae 0x4008e
movsbq (%rax), %rax
testq %rax, %rax
js 0x4008e
shlq $0x7, %rax
movzbl (%rdi), %ecx
andl $0x7f, %ecx
orq %rax, %rcx
movl $0x2, %eax
jmp 0x40410
leaq 0x2(%rdi), %rax
cmpq %rsi, %rax
jae 0x400c4
movsbq (%rax), %rax
testq %rax, %rax
js 0x400c4
shlq $0xe, %rax
movzbl 0x1(%rdi), %esi
andl $0x7f, %esi
shll $0x7, %esi
movzbl (%rdi), %ecx
andl $0x7f, %ecx
orq %rsi, %rcx
orq %rax, %rcx
movl $0x3, %eax
jmp 0x40410
leaq 0x3(%rdi), %rax
cmpq %rsi, %rax
jae 0x4010a
movsbq (%rax), %rax
testq %rax, %rax
js 0x4010a
shlq $0x15, %rax
movzbl 0x2(%rdi), %esi
andl $0x7f, %esi
shll $0xe, %esi
movzbl 0x1(%rdi), %r8d
andl $0x7f, %r8d
shll $0x7, %r8d
movzbl (%rdi), %ecx
andl $0x7f, %ecx
orq %r8, %rcx
orq %rsi, %rcx
orq %rax, %rcx
movl $0x4, %eax
jmp 0x40410
leaq 0x4(%rdi), %rax
cmpq %rsi, %rax
jae 0x40160
movsbq (%rax), %rax
testq %rax, %rax
js 0x40160
shlq $0x1c, %rax
movzbl 0x3(%rdi), %esi
andl $0x7f, %esi
shll $0x15, %esi
movzbl 0x2(%rdi), %r8d
andl $0x7f, %r8d
shll $0xe, %r8d
movzbl 0x1(%rdi), %r9d
andl $0x7f, %r9d
shll $0x7, %r9d
movzbl (%rdi), %ecx
andl $0x7f, %ecx
orq %r9, %rcx
orq %r8, %rcx
orq %rsi, %rcx
orq %rax, %rcx
movl $0x5, %eax
jmp 0x40410
leaq 0x5(%rdi), %rax
cmpq %rsi, %rax
jae 0x401c7
movsbq (%rax), %rax
testq %rax, %rax
js 0x401c7
shlq $0x23, %rax
movzbl 0x4(%rdi), %esi
andl $0x7f, %esi
shlq $0x1c, %rsi
movzbl 0x3(%rdi), %r8d
andl $0x7f, %r8d
shll $0x15, %r8d
movzbl 0x2(%rdi), %r9d
andl $0x7f, %r9d
shll $0xe, %r9d
movzbl 0x1(%rdi), %r10d
andl $0x7f, %r10d
shll $0x7, %r10d
movzbl (%rdi), %ecx
andl $0x7f, %ecx
orq %r10, %rcx
orq %r9, %rcx
orq %r8, %rcx
orq %rsi, %rcx
orq %rax, %rcx
movl $0x6, %eax
jmp 0x40410
leaq 0x6(%rdi), %rax
cmpq %rsi, %rax
jae 0x4023e
movsbq (%rax), %rax
testq %rax, %rax
js 0x4023e
shlq $0x2a, %rax
movzbl 0x5(%rdi), %esi
andl $0x7f, %esi
shlq $0x23, %rsi
movzbl 0x4(%rdi), %r8d
andl $0x7f, %r8d
shlq $0x1c, %r8
movzbl 0x3(%rdi), %r9d
andl $0x7f, %r9d
shll $0x15, %r9d
movzbl 0x2(%rdi), %r10d
andl $0x7f, %r10d
shll $0xe, %r10d
movzbl 0x1(%rdi), %r11d
andl $0x7f, %r11d
shll $0x7, %r11d
movzbl (%rdi), %ecx
andl $0x7f, %ecx
orq %r11, %rcx
orq %r10, %rcx
orq %r9, %rcx
orq %r8, %rcx
orq %rsi, %rcx
orq %rax, %rcx
movl $0x7, %eax
jmp 0x40410
leaq 0x7(%rdi), %rax
cmpq %rsi, %rax
jae 0x402c3
movsbq (%rax), %rcx
testq %rcx, %rcx
js 0x402c3
shlq $0x31, %rcx
movzbl 0x6(%rdi), %eax
andl $0x7f, %eax
shlq $0x2a, %rax
orq %rcx, %rax
movzbl 0x5(%rdi), %esi
andl $0x7f, %esi
shlq $0x23, %rsi
movzbl 0x4(%rdi), %r8d
andl $0x7f, %r8d
shlq $0x1c, %r8
movzbl 0x3(%rdi), %r9d
andl $0x7f, %r9d
shll $0x15, %r9d
movzbl 0x2(%rdi), %r10d
andl $0x7f, %r10d
shll $0xe, %r10d
movzbl 0x1(%rdi), %r11d
andl $0x7f, %r11d
shll $0x7, %r11d
movzbl (%rdi), %ecx
andl $0x7f, %ecx
orq %r11, %rcx
orq %r10, %rcx
orq %r9, %rcx
orq %r8, %rcx
orq %rsi, %rcx
orq %rax, %rcx
movl $0x8, %eax
jmp 0x40410
leaq 0x8(%rdi), %rax
cmpq %rsi, %rax
jae 0x4035e
movsbq (%rax), %rax
testq %rax, %rax
js 0x4035e
shlq $0x38, %rax
movzbl 0x7(%rdi), %ecx
andl $0x7f, %ecx
shlq $0x31, %rcx
orq %rax, %rcx
movzbl 0x6(%rdi), %eax
andl $0x7f, %eax
shlq $0x2a, %rax
orq %rcx, %rax
movzbl 0x5(%rdi), %esi
andl $0x7f, %esi
shlq $0x23, %rsi
movzbl 0x4(%rdi), %r8d
andl $0x7f, %r8d
shlq $0x1c, %r8
movzbl 0x3(%rdi), %r9d
andl $0x7f, %r9d
shll $0x15, %r9d
movzbl 0x2(%rdi), %r10d
andl $0x7f, %r10d
shll $0xe, %r10d
movzbl 0x1(%rdi), %r11d
andl $0x7f, %r11d
shll $0x7, %r11d
movzbl (%rdi), %ecx
andl $0x7f, %ecx
orq %r11, %rcx
orq %r10, %rcx
orq %r9, %rcx
orq %r8, %rcx
orq %rsi, %rcx
orq %rax, %rcx
movl $0x9, %eax
jmp 0x40410
leaq 0x9(%rdi), %rax
cmpq %rsi, %rax
jae 0x4040c
movsbq (%rax), %rax
testq %rax, %rax
js 0x4040c
cmpb $0x1, %al
ja 0x40414
shlq $0x3f, %rax
movzbl 0x8(%rdi), %ecx
andl $0x7f, %ecx
shlq $0x38, %rcx
orq %rax, %rcx
movzbl 0x7(%rdi), %esi
andl $0x7f, %esi
shlq $0x31, %rsi
orq %rcx, %rsi
movzbl 0x6(%rdi), %eax
andl $0x7f, %eax
shlq $0x2a, %rax
orq %rsi, %rax
movzbl 0x5(%rdi), %esi
andl $0x7f, %esi
shlq $0x23, %rsi
movzbl 0x4(%rdi), %r8d
andl $0x7f, %r8d
shlq $0x1c, %r8
movzbl 0x3(%rdi), %r9d
andl $0x7f, %r9d
shll $0x15, %r9d
movzbl 0x2(%rdi), %r10d
andl $0x7f, %r10d
shll $0xe, %r10d
movzbl 0x1(%rdi), %r11d
andl $0x7f, %r11d
shll $0x7, %r11d
movzbl (%rdi), %ecx
andl $0x7f, %ecx
orq %r11, %rcx
orq %r10, %rcx
orq %r9, %rcx
orq %r8, %rcx
orq %rsi, %rcx
orq %rax, %rcx
movl $0xa, %eax
jmp 0x40410
xorl %ecx, %ecx
xorl %eax, %eax
movq %rcx, (%rdx)
retq
xorl %eax, %eax
retq
| /WebAssembly[P]wabt/src/leb128.cc |
wabt::ReadS32Leb128(unsigned char const*, unsigned char const*, unsigned int*) | size_t ReadS32Leb128(const uint8_t* p,
const uint8_t* end,
uint32_t* out_value) {
if (p < end && (p[0] & 0x80) == 0) {
uint32_t result = LEB128_1(uint32_t);
*out_value = SIGN_EXTEND(int32_t, result, 6);
return 1;
} else if (p + 1 < end && (p[1] & 0x80) == 0) {
uint32_t result = LEB128_2(uint32_t);
*out_value = SIGN_EXTEND(int32_t, result, 13);
return 2;
} else if (p + 2 < end && (p[2] & 0x80) == 0) {
uint32_t result = LEB128_3(uint32_t);
*out_value = SIGN_EXTEND(int32_t, result, 20);
return 3;
} else if (p + 3 < end && (p[3] & 0x80) == 0) {
uint32_t result = LEB128_4(uint32_t);
*out_value = SIGN_EXTEND(int32_t, result, 27);
return 4;
} else if (p + 4 < end && (p[4] & 0x80) == 0) {
// The top bits should be a sign-extension of the sign bit.
bool sign_bit_set = (p[4] & 0x8);
int top_bits = p[4] & 0xf0;
if ((sign_bit_set && top_bits != 0x70) ||
(!sign_bit_set && top_bits != 0)) {
return 0;
}
uint32_t result = LEB128_5(uint32_t);
*out_value = result;
return 5;
} else {
// Past the end.
return 0;
}
} | cmpq %rsi, %rdi
jae 0x40433
movsbl (%rdi), %ecx
testl %ecx, %ecx
js 0x40433
shll $0x19, %ecx
sarl $0x19, %ecx
movl $0x1, %eax
jmp 0x40536
leaq 0x1(%rdi), %rax
cmpq %rsi, %rax
jae 0x4045e
movsbl (%rax), %eax
testl %eax, %eax
js 0x4045e
movzbl (%rdi), %ecx
andl $0x7f, %ecx
shll $0x19, %eax
shll $0x12, %ecx
orl %eax, %ecx
sarl $0x12, %ecx
movl $0x2, %eax
jmp 0x40536
leaq 0x2(%rdi), %rax
cmpq %rsi, %rax
jae 0x40495
movsbl (%rax), %eax
testl %eax, %eax
js 0x40495
movzbl 0x1(%rdi), %esi
andl $0x7f, %esi
movzbl (%rdi), %ecx
andl $0x7f, %ecx
shll $0x19, %eax
shll $0x12, %esi
shll $0xb, %ecx
orl %esi, %ecx
orl %eax, %ecx
sarl $0xb, %ecx
movl $0x3, %eax
jmp 0x40536
leaq 0x3(%rdi), %rax
cmpq %rsi, %rax
jae 0x404d9
movsbl (%rax), %eax
testl %eax, %eax
js 0x404d9
movzbl 0x2(%rdi), %esi
andl $0x7f, %esi
movzbl 0x1(%rdi), %r8d
andl $0x7f, %r8d
movzbl (%rdi), %ecx
andl $0x7f, %ecx
shll $0x19, %eax
shll $0x12, %esi
shll $0xb, %r8d
shll $0x4, %ecx
orl %r8d, %ecx
orl %esi, %ecx
orl %eax, %ecx
sarl $0x4, %ecx
movl $0x4, %eax
jmp 0x40536
leaq 0x4(%rdi), %rax
cmpq %rsi, %rax
jae 0x40539
movzbl (%rax), %ecx
testb %cl, %cl
js 0x40539
movl %ecx, %eax
shll $0x1c, %eax
movl %eax, %esi
sarl $0x1f, %esi
andl $0x70, %ecx
andl $0x70, %esi
cmpl %esi, %ecx
jne 0x40539
movzbl 0x3(%rdi), %esi
andl $0x7f, %esi
shll $0x15, %esi
movzbl 0x2(%rdi), %r8d
andl $0x7f, %r8d
shll $0xe, %r8d
movzbl 0x1(%rdi), %r9d
andl $0x7f, %r9d
shll $0x7, %r9d
movzbl (%rdi), %ecx
andl $0x7f, %ecx
orl %r9d, %ecx
orl %r8d, %ecx
orl %esi, %ecx
orl %eax, %ecx
movl $0x5, %eax
movl %ecx, (%rdx)
retq
xorl %eax, %eax
retq
| /WebAssembly[P]wabt/src/leb128.cc |
wabt::ReadS64Leb128(unsigned char const*, unsigned char const*, unsigned long*) | size_t ReadS64Leb128(const uint8_t* p,
const uint8_t* end,
uint64_t* out_value) {
if (p < end && (p[0] & 0x80) == 0) {
uint64_t result = LEB128_1(uint64_t);
*out_value = SIGN_EXTEND(int64_t, result, 6);
return 1;
} else if (p + 1 < end && (p[1] & 0x80) == 0) {
uint64_t result = LEB128_2(uint64_t);
*out_value = SIGN_EXTEND(int64_t, result, 13);
return 2;
} else if (p + 2 < end && (p[2] & 0x80) == 0) {
uint64_t result = LEB128_3(uint64_t);
*out_value = SIGN_EXTEND(int64_t, result, 20);
return 3;
} else if (p + 3 < end && (p[3] & 0x80) == 0) {
uint64_t result = LEB128_4(uint64_t);
*out_value = SIGN_EXTEND(int64_t, result, 27);
return 4;
} else if (p + 4 < end && (p[4] & 0x80) == 0) {
uint64_t result = LEB128_5(uint64_t);
*out_value = SIGN_EXTEND(int64_t, result, 34);
return 5;
} else if (p + 5 < end && (p[5] & 0x80) == 0) {
uint64_t result = LEB128_6(uint64_t);
*out_value = SIGN_EXTEND(int64_t, result, 41);
return 6;
} else if (p + 6 < end && (p[6] & 0x80) == 0) {
uint64_t result = LEB128_7(uint64_t);
*out_value = SIGN_EXTEND(int64_t, result, 48);
return 7;
} else if (p + 7 < end && (p[7] & 0x80) == 0) {
uint64_t result = LEB128_8(uint64_t);
*out_value = SIGN_EXTEND(int64_t, result, 55);
return 8;
} else if (p + 8 < end && (p[8] & 0x80) == 0) {
uint64_t result = LEB128_9(uint64_t);
*out_value = SIGN_EXTEND(int64_t, result, 62);
return 9;
} else if (p + 9 < end && (p[9] & 0x80) == 0) {
// The top bits should be a sign-extension of the sign bit.
bool sign_bit_set = (p[9] & 0x1);
int top_bits = p[9] & 0xfe;
if ((sign_bit_set && top_bits != 0x7e) ||
(!sign_bit_set && top_bits != 0)) {
return 0;
}
uint64_t result = LEB128_10(uint64_t);
*out_value = result;
return 10;
} else {
// Past the end.
return 0;
}
} | pushq %rbx
cmpq %rsi, %rdi
jae 0x4055d
movsbq (%rdi), %rcx
testq %rcx, %rcx
js 0x4055d
shlq $0x39, %rcx
sarq $0x39, %rcx
movl $0x1, %eax
jmp 0x40949
leaq 0x1(%rdi), %rax
cmpq %rsi, %rax
jae 0x4058e
movsbq (%rax), %rax
testq %rax, %rax
js 0x4058e
movzbl (%rdi), %ecx
andl $0x7f, %ecx
shlq $0x39, %rax
shlq $0x32, %rcx
orq %rax, %rcx
sarq $0x32, %rcx
movl $0x2, %eax
jmp 0x40949
leaq 0x2(%rdi), %rax
cmpq %rsi, %rax
jae 0x405cd
movsbq (%rax), %rax
testq %rax, %rax
js 0x405cd
movzbl 0x1(%rdi), %esi
andl $0x7f, %esi
movzbl (%rdi), %ecx
andl $0x7f, %ecx
shlq $0x39, %rax
shlq $0x32, %rsi
shlq $0x2b, %rcx
orq %rsi, %rcx
orq %rax, %rcx
sarq $0x2b, %rcx
movl $0x3, %eax
jmp 0x40949
leaq 0x3(%rdi), %rax
cmpq %rsi, %rax
jae 0x4061c
movsbq (%rax), %rax
testq %rax, %rax
js 0x4061c
movzbl 0x2(%rdi), %esi
andl $0x7f, %esi
movzbl 0x1(%rdi), %r8d
andl $0x7f, %r8d
movzbl (%rdi), %ecx
andl $0x7f, %ecx
shlq $0x39, %rax
shlq $0x32, %rsi
shlq $0x2b, %r8
shlq $0x24, %rcx
orq %r8, %rcx
orq %rsi, %rcx
orq %rax, %rcx
sarq $0x24, %rcx
movl $0x4, %eax
jmp 0x40949
leaq 0x4(%rdi), %rax
cmpq %rsi, %rax
jae 0x4067b
movsbq (%rax), %rax
testq %rax, %rax
js 0x4067b
movzbl 0x3(%rdi), %esi
andl $0x7f, %esi
movzbl 0x2(%rdi), %r8d
andl $0x7f, %r8d
movzbl 0x1(%rdi), %r9d
andl $0x7f, %r9d
movzbl (%rdi), %ecx
andl $0x7f, %ecx
shlq $0x39, %rax
shlq $0x32, %rsi
shlq $0x2b, %r8
shlq $0x24, %r9
shlq $0x1d, %rcx
orq %r9, %rcx
orq %r8, %rcx
orq %rsi, %rcx
orq %rax, %rcx
sarq $0x1d, %rcx
movl $0x5, %eax
jmp 0x40949
leaq 0x5(%rdi), %rax
cmpq %rsi, %rax
jae 0x406e9
movsbq (%rax), %rax
testq %rax, %rax
js 0x406e9
movzbl 0x4(%rdi), %esi
andl $0x7f, %esi
movzbl 0x3(%rdi), %r8d
andl $0x7f, %r8d
movzbl 0x2(%rdi), %r9d
andl $0x7f, %r9d
movzbl 0x1(%rdi), %r10d
andl $0x7f, %r10d
movzbl (%rdi), %ecx
andl $0x7f, %ecx
shlq $0x39, %rax
shlq $0x32, %rsi
shlq $0x2b, %r8
shlq $0x24, %r9
shlq $0x1d, %r10
shll $0x16, %ecx
orq %r10, %rcx
orq %r9, %rcx
orq %r8, %rcx
orq %rsi, %rcx
orq %rax, %rcx
sarq $0x16, %rcx
movl $0x6, %eax
jmp 0x40949
leaq 0x6(%rdi), %rax
cmpq %rsi, %rax
jae 0x40767
movsbq (%rax), %rax
testq %rax, %rax
js 0x40767
movzbl 0x5(%rdi), %esi
andl $0x7f, %esi
movzbl 0x4(%rdi), %r8d
andl $0x7f, %r8d
movzbl 0x3(%rdi), %r9d
andl $0x7f, %r9d
movzbl 0x2(%rdi), %r10d
andl $0x7f, %r10d
movzbl 0x1(%rdi), %r11d
andl $0x7f, %r11d
movzbl (%rdi), %ecx
andl $0x7f, %ecx
shlq $0x39, %rax
shlq $0x32, %rsi
shlq $0x2b, %r8
shlq $0x24, %r9
shlq $0x1d, %r10
shll $0x16, %r11d
shll $0xf, %ecx
orl %r11d, %ecx
orq %r10, %rcx
orq %r9, %rcx
orq %r8, %rcx
orq %rsi, %rcx
orq %rax, %rcx
sarq $0xf, %rcx
movl $0x7, %eax
jmp 0x40949
leaq 0x7(%rdi), %rax
cmpq %rsi, %rax
jae 0x407ef
movsbq (%rax), %r10
testq %r10, %r10
js 0x407ef
movzbl 0x6(%rdi), %eax
andl $0x7f, %eax
movzbl 0x5(%rdi), %esi
andl $0x7f, %esi
movzbl 0x4(%rdi), %r8d
andl $0x7f, %r8d
movzbl 0x3(%rdi), %r9d
andl $0x7f, %r9d
movzbl 0x2(%rdi), %r11d
andl $0x7f, %r11d
movzbl 0x1(%rdi), %ebx
andl $0x7f, %ebx
movzbl (%rdi), %ecx
andl $0x7f, %ecx
shlq $0x39, %r10
shlq $0x32, %rax
orq %r10, %rax
shlq $0x2b, %rsi
shlq $0x24, %r8
shlq $0x1d, %r9
shll $0x16, %r11d
shll $0xf, %ebx
shll $0x8, %ecx
orl %ebx, %ecx
orl %r11d, %ecx
orq %r9, %rcx
orq %r8, %rcx
orq %rsi, %rcx
orq %rax, %rcx
sarq $0x8, %rcx
movl $0x8, %eax
jmp 0x40949
leaq 0x8(%rdi), %rax
cmpq %rsi, %rax
jae 0x40890
movsbq (%rax), %rcx
testq %rcx, %rcx
js 0x40890
movzbl 0x7(%rdi), %r10d
andl $0x7f, %r10d
movzbl 0x6(%rdi), %eax
andl $0x7f, %eax
movzbl 0x5(%rdi), %esi
andl $0x7f, %esi
movzbl 0x4(%rdi), %r8d
andl $0x7f, %r8d
movzbl 0x3(%rdi), %r9d
andl $0x7f, %r9d
movzbl 0x2(%rdi), %r11d
andl $0x7f, %r11d
movzbl 0x1(%rdi), %ebx
andl $0x7f, %ebx
movb (%rdi), %dil
shlq $0x39, %rcx
shlq $0x32, %r10
orq %rcx, %r10
shlq $0x2b, %rax
orq %r10, %rax
shlq $0x24, %rsi
shlq $0x1d, %r8
shll $0x16, %r9d
shll $0xf, %r11d
shll $0x8, %ebx
addb %dil, %dil
movzbl %dil, %ecx
orq %rbx, %rcx
orq %r11, %rcx
orq %r9, %rcx
orq %r8, %rcx
orq %rsi, %rcx
orq %rax, %rcx
sarq %rcx
movl $0x9, %eax
jmp 0x40949
leaq 0x9(%rdi), %rax
cmpq %rsi, %rax
jae 0x4094e
movsbl (%rax), %eax
testl %eax, %eax
js 0x4094e
movl %eax, %ecx
andl $0x1, %ecx
negl %ecx
movl %eax, %esi
andl $0x7e, %esi
andl $0x7e, %ecx
cmpl %ecx, %esi
jne 0x4094e
shlq $0x3f, %rax
movzbl 0x8(%rdi), %ecx
andl $0x7f, %ecx
shlq $0x38, %rcx
orq %rax, %rcx
movzbl 0x7(%rdi), %esi
andl $0x7f, %esi
shlq $0x31, %rsi
orq %rcx, %rsi
movzbl 0x6(%rdi), %eax
andl $0x7f, %eax
shlq $0x2a, %rax
orq %rsi, %rax
movzbl 0x5(%rdi), %esi
andl $0x7f, %esi
shlq $0x23, %rsi
movzbl 0x4(%rdi), %r8d
andl $0x7f, %r8d
shlq $0x1c, %r8
movzbl 0x3(%rdi), %r9d
andl $0x7f, %r9d
shll $0x15, %r9d
movzbl 0x2(%rdi), %r10d
andl $0x7f, %r10d
shll $0xe, %r10d
movzbl 0x1(%rdi), %r11d
andl $0x7f, %r11d
shll $0x7, %r11d
movzbl (%rdi), %ecx
andl $0x7f, %ecx
orq %r11, %rcx
orq %r10, %rcx
orq %r9, %rcx
orq %r8, %rcx
orq %rsi, %rcx
orq %rax, %rcx
movl $0xa, %eax
movq %rcx, (%rdx)
popq %rbx
retq
xorl %eax, %eax
jmp 0x4094c
nop
| /WebAssembly[P]wabt/src/leb128.cc |
wabt::LexerSourceLineFinder::GetSourceLine(wabt::Location const&, unsigned long, wabt::LexerSourceLineFinder::SourceLine*) | Result LexerSourceLineFinder::GetSourceLine(const Location& loc,
Offset max_line_length,
SourceLine* out_source_line) {
ColumnRange column_range(loc.first_column, loc.last_column);
OffsetRange original;
CHECK_RESULT(GetLineOffsets(loc.line, &original));
OffsetRange clamped =
ClampSourceLineOffsets(original, column_range, max_line_length);
bool has_start_ellipsis = original.start != clamped.start;
bool has_end_ellipsis = original.end != clamped.end;
out_source_line->column_offset = clamped.start - original.start;
if (has_start_ellipsis) {
out_source_line->line += "...";
clamped.start += 3;
}
if (has_end_ellipsis) {
clamped.end -= 3;
}
std::vector<char> read_line;
CHECK_RESULT(source_->ReadRange(clamped, &read_line));
out_source_line->line.append(read_line.begin(), read_line.end());
if (has_end_ellipsis) {
out_source_line->line += "...";
}
return Result::Ok;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rdi, %r15
movl 0x14(%rsi), %r14d
movl 0x18(%rsi), %r13d
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
movl 0x10(%rsi), %esi
callq 0x40ab8
movl $0x1, %ebp
cmpl $0x1, %eax
je 0x40aa7
movq 0x20(%rsp), %rbp
movq 0x28(%rsp), %rax
shlq $0x20, %r13
orq %r14, %r13
movq %rax, %r14
movq %rbp, %rdi
movq %rax, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0x40cda
movq %rax, %r13
movq %rdx, %r12
subl %ebp, %eax
movl %eax, 0x20(%rbx)
cmpq %rbp, %r13
je 0x40a2e
leaq 0x22558(%rip), %rsi # 0x62f7a
movq %rbx, %rdi
callq 0x15430
addq $0x3, %r13
leaq -0x3(%r12), %rdx
cmpq %r12, %r14
cmoveq %r12, %rdx
xorps %xmm0, %xmm0
movq %rsp, %rcx
movaps %xmm0, (%rcx)
movq $0x0, 0x10(%rcx)
movq (%r15), %rdi
movq %r13, %rsi
callq 0x411ea
movl $0x1, %ebp
cmpl $0x1, %eax
je 0x40a91
movq (%rsp), %rcx
movq 0x8(%rsp), %r8
movq (%rbx), %rdx
addq 0x8(%rbx), %rdx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x40f6a
xorl %ebp, %ebp
cmpq %r12, %r14
je 0x40a91
leaq 0x224f1(%rip), %rsi # 0x62f7a
movq %rbx, %rdi
callq 0x15430
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x40aa7
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x15200
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/src/lexer-source-line-finder.cc |
wabt::LexerSourceLineFinder::GetLineOffsets(int, wabt::Range<unsigned long>*) | Result LexerSourceLineFinder::GetLineOffsets(int find_line,
OffsetRange* out_range) {
if (IsLineCached(find_line)) {
*out_range = GetCachedLine(find_line);
return Result::Ok;
}
const size_t kBufferSize = 1 << 16;
std::vector<char> buffer(kBufferSize);
assert(!line_ranges_.empty());
Offset buffer_file_offset = 0;
while (!IsLineCached(find_line) && !eof_) {
CHECK_RESULT(source_->Tell(&buffer_file_offset));
size_t read_size = source_->Fill(buffer.data(), buffer.size());
if (read_size < buffer.size()) {
eof_ = true;
}
for (auto iter = buffer.begin(), end = iter + read_size; iter < end;
++iter) {
if (*iter == '\n') {
// Don't include \n or \r in the line range.
Offset line_offset =
buffer_file_offset + (iter - buffer.begin()) - last_cr_;
line_ranges_.emplace_back(next_line_start_, line_offset);
next_line_start_ = line_offset + last_cr_ + 1;
}
last_cr_ = *iter == '\r';
}
if (eof_) {
// Add the final line as an empty range.
Offset end = buffer_file_offset + read_size;
line_ranges_.emplace_back(next_line_start_, end);
}
}
if (IsLineCached(find_line)) {
*out_range = GetCachedLine(find_line);
return Result::Ok;
} else {
assert(eof_);
return Result::Error;
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rdi, %r15
movslq %esi, %rbp
movq 0x10(%rdi), %rax
subq 0x8(%rdi), %rax
sarq $0x4, %rax
cmpq %rbp, %rax
jbe 0x40af6
movq %r15, %rdi
callq 0x40d52
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
xorl %ebx, %ebx
jmp 0x40c78
movl %esi, 0x1c(%rsp)
movq %rbx, 0x28(%rsp)
movl $0x10000, %edi # imm = 0x10000
callq 0x151f0
movq %rax, %r14
movl $0x10000, %edx # imm = 0x10000
movq %rax, %rdi
xorl %esi, %esi
callq 0x15140
movq 0x8(%r15), %rax
cmpq 0x10(%r15), %rax
je 0x40cbb
movq $0x0, 0x10(%rsp)
movq 0x10(%r15), %rax
subq 0x8(%r15), %rax
sarq $0x4, %rax
cmpq %rbp, %rax
seta %al
ja 0x40c51
cmpb $0x0, 0x29(%r15)
jne 0x40c4d
leaq 0x8(%r15), %r12
leaq 0x20(%r15), %r13
movq %rbp, 0x30(%rsp)
movq (%r15), %rdi
leaq 0x10(%rsp), %rsi
callq 0x41190
cmpl $0x1, %eax
je 0x40cb4
movq (%r15), %rdi
movl $0x10000, %edx # imm = 0x10000
movq %r14, %rsi
callq 0x4119a
cmpq $0xffff, %rax # imm = 0xFFFF
ja 0x40b95
movb $0x1, 0x29(%r15)
movq %rax, 0x20(%rsp)
testq %rax, %rax
jle 0x40c03
movq 0x20(%rsp), %rax
leaq (%r14,%rax), %rbx
xorl %ebp, %ebp
cmpb $0xa, (%r14,%rbp)
jne 0x40bea
movq 0x10(%rsp), %rax
movzbl 0x28(%r15), %ecx
subq %rcx, %rax
addq %rbp, %rax
movq %rax, 0x8(%rsp)
movq %r12, %rdi
movq %r13, %rsi
leaq 0x8(%rsp), %rdx
callq 0x40dd6
movq 0x8(%rsp), %rax
movzbl 0x28(%r15), %ecx
addq %rcx, %rax
incq %rax
movq %rax, 0x20(%r15)
cmpb $0xd, (%r14,%rbp)
sete 0x28(%r15)
leaq (%r14,%rbp), %rax
incq %rax
incq %rbp
cmpq %rbx, %rax
jb 0x40baa
cmpb $0x0, 0x29(%r15)
je 0x40c29
movq 0x20(%rsp), %rax
addq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %r12, %rdi
movq %r13, %rsi
leaq 0x8(%rsp), %rdx
callq 0x40dd6
movq 0x10(%r15), %rax
subq 0x8(%r15), %rax
sarq $0x4, %rax
movq 0x30(%rsp), %rbp
cmpq %rbp, %rax
seta %al
ja 0x40c51
cmpb $0x0, 0x29(%r15)
je 0x40b62
testb %al, %al
je 0x40c89
movq %r15, %rdi
movl 0x1c(%rsp), %esi
callq 0x40d52
movq 0x28(%rsp), %rcx
movq %rax, (%rcx)
movq %rdx, 0x8(%rcx)
xorl %ebx, %ebx
movl $0x10000, %esi # imm = 0x10000
movq %r14, %rdi
callq 0x15200
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1, %ebx
cmpb $0x0, 0x29(%r15)
jne 0x40c6b
leaq 0x1f941(%rip), %rdi # 0x605dd
leaq 0x1f836(%rip), %rsi # 0x604d9
leaq 0x1f8ec(%rip), %rcx # 0x60596
movl $0x78, %edx
callq 0x15160
movl $0x1, %ebx
jmp 0x40c6b
leaq 0x1f8be(%rip), %rdi # 0x60580
leaq 0x1f810(%rip), %rsi # 0x604d9
leaq 0x1f8c6(%rip), %rcx # 0x60596
movl $0x58, %edx
callq 0x15160
| /WebAssembly[P]wabt/src/lexer-source-line-finder.cc |
wabt::Opcode::GetBytes() const | std::vector<uint8_t> Opcode::GetBytes() const {
std::vector<uint8_t> result;
if (HasPrefix()) {
result.push_back(GetPrefix());
uint8_t buffer[5];
Offset length =
WriteU32Leb128Raw(buffer, buffer + sizeof(buffer), GetCode());
assert(length != 0);
result.insert(result.end(), buffer, buffer + length);
} else {
result.push_back(GetCode());
}
return result;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl (%rsi), %eax
leaq 0xc2eae(%rip), %r15 # 0x1043b0
cmpq $0x220, %rax # imm = 0x220
ja 0x41515
leaq (%rax,%rax,8), %rcx
movb 0x38(%r15,%rcx,8), %cl
jmp 0x4151c
movl %eax, %ecx
negl %ecx
shrl $0x9, %ecx
testb %cl, %cl
je 0x41532
cmpl $0x220, %eax # imm = 0x220
ja 0x41544
leaq (%rax,%rax,8), %rax
movb 0x38(%r15,%rax,8), %al
jmp 0x41549
cmpl $0x220, %eax # imm = 0x220
ja 0x415a2
leaq (%rax,%rax,8), %rax
movl 0x3c(%r15,%rax,8), %eax
jmp 0x415a4
negl %eax
shrl $0x9, %eax
leaq 0xa(%rsp), %rsi
movb %al, (%rsi)
movq %rbx, %rdi
callq 0x415e0
leaq 0x10(%rsp), %rsi
movl (%r14), %eax
cmpq $0x220, %rax # imm = 0x220
ja 0x41573
leaq (%rax,%rax,8), %rax
movl 0x3c(%r15,%rax,8), %edx
jmp 0x41578
negl %eax
movzbl %al, %edx
leaq 0xb(%rsp), %rdi
callq 0x3fd5c
testq %rax, %rax
je 0x415c0
movq 0x8(%rbx), %rsi
leaq (%rsp,%rax), %rcx
addq $0xb, %rcx
leaq 0xb(%rsp), %rdx
movq %rbx, %rdi
callq 0x416fe
jmp 0x415b3
negl %eax
leaq 0x9(%rsp), %rsi
movb %al, (%rsi)
movq %rbx, %rdi
callq 0x415e0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x216c9(%rip), %rdi # 0x62c90
leaq 0x216ce(%rip), %rsi # 0x62c9c
leaq 0x2171a(%rip), %rcx # 0x62cef
movl $0x1a7, %edx # imm = 0x1A7
callq 0x15160
nop
| /WebAssembly[P]wabt/src/opcode.cc |
wabt::OptionParser::AddOption(char, char const*, char const*, std::function<void ()> const&) | void OptionParser::AddOption(char short_name,
const char* long_name,
const char* help,
const NullCallback& callback) {
Option option(short_name, long_name, std::string(), HasArgument::No, help,
[callback](const char*) { callback(); });
AddOption(option);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x140, %rsp # imm = 0x140
movq %r8, %r14
movq %rcx, %r15
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x90(%rsp), %rdi
leaq 0xf(%rsp), %rax
movq %rdx, %rsi
movq %rax, %rdx
callq 0x300e2
leaq 0x80(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq 0x50(%rsp), %rdi
leaq 0xe(%rsp), %rdx
movq %r15, %rsi
callq 0x300e2
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x41e19
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
movl $0x2, %edx
callq *%rax
movq 0x18(%r14), %rax
movq %rax, 0x18(%r15)
movq 0x10(%r14), %rax
movq %rax, 0x10(%r15)
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movl $0x20, %edi
callq 0x151f0
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x41e69
leaq 0x10(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
movl $0x2, %edx
callq *%rax
movq 0x18(%r15), %rax
movq %rax, 0x18(%r14)
movq 0x10(%r15), %rax
movq %rax, 0x10(%r14)
leaq 0x30(%rsp), %r15
movq %r14, (%r15)
leaq 0xf14(%rip), %rax # 0x42d8c
movq %rax, 0x18(%r15)
leaq 0xf1d(%rip), %rax # 0x42da0
movq %rax, 0x10(%r15)
movq %r15, (%rsp)
movsbl %bpl, %esi
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rdx
leaq 0x70(%rsp), %rcx
leaq 0x50(%rsp), %r9
xorl %r8d, %r8d
callq 0x418e0
movq 0x10(%r15), %rax
testq %rax, %rax
je 0x41ec9
leaq 0x30(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x41ee2
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x41efd
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x15200
movq 0x70(%rsp), %rdi
cmpq %r12, %rdi
je 0x41f17
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x15200
leaq 0xa0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x41f38
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x15200
addq $0x40, %rbx
leaq 0xb0(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x42f0c
movq 0x80(%r14), %rax
testq %rax, %rax
je 0x41f6d
leaq 0x120(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x110(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x41f8e
movq 0x110(%rsp), %rsi
incq %rsi
callq 0x15200
leaq 0xe8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x41faf
movq 0xe8(%rsp), %rsi
incq %rsi
callq 0x15200
leaq 0xc8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x41fd0
movq 0xc8(%rsp), %rsi
incq %rsi
callq 0x15200
addq $0x140, %rsp # imm = 0x140
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/src/option-parser.cc |
wabt::OutputBuffer::WriteToFile(std::basic_string_view<char, std::char_traits<char>>) const | Result OutputBuffer::WriteToFile(std::string_view filename) const {
std::string filename_str(filename);
FILE* file = fopen(filename_str.c_str(), "wb");
if (!file) {
ERROR("unable to open %s for writing\n", filename_str.c_str());
return Result::Error;
}
if (data.empty()) {
fclose(file);
return Result::Ok;
}
ssize_t bytes = fwrite(data.data(), 1, data.size(), file);
if (bytes < 0 || static_cast<size_t>(bytes) != data.size()) {
ERROR("failed to write %" PRIzd " bytes to %s\n", data.size(),
filename_str.c_str());
fclose(file);
return Result::Error;
}
fclose(file);
return Result::Ok;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq (%rsi,%rdx), %rax
movq %rsp, %rbx
movq %rbx, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x16a80
movq (%rbx), %rdi
leaq 0x1f524(%rip), %rsi # 0x63004
callq 0x152d0
testq %rax, %rax
je 0x43b83
movq %rax, %rbx
movq (%r14), %rdi
movq 0x8(%r14), %rdx
cmpq %rdx, %rdi
je 0x43b1e
subq %rdi, %rdx
movl $0x1, %esi
movq %rbx, %rcx
callq 0x15440
testq %rax, %rax
js 0x43b4a
movq 0x8(%r14), %rcx
subq (%r14), %rcx
cmpq %rcx, %rax
jne 0x43b4a
movq %rbx, %rdi
callq 0x151e0
xorl %ebx, %ebx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x43b3e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x15200
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x4048f(%rip), %rax # 0x83fe0
movq (%rax), %rdi
movq 0x8(%r14), %r8
subq (%r14), %r8
movq (%rsp), %r9
leaq 0x1f51a(%rip), %rsi # 0x63080
leaq 0x1f4c0(%rip), %rdx # 0x6302d
movl $0x97, %ecx
xorl %eax, %eax
callq 0x15350
movq %rbx, %rdi
callq 0x151e0
jmp 0x43b8b
movq %rsp, %rdi
callq 0x159e8
movl $0x1, %ebx
jmp 0x43b28
| /WebAssembly[P]wabt/src/stream.cc |
wabt::MemoryStream::~MemoryStream() | MemoryStream(MemoryStream&&) = default; | pushq %rbx
movq %rdi, %rbx
leaq 0x3f287(%rip), %rax # 0x832d8
movq %rax, (%rdi)
movq 0x20(%rdi), %rsi
addq $0x20, %rbx
testq %rsi, %rsi
je 0x44069
movq %rbx, %rdi
callq 0x44102
movq $0x0, (%rbx)
popq %rbx
retq
| /WebAssembly[P]wabt/include/wabt/stream.h |
wabt::ValidateModule(wabt::Module const*, std::vector<wabt::Error, std::allocator<wabt::Error>>*, wabt::ValidateOptions const&) | Result ValidateModule(const Module* module,
Errors* errors,
const ValidateOptions& options) {
Validator validator(errors, module, options);
return validator.CheckModule();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x2a8, %rsp # imm = 0x2A8
movq %rdi, %rbx
leaq 0x3ef96(%rip), %r15 # 0x83398
leaq 0x20(%rsp), %r14
movq %r15, -0x18(%r14)
movq %rdx, -0x10(%r14)
movq %rsi, -0x8(%r14)
movq %r14, %rdi
callq 0x4d0de
movq %rbx, 0x278(%r14)
movl $0x0, 0x280(%r14)
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x44458
movl %eax, %ebp
movq %r15, (%rbx)
movq %r14, %rdi
callq 0x47a8e
movl %ebp, %eax
addq $0x2a8, %rsp # imm = 0x2A8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
| /WebAssembly[P]wabt/src/validator.cc |
wabt::(anonymous namespace)::ScriptValidator::CheckAction(wabt::Action const*) | ScriptValidator::ActionResult ScriptValidator::CheckAction(
const Action* action) {
ActionResult result;
ZeroMemory(result);
switch (action->type()) {
case ActionType::Invoke:
result.types = CheckInvoke(cast<InvokeAction>(action));
result.kind =
result.types ? ActionResult::Kind::Types : ActionResult::Kind::Error;
break;
case ActionType::Get:
if (Succeeded(CheckGet(cast<GetAction>(action), &result.type))) {
result.kind = ActionResult::Kind::Type;
} else {
result.kind = ActionResult::Kind::Error;
}
break;
}
return result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x90(%rsi), %eax
cmpl $0x1, %eax
je 0x452fd
testl %eax, %eax
jne 0x4534e
movq 0x10(%r14), %rdi
leaq 0x28(%rbx), %rsi
callq 0x3e5b2
testq %rax, %rax
je 0x45353
movq %rax, %r15
movq 0x70(%rbx), %rdx
movq 0x78(%rbx), %rsi
movq %rax, %rdi
callq 0x3d190
testq %rax, %rax
je 0x45390
addq $0x28, %rax
movq %r15, %rdi
movq %rax, %rsi
callq 0x3d4da
testq %rax, %rax
je 0x453d5
movq %rax, %r15
movq 0x98(%rbx), %rax
movq 0xa0(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x4, %rdx
movabsq $-0x3333333333333333, %r12 # imm = 0xCCCCCCCCCCCCCCCD
movq 0x78(%r15), %rsi
subq 0x70(%r15), %rsi
imulq %rdx, %r12
shrq $0x3, %rsi
movl %esi, %r9d
cmpq %r9, %r12
jne 0x453da
cmpq %rax, %rcx
je 0x452f1
cmpq $0x1, %r12
adcq $0x0, %r12
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x98(%rbx), %rsi
movq 0x20(%rsi,%r13), %rdx
addq %r13, %rsi
movl %ebp, %eax
movq 0x70(%r15), %rcx
movq (%rcx,%rax,8), %rcx
leaq 0x1dc59(%rip), %rax # 0x62f28
movq %rax, (%rsp)
movq %r14, %rdi
leaq 0x1e4b8(%rip), %r8 # 0x63795
movl %ebp, %r9d
callq 0x45608
incq %rbp
addq $0x50, %r13
cmpq %rbp, %r12
jne 0x452af
addq $0x88, %r15
jmp 0x4540d
movq 0x10(%r14), %rdi
leaq 0x28(%rbx), %rsi
callq 0x3e5b2
testq %rax, %rax
je 0x45373
movq %rax, %r15
movq 0x70(%rbx), %rdx
movq 0x78(%rbx), %rsi
movq %rax, %rdi
callq 0x3d190
testq %rax, %rax
je 0x453b1
addq $0x28, %rax
movq %r15, %rdi
movq %rax, %rsi
callq 0x3d546
testq %rax, %rax
je 0x4534e
movq 0x20(%rax), %r15
movl $0x2, %r12d
jmp 0x45417
xorl %r12d, %r12d
jmp 0x453d0
addq $0x8, %rbx
leaq 0x1e3cd(%rip), %rdx # 0x6372b
xorl %r15d, %r15d
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x45502
jmp 0x4540d
addq $0x8, %rbx
leaq 0x1e3ad(%rip), %rdx # 0x6372b
xorl %r12d, %r12d
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x45502
jmp 0x453d0
movq 0x70(%rbx), %rcx
addq $0x8, %rbx
leaq 0x1e39b(%rip), %rdx # 0x6373a
xorl %r15d, %r15d
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x45502
jmp 0x4540d
movq 0x70(%rbx), %rcx
addq $0x8, %rbx
leaq 0x1e40f(%rip), %rdx # 0x637cf
xorl %r12d, %r12d
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x45502
xorl %r15d, %r15d
jmp 0x45417
xorl %r15d, %r15d
jmp 0x4540d
addq $0x8, %rbx
cmpq %r9, %r12
leaq 0x1e3a4(%rip), %rax # 0x6378c
leaq 0x1e3a2(%rip), %rcx # 0x63791
cmovaq %rax, %rcx
leaq 0x1e35d(%rip), %rdx # 0x63757
xorl %r15d, %r15d
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %r8
xorl %eax, %eax
callq 0x45502
xorl %r12d, %r12d
testq %r15, %r15
setne %r12b
movl %r12d, %eax
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /WebAssembly[P]wabt/src/validator.cc |
wabt::(anonymous namespace)::Validator::OnTableSizeExpr(wabt::VarExpr<(wabt::ExprType)55>*) | Result Validator::OnTableSizeExpr(TableSizeExpr* expr) {
result_ |= validator_.OnTableSize(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 0x5166e
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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.