name string | code string | asm string | file string |
|---|---|---|---|
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::P... | 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 = 0xAAAA... | /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::El... | 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, %... | /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... | 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... | /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... | /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 %xm... | /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... | /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 %r... | /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 %... | /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 %r... | /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 %r... | /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), %... | /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
c... | /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_... | 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)... | /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()), 1ul... | 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)... | /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 = V... | 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 ... | /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(... | /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... | 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
cmp... | /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, %... | /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::ma... | 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 0x... | /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(... | /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... | 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, ... | /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... | 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 = 0xAAAAAAAAAA... | /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 # 0... | /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 # 0... | /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
po... | /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 0x2... | /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(%rb... | /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
... | /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)
m... | /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, (%rd... | /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)
m... | /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, (%r1... | /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)
m... | /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, %e... | /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, (%r1... | /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)
m... | /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 *0x... | /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) {
Ind... | 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 %rb... | /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_ +... | 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), %... | /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;
... | 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), %... | /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(ReadSt... | 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), %... | /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), %... | /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;
CHEC... | 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 ... | /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);
... | 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 $0x... | /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_typ... | 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),... | /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)];
... | 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 %ra... | /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 $... | /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,
... | 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... | /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<ExternalKin... | 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 0... | /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(a... | 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(%... | /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::... | 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
cm... | /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) {
fprint... | 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
m... | /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... | /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... | 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, ... | /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 ... | 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,... | /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 ... | /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
... | /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]) {
... | 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,... | /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, ... | /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, ... | /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;
... | 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,... | /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;
... | 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,... | /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;
... | 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,... | /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
mov... | /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 ... | /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... | /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
cmp... | /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,... | /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:... | 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, %rs... | /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
mov... | /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... | /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... | /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)->fun... | 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, %... | /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, ... | /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
test... | /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 {
... | 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 0x3e2c... | /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... | /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
m... | /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... | /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-extend... | 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)
mo... | /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;
} e... | 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
cm... | /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;
} e... | 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
cm... | /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) {
... | 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... | /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) {
... | 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... | /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(GetLineOff... | 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
mo... | /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);
ass... | 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
mov... | /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... | 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... | /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... | 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)
mov... | /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... | 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... | /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(%rs... | /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::Ty... | 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... | /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
movz... | /WebAssembly[P]wabt/src/validator.cc |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.