name string | code string | asm string | file string |
|---|---|---|---|
wabt::WastParser::ParseUnboundFuncSignature(wabt::FuncSignature*) | Result WastParser::ParseUnboundFuncSignature(FuncSignature* sig) {
WABT_TRACE(ParseUnboundFuncSignature);
CHECK_RESULT(ParseUnboundValueTypeList(TokenType::Param, &sig->param_types,
&sig->param_type_names));
CHECK_RESULT(ParseResultList(&sig->result_types, &sig->result_typ... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x30(%rsi), %rcx
movl $0x23, %esi
movq %rbx, %rdx
callq 0x9a4d6
movl %eax, %ecx
movl $0x1, %eax
cmpl $0x1, %ecx
je 0x99bb1
leaq 0x18(%rbx), %rdx
addq $0x68, %rbx
movq %r14, %rdi
movl $0x27, %esi
movq %rbx, %rcx
callq 0x9a4d6
movl %eax, %ecx
xorl %eax... | /wapm-packages[P]wabt/src/wast-parser.cc |
wabt::WastParser::ParseExportDesc(wabt::Export*) | Result WastParser::ParseExportDesc(Export* export_) {
WABT_TRACE(ParseExportDesc);
EXPECT(Lpar);
switch (Peek()) {
case TokenType::Func: export_->kind = ExternalKind::Func; break;
case TokenType::Table: export_->kind = ExternalKind::Table; break;
case TokenType::Memory: export_->kind = ExternalKind... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x1b, %esi
callq 0x92396
movl $0x1, %ebp
cmpl $0x1, %eax
je 0x99d38
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x91fb0
cmpl $0x1b, %eax
jle 0x99cdf
cmpl $0x1c, %eax
je 0x99cf1
cmpl $0x81... | /wapm-packages[P]wabt/src/wast-parser.cc |
wabt::WastParser::ParseBoundValueTypeList(wabt::TokenType, std::vector<wabt::Type, std::allocator<wabt::Type>>*, wabt::BindingHash*, std::unordered_map<unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::hash<unsigned int>, std::equal_to<unsigned int>, std::allocator<std::... | Result WastParser::ParseBoundValueTypeList(
TokenType token,
TypeVector* types,
BindingHash* bindings,
std::unordered_map<uint32_t, std::string>* type_names,
Index binding_index_offset) {
WABT_TRACE(ParseBoundValueTypeList);
while (MatchLpar(token)) {
if (PeekMatch(TokenType::Var)) {
s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %r8, %r14
movq %rcx, 0x38(%rsp)
movq %rdx, %r12
movl %esi, %r13d
movq %rdi, %rbx
movl %r9d, 0x4(%rsp)
movl %r9d, %eax
movq %rax, 0x30(%rsp)
leaq 0xa0(%rsp), %r15
movq %r8, 0x28(%rsp)
movq %rbx, %rdi
movl %r13d, %esi
callq 0x9235e
te... | /wapm-packages[P]wabt/src/wast-parser.cc |
wabt::(anonymous namespace)::IsInstr(std::array<wabt::TokenType, 2ul>) | bool IsInstr(TokenTypePair pair) {
return IsPlainOrBlockInstr(pair[0]) || IsExpr(pair);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x9ab24
movb $0x1, %bl
testb %al, %al
jne 0x9a7f4
leal -0x40(%r14), %eax
cmpl $0x38, %eax
jae 0x9a7c0
movabsq $0x80000001080001, %rcx # imm = 0x80000001080001
btq %rax, %rcx
jb 0x9a7f4
cmpl $0x1b, %r14d
jne 0x9a7f2
shrq $0x20, %r14
movl %r14d, %edi
callq 0x9ab24
te... | /wapm-packages[P]wabt/src/wast-parser.cc |
wabt::WastParser::ParseConst(wabt::Const*, wabt::WastParser::ConstType) | Result WastParser::ParseConst(Const* const_, ConstType const_type) {
WABT_TRACE(ParseConst);
Token opcode_token = Consume();
Opcode opcode = opcode_token.opcode();
const_->loc = GetLocation();
Token token = GetToken();
// V128 is fully handled by ParseSimdV128Const:
if (opcode != Opcode::V128Const) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xd8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x922f4
movl 0x20(%r15), %eax
addl $-0x38, %eax
cmpl $0x42, %eax
jae 0x9ccaf
movl 0x100(%rsp), %r12d
le... | /wapm-packages[P]wabt/src/wast-parser.cc |
wabt::WastParser::ParseBlockDeclaration(wabt::FuncDeclaration*) | Result WastParser::ParseBlockDeclaration(BlockDeclaration* decl) {
WABT_TRACE(ParseBlockDeclaration);
FuncDeclaration func_decl;
CHECK_RESULT(ParseTypeUseOpt(&func_decl));
CHECK_RESULT(ParseUnboundFuncSignature(&func_decl.sig));
decl->has_func_type = func_decl.has_func_type;
decl->type_var = func_decl.type_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10(%rsp), %rbx
movb $0x0, -0x8(%rbx)
movq %rbx, %rdi
callq 0xda074
leaq 0xb8(%rsp), %rax
xorps %xmm0, %xmm0
movups %xmm0, -0x40(%rax)
movups %xmm0, -0x50(%rax)
movups %xmm0, -0x60(%rax)
movq %rax, -... | /wapm-packages[P]wabt/src/wast-parser.cc |
wabt::WastParser::ParseInputCommand(std::unique_ptr<wabt::Command, std::default_delete<wabt::Command>>*) | Result WastParser::ParseInputCommand(CommandPtr*) {
// Parse the input command, but always fail since this command is not
// actually supported.
WABT_TRACE(ParseInputCommand);
EXPECT(Lpar);
Location loc = GetLocation();
EXPECT(Input);
Error(loc, "input command is not supported");
Var var;
std::string ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %rbx
movl $0x1b, %esi
callq 0x92396
cmpl $0x1, %eax
je 0x9e72d
leaq 0x68(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x91ed8
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movaps %xmm1, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movq %rbx, %rdi
movl ... | /wapm-packages[P]wabt/src/wast-parser.cc |
wabt::WastParser::ParseScriptModule(std::unique_ptr<wabt::ScriptModule, std::default_delete<wabt::ScriptModule>>*) | Result WastParser::ParseScriptModule(
std::unique_ptr<ScriptModule>* out_module) {
WABT_TRACE(ParseScriptModule);
EXPECT(Lpar);
Location loc = GetLocation();
EXPECT(Module);
std::string name;
ParseBindVarOpt(&name);
switch (Peek()) {
case TokenType::Bin: {
Consume();
std::vector<uint8... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x1b, %esi
callq 0x92396
movl $0x1, %ebp
cmpl $0x1, %eax
je 0x9f27b
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x91ed8
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movaps %xmm1, 0x3... | /wapm-packages[P]wabt/src/wast-parser.cc |
wabt::Result wabt::WastParser::ParseMemoryExpr<wabt::MemoryExpr<(wabt::ExprType)30>>(wabt::Location, std::unique_ptr<wabt::Expr, std::default_delete<wabt::Expr>>*) | Result WastParser::ParseMemoryExpr(Location loc,
std::unique_ptr<Expr>* out_expr) {
Var memidx;
CHECK_RESULT(ParseMemidx(loc, &memidx));
out_expr->reset(new T(memidx, loc));
return Result::Ok;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0xda074
movaps 0xe0(%rsp), %xmm0
movaps 0xf0(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x94f12
movl $0x1, %ebp
cmpl $... | /wapm-packages[P]wabt/src/wast-parser.cc |
wabt::RegisterCommand::~RegisterCommand() | RegisterCommand(std::string_view module_name, const Var& var)
: module_name(module_name), var(var) {} | pushq %rbx
movq %rdi, %rbx
leaq 0xa4b4b(%rip), %rax # 0x148988
movq %rax, (%rdi)
addq $0x30, %rdi
callq 0xda21c
movq 0x10(%rbx), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0xa3e61
movq (%rax), %rsi
incq %rsi
callq 0x2d0f0
movl $0x78, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x2d0f0
nop
| /wapm-packages[P]wabt/include/wabt/ir.h |
wabt::CircularArray<wabt::Token, 2ul>::pop_back() | void pop_back() {
assert(size_ > 0);
SetElement(back());
--size_;
} | pushq %rbx
cmpq $0x0, 0x80(%rdi)
je 0xa3ea7
movq %rdi, %rbx
callq 0xa3ec6
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0xc(%rax)
movl $0x0, 0x20(%rax)
decq 0x80(%rbx)
popq %rbx
retq
leaq 0x43972(%rip), %rdi # 0xe7820
leaq 0x4373c(%rip), %rsi # 0xe75f1
leaq 0x5a3b5(%rip), %rcx # 0xfe271
movl $0x50, ... | /wapm-packages[P]wabt/include/wabt/circular-array.h |
wabt::CircularArray<wabt::Token, 2ul>::back() | reference back() { return at(size_ - 1); } | movq 0x80(%rdi), %rax
testq %rax, %rax
je 0xa3ee4
notl %eax
addl 0x88(%rdi), %eax
andl $0x1, %eax
shll $0x6, %eax
addq %rdi, %rax
retq
pushq %rax
leaq 0x43806(%rip), %rdi # 0xe76f2
leaq 0x436fe(%rip), %rsi # 0xe75f1
leaq 0x5a436(%rip), %rcx # 0xfe330
movl $0x34, %edx
callq 0x2d170
| /wapm-packages[P]wabt/include/wabt/circular-array.h |
wabt::DataSegmentModuleField::~DataSegmentModuleField() | explicit DataSegmentModuleField(const Location& loc = Location(),
std::string_view name = std::string_view())
: ModuleFieldMixin<ModuleFieldType::DataSegment>(loc),
data_segment(name) {} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xa4059(%rip), %rax # 0x148aa8
movq %rax, (%rdi)
movq 0xc8(%rdi), %rdi
testq %rdi, %rdi
je 0xa4a6d
movq 0xd8(%rbx), %rsi
subq %rdi, %rsi
callq 0x2d0f0
leaq 0xb0(%rbx), %r14
movq 0xb0(%rbx), %rdi
testq %rdi, %rdi
je 0xa4a92
movq (%rdi), %rax
movq 0x8(%rdi), %r15
... | /wapm-packages[P]wabt/include/wabt/ir.h |
wabt::DataSegmentModuleField::~DataSegmentModuleField() | explicit DataSegmentModuleField(const Location& loc = Location(),
std::string_view name = std::string_view())
: ModuleFieldMixin<ModuleFieldType::DataSegment>(loc),
data_segment(name) {} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xa3fcb(%rip), %rax # 0x148aa8
movq %rax, (%rdi)
movq 0xc8(%rdi), %rdi
testq %rdi, %rdi
je 0xa4afb
movq 0xd8(%rbx), %rsi
subq %rdi, %rsi
callq 0x2d0f0
leaq 0xb0(%rbx), %r14
movq 0xb0(%rbx), %rdi
testq %rdi, %rdi
je 0xa4b20
movq (%rdi), %rax
movq 0x8(%rdi), %r15
... | /wapm-packages[P]wabt/include/wabt/ir.h |
wabt::ElemSegmentModuleField::~ElemSegmentModuleField() | explicit ElemSegmentModuleField(const Location& loc = Location(),
std::string_view name = std::string_view())
: ModuleFieldMixin<ModuleFieldType::ElemSegment>(loc),
elem_segment(name) {} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xa3f87(%rip), %rax # 0x148af8
movq %rax, (%rdi)
addq $0xd0, %rdi
callq 0xa4c66
leaq 0xb8(%rbx), %r14
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0xa4ba5
movq (%rdi), %rax
movq 0x8(%rdi), %r15
callq *0x8(%rax)
movq %r15, %rdi
testq %r15, %r15
jne 0xa4b93
xorps %xm... | /wapm-packages[P]wabt/include/wabt/ir.h |
wabt::ElemSegmentModuleField::~ElemSegmentModuleField() | explicit ElemSegmentModuleField(const Location& loc = Location(),
std::string_view name = std::string_view())
: ModuleFieldMixin<ModuleFieldType::ElemSegment>(loc),
elem_segment(name) {} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xa3f09(%rip), %rax # 0x148af8
movq %rax, (%rdi)
addq $0xd0, %rdi
callq 0xa4c66
leaq 0xb8(%rbx), %r14
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0xa4c23
movq (%rdi), %rax
movq 0x8(%rdi), %r15
callq *0x8(%rax)
movq %r15, %rdi
testq %r15, %r15
jne 0xa4c11
xorps %xm... | /wapm-packages[P]wabt/include/wabt/ir.h |
wabt::Tag::Tag(std::basic_string_view<char, std::char_traits<char>>) | explicit Tag(std::string_view name) : name(name) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
leaq (%rsi,%rdx), %rax
movq %rdx, %rsi
movq %rax, %rdx
callq 0x4e296
movb $0x0, 0x20(%rbx)
leaq 0x28(%rbx), %rdi
callq 0xda074
leaq 0xd0(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%rbx)
movups %xmm0, 0x80(%rbx)
movups %xmm0, 0x70(%rbx)
movq %rax,... | /wapm-packages[P]wabt/include/wabt/ir.h |
wabt::TagImport::~TagImport() | explicit TagImport(std::string_view name = std::string_view())
: ImportMixin<ExternalKind::Tag>(), tag(name) {} | pushq %rbx
movq %rdi, %rbx
leaq 0xa3dcb(%rip), %rax # 0x148b48
movq %rax, (%rdi)
addq $0x128, %rdi # imm = 0x128
callq 0xa33c2
leaq 0xf0(%rbx), %rdi
callq 0xa33c2
movq 0xd8(%rbx), %rdi
testq %rdi, %rdi
je 0xa4db3
movq 0xe8(%rbx), %rsi
subq %rdi, %rsi
callq 0x2d0f0
movq 0xc0(%rbx), %rdi
testq %rdi, %rdi
j... | /wapm-packages[P]wabt/include/wabt/ir.h |
wabt::TagImport::~TagImport() | explicit TagImport(std::string_view name = std::string_view())
: ImportMixin<ExternalKind::Tag>(), tag(name) {} | pushq %rbx
movq %rdi, %rbx
leaq 0xa3d45(%rip), %rax # 0x148b48
movq %rax, (%rdi)
addq $0x128, %rdi # imm = 0x128
callq 0xa33c2
leaq 0xf0(%rbx), %rdi
callq 0xa33c2
movq 0xd8(%rbx), %rdi
testq %rdi, %rdi
je 0xa4e39
movq 0xe8(%rbx), %rsi
subq %rdi, %rsi
callq 0x2d0f0
movq 0xc0(%rbx), %rdi
testq %rdi, %rdi
j... | /wapm-packages[P]wabt/include/wabt/ir.h |
wabt::TagModuleField::~TagModuleField() | explicit TagModuleField(const Location& loc = Location(),
std::string_view name = std::string_view())
: ModuleFieldMixin<ModuleFieldType::Tag>(loc), tag(name) {} | pushq %rbx
movq %rdi, %rbx
leaq 0xa3d0d(%rip), %rax # 0x148c18
movq %rax, (%rdi)
addq $0x118, %rdi # imm = 0x118
callq 0xa33c2
leaq 0xe0(%rbx), %rdi
callq 0xa33c2
movq 0xc8(%rbx), %rdi
testq %rdi, %rdi
je 0xa4f41
movq 0xd8(%rbx), %rsi
subq %rdi, %rsi
callq 0x2d0f0
movq 0xb0(%rbx), %rdi
testq %rdi, %rdi
j... | /wapm-packages[P]wabt/include/wabt/ir.h |
wabt::TagModuleField::~TagModuleField() | explicit TagModuleField(const Location& loc = Location(),
std::string_view name = std::string_view())
: ModuleFieldMixin<ModuleFieldType::Tag>(loc), tag(name) {} | pushq %rbx
movq %rdi, %rbx
leaq 0xa3c8d(%rip), %rax # 0x148c18
movq %rax, (%rdi)
addq $0x118, %rdi # imm = 0x118
callq 0xa33c2
leaq 0xe0(%rbx), %rdi
callq 0xa33c2
movq 0xc8(%rbx), %rdi
testq %rdi, %rdi
je 0xa4fc1
movq 0xd8(%rbx), %rsi
subq %rdi, %rsi
callq 0x2d0f0
movq 0xb0(%rbx), %rdi
testq %rdi, %rdi
j... | /wapm-packages[P]wabt/include/wabt/ir.h |
wabt::ExportModuleField::~ExportModuleField() | explicit ExportModuleField(const Location& loc = Location())
: ModuleFieldMixin<ModuleFieldType::Export>(loc) {} | pushq %rbx
movq %rdi, %rbx
leaq 0xa3c1f(%rip), %rax # 0x148c68
movq %rax, (%rdi)
addq $0x68, %rdi
callq 0xda21c
movq 0x40(%rbx), %rdi
leaq 0x50(%rbx), %rax
cmpq %rax, %rdi
je 0xa506d
movq (%rax), %rsi
incq %rsi
callq 0x2d0f0
movl $0xb0, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x2d0f0
nop
| /wapm-packages[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 0xa35dd(%rip), %rax # 0x148e68
movq %rax, (%rdi)
movq 0x50(%rdi), %rdi
leaq 0x60(%rbx), %rax
cmpq %rax, %rdi
je 0xa58a6
movq (%rax), %rsi
incq %rsi
callq 0x2d0f0
movq %rbx, %rdi
callq 0xa5928
movl $0x90, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x2d0f0
| /wapm-packages[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 0xa35c1(%rip), %rax # 0x148eb8
movq %rax, (%rdi)
movq 0x50(%rdi), %rdi
leaq 0x60(%rbx), %rax
cmpq %rax, %rdi
je 0xa5912
movq (%rax), %rsi
incq %rsi
callq 0x2d0f0
movq %rbx, %rdi
callq 0xa5928
movl $0x88, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x2d0f0
| /wapm-packages[P]wabt/include/wabt/ir.h |
wabt::Import::~Import() | virtual ~Import() = default; | pushq %rbx
movq %rdi, %rbx
leaq 0xa3275(%rip), %rax # 0x148ba8
movq %rax, (%rdi)
movq 0x28(%rdi), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0xa594e
movq (%rax), %rsi
incq %rsi
callq 0x2d0f0
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0xa5967
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x2d0f0
popq %r... | /wapm-packages[P]wabt/include/wabt/ir.h |
wabt::LoadStoreExpr<(wabt::ExprType)2>::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 0xda134
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r15)
leaq 0xa1439(%rip), %rax # 0x148738
movq %rax, (%r... | /wapm-packages[P]wabt/include/wabt/ir.h |
wabt::Block::Block() | Block() = default; | pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
xorl %eax, %eax
movb %al, 0x10(%rdi)
movb %al, 0x20(%rdi)
addq $0x28, %rdi
callq 0xda074
leaq 0xd0(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%rbx)
movups %xmm0, 0x80(%rbx)
movups %xmm0, 0x70(%rbx)
movq %rax, 0xa0(%rbx)
movl ... | /wapm-packages[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 0xa2877(%rip), %rax # 0x14a0e8
movq %rax, (%rdi)
leaq 0x150(%rdi), %r14
movq 0x150(%rdi), %rdi
testq %rdi, %rdi
je 0xa7899
movq (%rdi), %rax
movq 0x8(%rdi), %r15
callq *0x8(%rax)
movq %r15, %rdi
testq %r15, %r15
jne 0xa7887
xorps %xmm0, %xmm0
movups %xmm0, (%r14... | /wapm-packages[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 0xa27ef(%rip), %rax # 0x14a138
movq %rax, (%rdi)
leaq 0x150(%rdi), %r14
movq 0x150(%rdi), %rdi
testq %rdi, %rdi
je 0xa7971
movq (%rdi), %rax
movq 0x8(%rdi), %r15
callq *0x8(%rax)
movq %r15, %rdi
testq %r15, %r15
jne 0xa795f
xorps %xmm0, %xmm0
movups %xmm0, (%r14... | /wapm-packages[P]wabt/include/wabt/ir.h |
wabt::DataScriptModule<(wabt::ScriptModuleType)1>::~DataScriptModule() | const Location& location() const override { return loc; } | pushq %rbx
movq %rdi, %rbx
leaq 0xa2049(%rip), %rax # 0x14a6e8
movq %rax, (%rdi)
movq 0x50(%rdi), %rdi
testq %rdi, %rdi
je 0xa86b7
movq 0x60(%rbx), %rsi
subq %rdi, %rsi
callq 0x2d0f0
movq 0x30(%rbx), %rdi
leaq 0x40(%rbx), %rax
cmpq %rax, %rdi
je 0xa86cf
movq (%rax), %rsi
incq %rsi
callq 0x2d0f0
movl $0x68, %esi
mov... | /wapm-packages[P]wabt/include/wabt/ir.h |
wabt::interp::(anonymous namespace)::BinaryReaderInterp::OnImportGlobal(unsigned int, std::basic_string_view<char, std::char_traits<char>>, std::basic_string_view<char, std::char_traits<char>>, unsigned int, wabt::Type, bool) | Result BinaryReaderInterp::OnImportGlobal(Index import_index,
std::string_view module_name,
std::string_view field_name,
Index global_index,
Type type,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %r9, %r14
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %rbp
movq %rdi, %rbx
movb 0x100(%rsp), %al
movq 0xf8(%rsp), %rdx
leaq 0x28(%rdi), %rdi
leaq 0x50(%rsp), %rsi
movl $0x0, 0x18(%rsi)
movq $0x0, 0x10(%rsi)
movups 0x3a0(%rbx), %xmm0
m... | /wapm-packages[P]wabt/src/interp/binary-reader-interp.cc |
wabt::interp::(anonymous namespace)::BinaryReaderInterp::OnMemory(unsigned int, wabt::Limits const*) | Result BinaryReaderInterp::OnMemory(Index index, const Limits* limits) {
CHECK_RESULT(validator_.OnMemory(GetLocation(), *limits));
MemoryType memory_type{*limits};
module_.memories.push_back(MemoryDesc{memory_type});
memory_types_.push_back(memory_type);
return Result::Ok;
} | pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rdi, %rbx
addq $0x28, %rdi
movq %rsp, %rsi
movl $0x0, 0x18(%rsi)
movq $0x0, 0x10(%rsi)
movups 0x3a0(%rbx), %xmm0
movaps %xmm0, (%rsi)
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsi)
callq 0xdd724
movl %eax, %ecx
movl $0x1, %eax
cmpl $0x1, %ec... | /wapm-packages[P]wabt/src/interp/binary-reader-interp.cc |
wabt::interp::(anonymous namespace)::BinaryReaderInterp::OnAtomicStoreExpr(wabt::Opcode, unsigned int, unsigned long, unsigned long) | Result BinaryReaderInterp::OnAtomicStoreExpr(Opcode opcode,
Index memidx,
Address align_log2,
Address offset) {
CHECK_RESULT(validator_.OnAtomicStore(GetLocation(), opcode,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, %rbx
movl %edx, %r8d
movl %esi, 0x4(%rsp)
movq %rdi, %r15
leaq 0x28(%rdi), %r12
xorl %eax, %eax
leaq 0x30(%rsp), %r13
movl %eax, 0x18(%r13)
movq %rax, 0x10(%r13)
movups 0x3a0(%rdi), %xmm0
movaps %xmm0, (%r1... | /wapm-packages[P]wabt/src/interp/binary-reader-interp.cc |
wabt::interp::(anonymous namespace)::BinaryReaderInterp::OnAtomicRmwExpr(wabt::Opcode, unsigned int, unsigned long, unsigned long) | Result BinaryReaderInterp::OnAtomicRmwExpr(Opcode opcode,
Index memidx,
Address align_log2,
Address offset) {
CHECK_RESULT(validator_.OnAtomicRmw(GetLocation(), opcode,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, %rbx
movl %edx, %r8d
movl %esi, 0x4(%rsp)
movq %rdi, %r15
leaq 0x28(%rdi), %r12
xorl %eax, %eax
leaq 0x30(%rsp), %r13
movl %eax, 0x18(%r13)
movq %rax, 0x10(%r13)
movups 0x3a0(%rdi), %xmm0
movaps %xmm0, (%r1... | /wapm-packages[P]wabt/src/interp/binary-reader-interp.cc |
wabt::interp::(anonymous namespace)::BinaryReaderInterp::OnAtomicRmwCmpxchgExpr(wabt::Opcode, unsigned int, unsigned long, unsigned long) | Result BinaryReaderInterp::OnAtomicRmwCmpxchgExpr(Opcode opcode,
Index memidx,
Address align_log2,
Address offset) {
CHECK_RESULT(validator_.OnAtomicRmwCmpxchg(GetLocat... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, %rbx
movl %edx, %r8d
movl %esi, 0x4(%rsp)
movq %rdi, %r15
leaq 0x28(%rdi), %r12
xorl %eax, %eax
leaq 0x30(%rsp), %r13
movl %eax, 0x18(%r13)
movq %rax, 0x10(%r13)
movups 0x3a0(%rdi), %xmm0
movaps %xmm0, (%r1... | /wapm-packages[P]wabt/src/interp/binary-reader-interp.cc |
wabt::interp::(anonymous namespace)::BinaryReaderInterp::OnAtomicWaitExpr(wabt::Opcode, unsigned int, unsigned long, unsigned long) | Result BinaryReaderInterp::OnAtomicWaitExpr(Opcode opcode,
Index memidx,
Address align_log2,
Address offset) {
CHECK_RESULT(validator_.OnAtomicWait(GetLocation(), opcode,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, %rbx
movl %edx, %r8d
movl %esi, 0x4(%rsp)
movq %rdi, %r15
leaq 0x28(%rdi), %r12
xorl %eax, %eax
leaq 0x30(%rsp), %r13
movl %eax, 0x18(%r13)
movq %rax, 0x10(%r13)
movups 0x3a0(%rdi), %xmm0
movaps %xmm0, (%r1... | /wapm-packages[P]wabt/src/interp/binary-reader-interp.cc |
wabt::interp::(anonymous namespace)::BinaryReaderInterp::OnAtomicFenceExpr(unsigned int) | Result BinaryReaderInterp::OnAtomicFenceExpr(uint32_t consistency_model) {
CHECK_RESULT(validator_.OnAtomicFence(GetLocation(), consistency_model));
istream_.Emit(Opcode::AtomicFence, consistency_model);
return Result::Ok;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %r14
addq $0x28, %rdi
movq %rsp, %rsi
movl $0x0, 0x18(%rsi)
movq $0x0, 0x10(%rsi)
movups 0x3a0(%r14), %xmm0
movaps %xmm0, (%rsi)
movq 0x8(%r14), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsi)
movl %ebx, %edx
callq 0xdea08
movl %eax, %ecx
movl $0x1, %ea... | /wapm-packages[P]wabt/src/interp/binary-reader-interp.cc |
wabt::interp::(anonymous namespace)::BinaryReaderInterp::OnBinaryExpr(wabt::Opcode) | Result BinaryReaderInterp::OnBinaryExpr(Opcode opcode) {
CHECK_RESULT(validator_.OnBinary(GetLocation(), opcode));
istream_.Emit(opcode);
return Result::Ok;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %r14
addq $0x28, %rdi
movq %rsp, %rsi
movl $0x0, 0x18(%rsi)
movq $0x0, 0x10(%rsi)
movups 0x3a0(%r14), %xmm0
movaps %xmm0, (%rsi)
movq 0x8(%r14), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsi)
movl %ebx, %edx
callq 0xdefd4
movl %eax, %ecx
movl $0x1, %ea... | /wapm-packages[P]wabt/src/interp/binary-reader-interp.cc |
wabt::interp::(anonymous namespace)::BinaryReaderInterp::OnBlockExpr(wabt::Type) | Result BinaryReaderInterp::OnBlockExpr(Type sig_type) {
CHECK_RESULT(validator_.OnBlock(GetLocation(), sig_type));
PushLabel();
return Result::Ok;
} | pushq %rbp
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
addq $0x28, %rdi
movq %rsp, %rsi
movl $0x0, 0x18(%rsi)
movq $0x0, 0x10(%rsi)
movups 0x3a0(%rbx), %xmm0
movaps %xmm0, (%rsi)
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsi)
callq 0xdf00e
movl $0x1, %ebp
cmpl $0x1, %eax
je 0xaaaa9
xor... | /wapm-packages[P]wabt/src/interp/binary-reader-interp.cc |
wabt::interp::(anonymous namespace)::BinaryReaderInterp::OnBrExpr(unsigned int) | Result BinaryReaderInterp::OnBrExpr(Index depth) {
Index drop_count, keep_count, catch_drop_count;
CHECK_RESULT(GetBrDropKeepCount(depth, &drop_count, &keep_count));
CHECK_RESULT(validator_.GetCatchCount(depth, &catch_drop_count));
CHECK_RESULT(validator_.OnBr(GetLocation(), Var(depth, GetLocation())));
EmitB... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0xc(%rsp), %rdx
leaq 0x8(%rsp), %rcx
callq 0xaedd6
movl $0x1, %ebp
cmpl $0x1, %eax
je 0xaab93
leaq 0x48(%r14), %rdi
leaq 0x4(%rsp), %rdx
movl %ebx, %esi
callq 0xe35f6
cmpl $0x1, %eax
je 0xaab93
leaq 0... | /wapm-packages[P]wabt/src/interp/binary-reader-interp.cc |
wabt::interp::(anonymous namespace)::BinaryReaderInterp::OnBrIfExpr(unsigned int) | Result BinaryReaderInterp::OnBrIfExpr(Index depth) {
Index drop_count, keep_count, catch_drop_count;
CHECK_RESULT(validator_.OnBrIf(GetLocation(), Var(depth, GetLocation())));
CHECK_RESULT(GetBrDropKeepCount(depth, &drop_count, &keep_count));
CHECK_RESULT(validator_.GetCatchCount(depth, &catch_drop_count));
/... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x28(%rdi), %r14
xorl %eax, %eax
leaq 0x30(%rsp), %r15
movl %eax, 0x18(%r15)
movq %rax, 0x10(%r15)
movups 0x3a0(%rdi), %xmm0
movaps %xmm0, (%r15)
movq 0x8(%rdi), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%r15)
... | /wapm-packages[P]wabt/src/interp/binary-reader-interp.cc |
wabt::interp::(anonymous namespace)::BinaryReaderInterp::OnConvertExpr(wabt::Opcode) | Result BinaryReaderInterp::OnConvertExpr(Opcode opcode) {
CHECK_RESULT(validator_.OnConvert(GetLocation(), opcode));
istream_.Emit(opcode);
return Result::Ok;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %r14
addq $0x28, %rdi
movq %rsp, %rsi
movl $0x0, 0x18(%rsi)
movq $0x0, 0x10(%rsi)
movups 0x3a0(%r14), %xmm0
movaps %xmm0, (%rsi)
movq 0x8(%r14), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsi)
movl %ebx, %edx
callq 0xdf688
movl %eax, %ecx
movl $0x1, %ea... | /wapm-packages[P]wabt/src/interp/binary-reader-interp.cc |
wabt::interp::(anonymous namespace)::BinaryReaderInterp::OnDropExpr() | Result BinaryReaderInterp::OnDropExpr() {
CHECK_RESULT(validator_.OnDrop(GetLocation()));
istream_.Emit(Opcode::Drop);
return Result::Ok;
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
addq $0x28, %rdi
movq %rsp, %rsi
movl $0x0, 0x18(%rsi)
movq $0x0, 0x10(%rsi)
movups 0x3a0(%rbx), %xmm0
movaps %xmm0, (%rsi)
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsi)
callq 0xdf7cc
movl %eax, %ecx
movl $0x1, %eax
cmpl $0x1, %ecx
je 0xab85b
movq 0x20(%rbx... | /wapm-packages[P]wabt/src/interp/binary-reader-interp.cc |
wabt::interp::(anonymous namespace)::BinaryReaderInterp::OnEndExpr() | Result BinaryReaderInterp::OnSimdStoreLaneExpr(Opcode opcode,
Index memidx,
Address alignment_log2,
Address offset,
uint64_t value) ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq 0x2b0(%rdi), %rax
subq 0x2a8(%rdi), %rax
xorl %ebp, %ebp
cmpq $0x10, %rax
je 0xaba6b
movq %rdi, %rbx
addq $0x48, %rdi
leaq 0x8(%rsp), %rdx
xorl %esi, %esi
callq 0xe338a
movl $0x1, %ebp
cmpl $0x1, %eax
je 0xaba6b
leaq 0x28(%rbx), %rdi
movq 0x8(%rsp), %rax... | /wapm-packages[P]wabt/src/interp/binary-reader-interp.cc |
wabt::interp::(anonymous namespace)::BinaryReaderInterp::OnF32ConstExpr(unsigned int) | Result BinaryReaderInterp::OnF32ConstExpr(uint32_t value_bits) {
CHECK_RESULT(validator_.OnConst(GetLocation(), Type::F32));
istream_.Emit(Opcode::F32Const, value_bits);
return Result::Ok;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %r14
addq $0x28, %rdi
movq %rsp, %rsi
movl $0x0, 0x18(%rsi)
movq $0x0, 0x10(%rsi)
movups 0x3a0(%r14), %xmm0
movaps %xmm0, (%rsi)
movq 0x8(%r14), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsi)
movq $-0x3, %rdx
callq 0xdf65a
movl %eax, %ecx
movl $0x1, %e... | /wapm-packages[P]wabt/src/interp/binary-reader-interp.cc |
wabt::interp::(anonymous namespace)::BinaryReaderInterp::OnTableSizeExpr(unsigned int) | Result BinaryReaderInterp::OnTableSizeExpr(Index table_index) {
CHECK_RESULT(
validator_.OnTableSize(GetLocation(), Var(table_index, GetLocation())));
istream_.Emit(Opcode::TableSize, table_index);
return Result::Ok;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x28(%rdi), %r15
xorl %eax, %eax
leaq 0x20(%rsp), %r12
movl %eax, 0x18(%r12)
movq %rax, 0x10(%r12)
movups 0x3a0(%rdi), %xmm0
movaps %xmm0, (%r12)
movq 0x8(%rdi), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, ... | /wapm-packages[P]wabt/src/interp/binary-reader-interp.cc |
wabt::interp::(anonymous namespace)::BinaryReaderInterp::OnRefIsNullExpr() | Result BinaryReaderInterp::OnRefIsNullExpr() {
CHECK_RESULT(validator_.OnRefIsNull(GetLocation()));
istream_.Emit(Opcode::RefIsNull);
return Result::Ok;
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
addq $0x28, %rdi
movq %rsp, %rsi
movl $0x0, 0x18(%rsi)
movq $0x0, 0x10(%rsi)
movups 0x3a0(%rbx), %xmm0
movaps %xmm0, (%rsi)
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsi)
callq 0xe05a0
movl %eax, %ecx
movl $0x1, %eax
cmpl $0x1, %ecx
je 0xacf29
movq 0x20(%rbx... | /wapm-packages[P]wabt/src/interp/binary-reader-interp.cc |
wabt::interp::(anonymous namespace)::BinaryReaderInterp::OnReturnCallExpr(unsigned int) | Result BinaryReaderInterp::OnReturnCallExpr(Index func_index) {
CHECK_RESULT(
validator_.OnReturnCall(GetLocation(), Var(func_index, GetLocation())));
FuncType& func_type = func_types_[func_index];
Index drop_count, keep_count, catch_drop_count;
CHECK_RESULT(
GetReturnCallDropKeepCount(func_type, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdi, %rbx
leaq 0x28(%rdi), %r14
xorl %ebp, %ebp
leaq 0x30(%rsp), %r15
movl %ebp, 0x18(%r15)
movq %rbp, 0x10(%r15)
movups 0x3a0(%rdi), %xmm0
movaps %xmm0, (%r15)
movq 0x8(%rdi), %rax
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%r15)
leaq ... | /wapm-packages[P]wabt/src/interp/binary-reader-interp.cc |
wabt::interp::(anonymous namespace)::BinaryReaderInterp::OnSelectExpr(unsigned int, wabt::Type*) | Result BinaryReaderInterp::OnSelectExpr(Index result_count,
Type* result_types) {
CHECK_RESULT(validator_.OnSelect(GetLocation(), result_count, result_types));
istream_.Emit(Opcode::Select);
return Result::Ok;
} | pushq %rbx
subq $0x20, %rsp
movq %rdx, %rcx
movl %esi, %edx
movq %rdi, %rbx
addq $0x28, %rdi
movq %rsp, %rsi
movl $0x0, 0x18(%rsi)
movq $0x0, 0x10(%rsi)
movups 0x3a0(%rbx), %xmm0
movaps %xmm0, (%rsi)
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsi)
callq 0xe089a
movl %eax, %ecx
movl $0x1, %eax
cmpl $0x1... | /wapm-packages[P]wabt/src/interp/binary-reader-interp.cc |
wabt::interp::(anonymous namespace)::BinaryReaderInterp::OnStoreExpr(wabt::Opcode, unsigned int, unsigned long, unsigned long) | Result BinaryReaderInterp::OnStoreExpr(Opcode opcode,
Index memidx,
Address align_log2,
Address offset) {
CHECK_RESULT(validator_.OnStore(GetLocation(), opcode,
Var(me... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, %rbx
movl %edx, %r8d
movl %esi, 0x4(%rsp)
movq %rdi, %r15
leaq 0x28(%rdi), %r12
xorl %eax, %eax
leaq 0x30(%rsp), %r13
movl %eax, 0x18(%r13)
movq %rax, 0x10(%r13)
movups 0x3a0(%rdi), %xmm0
movaps %xmm0, (%r1... | /wapm-packages[P]wabt/src/interp/binary-reader-interp.cc |
wabt::interp::(anonymous namespace)::BinaryReaderInterp::OnThrowExpr(unsigned int) | Result BinaryReaderInterp::OnThrowExpr(Index tag_index) {
CHECK_RESULT(
validator_.OnThrow(GetLocation(), Var(tag_index, GetLocation())));
istream_.Emit(Opcode::Throw, tag_index);
return Result::Ok;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x28(%rdi), %r15
xorl %eax, %eax
leaq 0x20(%rsp), %r12
movl %eax, 0x18(%r12)
movq %rax, 0x10(%r12)
movups 0x3a0(%rdi), %xmm0
movaps %xmm0, (%r12)
movq 0x8(%rdi), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, ... | /wapm-packages[P]wabt/src/interp/binary-reader-interp.cc |
wabt::interp::(anonymous namespace)::BinaryReaderInterp::OnTryExpr(wabt::Type) | Result BinaryReaderInterp::OnTryExpr(Type sig_type) {
u32 exn_stack_height;
CHECK_RESULT(
validator_.GetCatchCount(label_stack_.size() - 1, &exn_stack_height));
u32 value_stack_height = validator_.type_stack_size();
CHECK_RESULT(validator_.OnTry(GetLocation(), sig_type));
// Push a label that tracks map... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq 0x2b0(%rdi), %rax
subq 0x2a8(%rdi), %rax
movq %rsi, %r14
shrq $0x4, %rax
decl %eax
addq $0x48, %rdi
leaq 0xc(%rsp), %rdx
movl %eax, %esi
callq 0xe35f6
movl $0x1, %ebp
cmpl $0x1, %eax
je 0xad953
leaq 0x28(%rbx), %rdi
movq 0x68(%... | /wapm-packages[P]wabt/src/interp/binary-reader-interp.cc |
wabt::interp::(anonymous namespace)::BinaryReaderInterp::OnUnreachableExpr() | Result BinaryReaderInterp::OnUnreachableExpr() {
CHECK_RESULT(validator_.OnUnreachable(GetLocation()));
istream_.Emit(Opcode::Unreachable);
return Result::Ok;
} | pushq %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
addq $0x28, %rdi
movq %rsp, %rsi
movl $0x0, 0x18(%rsi)
movq $0x0, 0x10(%rsi)
movups 0x3a0(%rbx), %xmm0
movaps %xmm0, (%rsi)
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsi)
callq 0xe1404
movl $0x1, %ebp
cmpl $0x1, %eax
je 0xada77
movq 0x20(%rbx), %r... | /wapm-packages[P]wabt/src/interp/binary-reader-interp.cc |
wabt::interp::(anonymous namespace)::BinaryReaderInterp::OnElemSegmentElemExpr_RefFunc(unsigned int, unsigned int) | Result BinaryReaderInterp::OnElemSegmentElemExpr_RefFunc(Index segment_index,
Index func_index) {
CHECK_RESULT(validator_.OnElemSegmentElemExpr_RefFunc(
GetLocation(), Var(func_index, GetLocation())));
ElemDesc& elem = module_.elems.back();
elem.eleme... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %edx, %ebx
movq %rdi, %r14
leaq 0x28(%rdi), %r15
xorl %eax, %eax
movq %rsp, %r12
movl %eax, 0x18(%r12)
movq %rax, 0x10(%r12)
movups 0x3a0(%rdi), %xmm0
movaps %xmm0, (%r12)
movq 0x8(%rdi), %rcx
movq 0x10(%rcx), %rdx
movq %rdx, 0x10(%... | /wapm-packages[P]wabt/src/interp/binary-reader-interp.cc |
wabt::interp::(anonymous namespace)::BinaryReaderInterp::BeginDataSegment(unsigned int, unsigned int, unsigned char) | Result BinaryReaderInterp::BeginDataSegment(Index index,
Index memory_index,
uint8_t flags) {
auto mode = ToSegmentMode(flags);
CHECK_RESULT(validator_.OnDataSegment(
GetLocation(), Var(memory_index, GetLocation()), mode))... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movl %edx, %ebp
movq %rdi, %rbx
movl %ecx, %eax
notl %eax
andl $0x1, %ecx
testb $0x3, %al
movl $0x2, %r14d
cmovnel %ecx, %r14d
leaq 0x28(%rdi), %r15
xorl %eax, %eax
leaq 0xb0(%rsp), %r12
movl %eax, 0x18(%r12)
mo... | /wapm-packages[P]wabt/src/interp/binary-reader-interp.cc |
wabt::interp::(anonymous namespace)::BinaryReaderInterp::OnDataSegmentData(unsigned int, void const*, unsigned long) | Result BinaryReaderInterp::OnDataSegmentData(Index index,
const void* src_data,
Address size) {
DataDesc& dst_data = module_.datas.back();
if (size > 0) {
dst_data.data.resize(size);
memcpy(dst_data.data.data(), src_da... | testq %rcx, %rcx
je 0xae853
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq 0x18(%rdi), %rax
movq 0xf8(%rax), %r15
leaq -0x98(%r15), %rdi
movq %rcx, %rsi
callq 0x41116
movq -0x98(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2d0a0
popq %rbx
popq %r14
popq %r15
xorl %eax, %eax
retq
| /wapm-packages[P]wabt/src/interp/binary-reader-interp.cc |
wabt::interp::(anonymous namespace)::BinaryReaderInterp::BeginInitExpr(wabt::Type, wabt::interp::FuncDesc*) | Result BinaryReaderInterp::BeginInitExpr(Type type, FuncDesc* func) {
label_stack_.clear();
func_ = func;
func_->code_offset = istream_.end();
CHECK_RESULT(validator_.BeginInitExpr(GetLocation(), type));
// Push implicit init func label (equivalent to return).
PushLabel(LabelKind::Try, Istream::kInvalidOffs... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x2a8(%rdi), %rax
cmpq %rax, 0x2b0(%rdi)
je 0xaea14
movq %rax, 0x2b0(%rbx)
movq %rdx, 0x2a0(%rbx)
movq 0x20(%rbx), %rdi
callq 0xc9778
movq 0x2a0(%rbx), %rcx
movl %eax, 0x58(%rcx)
leaq 0x28(%rbx), %rdi
movq %rsp, %rsi
movl $0x0, 0x18(%rsi)
movq ... | /wapm-packages[P]wabt/src/interp/binary-reader-interp.cc |
wabt::interp::Match(wabt::interp::GlobalType const&, wabt::interp::GlobalType const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | Result Match(const GlobalType& expected,
const GlobalType& actual,
std::string* out_msg) {
if (actual.mut != expected.mut) {
*out_msg = StringPrintf(
"mutability mismatch in imported global, expected %s but got %s.",
GetName(actual.mut), GetName(expected.mut));
return... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %rbx
movslq 0x14(%rsi), %rax
movslq 0x14(%rdi), %rcx
cmpl %ecx, %eax
jne 0xb368d
movq %rsi, %r14
movl 0xc(%rsi), %edx
xorl %eax, %eax
cmpl 0xc(%rdi), %edx
je 0xb36dc
cmpl $0x1, %ecx
je 0xb35e3
movl 0xc(%rdi), %ecx
cmpl 0xc(%r14), %ecx
je 0xb36dc
mo... | /wapm-packages[P]wabt/src/interp/interp.cc |
wabt::interp::FuncDesc::GetLocalType(unsigned int) const | ValueType FuncDesc::GetLocalType(Index index) const {
if (index < type.params.size()) {
return type.params[index];
}
index -= type.params.size();
auto iter = std::lower_bound(
locals.begin(), locals.end(), index + 1,
[](const LocalDesc& lhs, Index rhs) { return lhs.end < rhs; });
assert(iter ... | pushq %rax
movl %esi, %eax
movq 0x10(%rdi), %rcx
movq 0x18(%rdi), %r8
subq %rcx, %r8
sarq $0x3, %r8
cmpq %rax, %r8
jbe 0xb37e1
leaq (%rcx,%rax,8), %rax
jmp 0xb382b
movq 0x40(%rdi), %rax
movq 0x48(%rdi), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x4, %rdx
testq %rdx, %rdx
jle 0xb3826
subl %r8d, %esi
incl %esi
movq %rdx... | /wapm-packages[P]wabt/src/interp/interp.cc |
wabt::interp::Store::Mark(wabt::interp::Ref) | void Store::Mark(Ref ref) {
size_t index = ref.index;
if (gc_context_.marks[index])
return;
gc_context_.marks[index] = true;
if (WABT_UNLIKELY(gc_context_.call_depth >= max_call_depth)) {
gc_context_.untraced_objects.push_back(index);
return;
}
gc_context_.call_depth++;
objects_.Get(index)... | pushq %rbx
subq $0x10, %rsp
movq %rsi, %rcx
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
leaq 0x3f(%rsi), %rax
testq %rsi, %rsi
cmovnsq %rsi, %rax
sarq $0x6, %rax
shlq $0x3, %rax
addq 0x20(%rdi), %rax
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
leaq 0x3f(%rsi), %rdi
andq %rcx, %rdi
xorl %edx, %edx
cmpq %rsi, ... | /wapm-packages[P]wabt/src/interp/interp.cc |
wabt::interp::Thread::Run(int, wabt::interp::RefPtr<wabt::interp::Trap>*) | RunResult Thread::Run(int num_instructions, Trap::Ptr* out_trap) {
DefinedFunc::Ptr func{store_, frames_.back().func};
for (; num_instructions > 0; --num_instructions) {
auto result = StepInternal(out_trap);
if (result != RunResult::Ok) {
return result;
}
}
return RunResult::Ok;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
movq 0x8(%rdi), %rax
movq 0x60(%rdi), %rsi
movq -0x28(%rax), %rdx
movq %rsp, %rdi
callq 0x4b5d2
xorl %ebx, %ebx
testl %ebp, %ebp
jle 0xb7291
incl %ebp
movq %r15, %rdi
movq %r14, %rsi
callq 0xb72c6
tes... | /wapm-packages[P]wabt/src/interp/interp.cc |
wabt::interp::Thread::Push(wabt::interp::Ref) | void Thread::Push(Ref ref) {
refs_.push_back(values_.size());
values_.push_back(Value::Make(ref));
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rax
subq 0x18(%rdi), %rax
shrq $0x4, %rax
movl %eax, 0x8(%rsp)
movq 0x38(%rdi), %rsi
cmpq 0x40(%rdi), %rsi
je 0xbb109
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x38(%rbx)
jmp 0xbb117
leaq 0x30(%rbx), %rdi
leaq 0x8(%rsp), %rdx
ca... | /wapm-packages[P]wabt/src/interp/interp.cc |
wabt::interp::Thread::DoTableInit(wabt::interp::Instr, wabt::interp::RefPtr<wabt::interp::Trap>*) | RunResult Thread::DoTableInit(Instr instr, Trap::Ptr* out_trap) {
Table::Ptr table{store_, inst_->tables()[instr.imm_u32x2.fst]};
auto&& elem = inst_->elems()[instr.imm_u32x2.snd];
auto size = Pop<u32>();
auto src = Pop<u32>();
auto dst = Pop<u32>();
TRAP_IF(Failed(table->Init(store_, dst, elem, src, size))... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x60(%rdi), %rsi
movq 0x68(%rdi), %rax
movl 0x98(%rsp), %ecx
movq 0x78(%rax), %rax
movq (%rax,%rcx,8), %rdx
movq %rsp, %r15
movq %r15, %rdi
callq 0x4dfbe
movq 0x68(%r14), %rax
movl 0x9c(%rsp), %r12d
s... | /wapm-packages[P]wabt/src/interp/interp.cc |
wabt::interp::Thread::DoTableGet(wabt::interp::Instr, wabt::interp::RefPtr<wabt::interp::Trap>*) | RunResult Thread::DoTableGet(Instr instr, Trap::Ptr* out_trap) {
Table::Ptr table{store_, inst_->tables()[instr.imm_u32]};
auto index = Pop<u32>();
Ref ref;
TRAP_IF(Failed(table->Get(index, &ref)),
StringPrintf(
"out of bounds table access: table.get at %u >= max value %u",
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x60(%rdi), %rsi
movq 0x68(%rdi), %rax
movl 0x98(%rsp), %ecx
movq 0x78(%rax), %rax
movq (%rax,%rcx,8), %rdx
movq %rsp, %r15
movq %r15, %rdi
callq 0x4dfbe
movq %r14, %rdi
callq 0xbb040
movq (%r15), %rcx
movq 0x70... | /wapm-packages[P]wabt/src/interp/interp.cc |
wabt::interp::Thread::DoTableGrow(wabt::interp::Instr, wabt::interp::RefPtr<wabt::interp::Trap>*) | RunResult Thread::DoTableGrow(Instr instr, Trap::Ptr* out_trap) {
Table::Ptr table{store_, inst_->tables()[instr.imm_u32]};
u32 old_size = table->size();
auto delta = Pop<u32>();
auto ref = Pop<Ref>();
if (Failed(table->Grow(store_, delta, ref))) {
Push<s32>(-1);
} else {
Push<u32>(old_size);
}
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x60(%rdi), %rsi
movq 0x68(%rdi), %rax
movl 0x58(%rsp), %ecx
movq 0x78(%rax), %rax
movq (%rax,%rcx,8), %rdx
movq %rsp, %r14
movq %r14, %rdi
callq 0x4dfbe
movq (%r14), %r15
movq 0x78(%r15), %r13
subq 0x70(%r15), %r13
movq %rbx, ... | /wapm-packages[P]wabt/src/interp/interp.cc |
wabt::interp::Thread::DoTableFill(wabt::interp::Instr, wabt::interp::RefPtr<wabt::interp::Trap>*) | RunResult Thread::DoTableFill(Instr instr, Trap::Ptr* out_trap) {
Table::Ptr table{store_, inst_->tables()[instr.imm_u32]};
auto size = Pop<u32>();
auto value = Pop<Ref>();
auto dst = Pop<u32>();
TRAP_IF(Failed(table->Fill(store_, dst, value, size)),
"out of bounds table access: table.fill out of bo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x60(%rdi), %rsi
movq 0x68(%rdi), %rax
movl 0x98(%rsp), %ecx
movq 0x78(%rax), %rax
movq (%rax,%rcx,8), %rdx
movq %rsp, %r15
movq %r15, %rdi
callq 0x4dfbe
movq %r14, %rdi
callq 0xbb040
movq %rax, %r12
... | /wapm-packages[P]wabt/src/interp/interp.cc |
wabt::interp::Thread::DoSimdSwizzle() | RunResult Thread::DoSimdSwizzle() {
using S = u8x16;
auto rhs = Pop<S>();
auto lhs = Pop<S>();
S result;
for (u8 i = 0; i < S::lanes; ++i) {
result[i] = rhs[i] < S::lanes ? lhs[rhs[i]] : 0;
}
Push(result);
return RunResult::Ok;
} | pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
callq 0xbb040
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq %rbx, %rdi
callq 0xbb040
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
xorl %eax, %eax
movzbl 0x20(%rsp,%rax), %ecx
cmpq $0xf, %rcx
ja 0xbbe4c
movb 0x10(%rsp,%rcx), %cl
jmp 0xbbe4e
xorl %ecx, %ecx
movb %cl, (%rsp,%r... | /wapm-packages[P]wabt/src/interp/interp.cc |
wabt::interp::Thread::TraceSource::GetLocalType(unsigned int) | ValueType Thread::TraceSource::GetLocalType(Index stack_slot) {
const Frame& frame = thread_->frames_.back();
DefinedFunc::Ptr func{thread_->store_, frame.func};
// When a function is called, the arguments are first pushed on the stack by
// the caller, then the new call frame is pushed (which caches the curren... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %r14
movq 0x8(%rdi), %rax
movq 0x8(%rax), %r15
movq 0x60(%rax), %rsi
movq -0x28(%r15), %rdx
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x4b5d2
movq 0x8(%r14), %rax
movq 0x20(%rax), %rcx
subq 0x18(%rax), %rcx
shrq $0x4, %rcx
movq (%rbx), ... | /wapm-packages[P]wabt/src/interp/interp.cc |
unsigned long wabt::interp::FreeList<wabt::interp::Object*>::New<wabt::interp::Object*>(wabt::interp::Object*&&) | auto FreeList<T>::New(Args&&... args) -> Index {
if (free_head_ == 0) {
list_.push_back(T(std::forward<Args>(args)...));
return list_.size() - 1;
}
Index index = free_head_ - 1;
assert(!IsUsed(index));
assert(free_items_ > 0);
free_head_ = reinterpret_cast<uintptr_t>(list_[index]) >> ptrFreeShift... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0xbc667
movq (%rbx), %rcx
movq -0x8(%rcx,%rax,8), %rdi
testb $0x1, %dil
je 0xbc68e
movq 0x20(%rbx), %rdx
testq %rdx, %rdx
je 0xbc6ad
shrq %rdi
movq %rdi, 0x18(%rbx)
movq (%rsi), %rsi
movq %rsi, -0x8(%rcx,%rax,8)
decq %rax
decq %rdx
mo... | /wapm-packages[P]wabt/include/wabt/interp/interp-inl.h |
wabt::(anonymous namespace)::BinaryReaderIR::OnDataSymbol(unsigned int, unsigned int, std::basic_string_view<char, std::char_traits<char>>, unsigned int, unsigned int, unsigned int) | Result BinaryReaderIR::OnDataSymbol(Index index,
uint32_t flags,
std::string_view name,
Index segment,
uint32_t offset,
uint32_t size) {
i... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
xorl %r15d, %r15d
testq %rcx, %rcx
je 0xd067f
andl $0x10, %edx
orl 0x80(%rsp), %edx
jne 0xd067f
movl %r9d, %ebx
movq %rdi, %r14
movl %r9d, %eax
movq 0x18(%rdi), %r12
movq 0x148(%r12), %rdx
movq 0x150(%r12), %rsi
subq %rdx, %rsi
sarq $0x3, %rsi
cmpq... | /wapm-packages[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 0xd0792
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 0xd0779
movq (%rdx,%rax,8), %r12
cmp... | /wapm-packages[P]wabt/src/binary-reader-ir.cc |
wabt::(anonymous namespace)::BinaryReaderIR::OnTagType(unsigned int, unsigned int) | Result BinaryReaderIR::OnTagType(Index index, Index sig_index) {
auto field = std::make_unique<TagModuleField>(GetLocation());
Tag& tag = field->tag;
SetFuncDeclaration(&tag.decl, Var(sig_index, GetLocation()));
module_->AppendField(std::move(field));
return Result::Ok;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movq 0x40(%rdi), %r15
movq %r15, %rdi
callq 0x2d390
movq %rax, %r12
movq 0x8(%rbx), %rax
movq 0x10(%rax), %r13
movl $0x150, %edi # imm = 0x150
callq 0x2d130
movq %rax, %r14
xorps %xmm0, %xmm0
mo... | /wapm-packages[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 0xd0a5b
movq %r13, (%rax)
leaq 0x8(%rax), %rdi
xorps %xmm0, %... | /wapm-packages[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 0xd2fb6
movl $0x68, %edi
callq 0x2d130
movups 0x... | /wapm-packages[P]wabt/src/binary-reader-ir.cc |
wabt::(anonymous namespace)::BinaryReaderIR::SetFuncDeclaration(wabt::FuncDeclaration*, wabt::Var) | void BinaryReaderIR::SetFuncDeclaration(FuncDeclaration* decl, Var var) {
decl->has_func_type = true;
decl->type_var = var;
if (auto* func_type = module_->GetFuncType(var)) {
decl->sig = func_type->sig;
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movb $0x1, (%rsi)
leaq 0x8(%rsi), %rdi
movq %rdx, %rsi
callq 0xda152
movq 0x18(%r15), %rdi
movq %r14, %rsi
callq 0xd91a0
testq %rax, %rax
je 0xd0e06
movq %rax, %r14
leaq 0x50(%rax), %rsi
leaq 0x50(%rbx), %rdi
callq 0xa3a8c
leaq 0x68(%rbx),... | /wapm-packages[P]wabt/src/binary-reader-ir.cc |
wabt::(anonymous namespace)::BinaryReaderIR::PushLabel(wabt::LabelType, wabt::intrusive_list<wabt::Expr>*, wabt::Expr*) | void BinaryReaderIR::PushLabel(LabelType label_type,
ExprList* first,
Expr* context) {
label_stack_.emplace_back(label_type, first, context);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq 0x30(%rdi), %r15
cmpq 0x38(%rdi), %r15
je 0xd0e41
movl %ebp, (%r15)
movq %rdx, 0x8(%r15)
movq %rcx, 0x10(%r15)
addq $0x18, %r15
movq %r15, 0x30(%rbx)
jmp 0xd0f3f
movq 0x28(%rbx), %rdi
movq %r15, %rax
... | /wapm-packages[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 0xd11dd
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 0x2d390
movq %rax, ... | /wapm-packages[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 0xd1261
leaq (%r12,%rax), %r15
addq $-0x18, %r15
jmp 0xd1289
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAA... | /wapm-packages[P]wabt/src/binary-reader-ir.cc |
wabt::(anonymous namespace)::MakeDollarName[abi:cxx11](std::basic_string_view<char, std::char_traits<char>>) | static std::string MakeDollarName(std::string_view name) {
return std::string("$") + std::string(name);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x38(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x22215(%rip), %rsi # 0xf3689
leaq 0x2220f(%rip), %rdx # 0xf368a
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x4e296
leaq 0x18(%rsp... | /wapm-packages[P]wabt/src/binary-reader-ir.cc |
wabt::(anonymous namespace)::BinaryReaderIR::GetUniqueName(wabt::BindingHash*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string BinaryReaderIR::GetUniqueName(BindingHash* bindings,
const std::string& orig_name) {
int counter = 1;
std::string unique_name = orig_name;
while (bindings->count(unique_name) != 0) {
unique_name = orig_name + "." + std::to_string(counter++);
}
return u... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
callq 0x4115e
movq %r15, 0x60(%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0xd2d0e
testq %rax, ... | /wapm-packages[P]wabt/src/binary-reader-ir.cc |
wabt::LoadStoreExpr<(wabt::ExprType)48>::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 0xda134
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r15)
leaq 0x75db3(%rip), %rax # 0x148738
movq %rax, (%r... | /wapm-packages[P]wabt/include/wabt/ir.h |
wabt::BinaryReaderLogging::WriteIndent() | void BinaryReaderLogging::WriteIndent() {
static char s_indent[] =
" "
" ";
static const size_t s_indent_len = sizeof(s_indent) - 1;
size_t i = indent_;
while (... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq 0x20(%rdi), %r15
cmpq $0x8f, %r15
jb 0xd331a
leaq 0x1044cc(%rip), %r14 # 0x1d77c0
movq 0x10(%rbx), %rdi
movl $0x8e, %edx
movq %r14, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x8f4ca
addq $-0x8e, %r15
cmpq $0x8e, %r15
ja 0xd32f4
testq %r15, %r15
je 0xd333d
movq... | /wapm-packages[P]wabt/src/binary-reader-logging.cc |
wabt::BinaryReaderLogging::OnFuncType(unsigned int, unsigned int, wabt::Type*, unsigned int, wabt::Type*) | Result BinaryReaderLogging::OnFuncType(Index index,
Index param_count,
Type* param_types,
Index result_count,
Type* result_types) {
LOGF("OnFuncType(index: %" PRI... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movl %r8d, %ebp
movq %rcx, %r14
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %r13
callq 0xd32d8
movq 0x10(%r13), %rdi
leaq 0x30b10(%rip), %rsi # 0x1040ad
movl %r12d, %edx
xorl %eax, %eax
callq 0x8f556
movq %r13, %rdi
movl %r... | /wapm-packages[P]wabt/src/binary-reader-logging.cc |
combine_chr(double*, int, int, int*, double**) | void combine_chr(double* p_value_g, int m, int num_chr, int* m_chr, double** NM)
{
double** M;
M = new double* [num_chr+1];
for(int q=0; q<=num_chr; q++)
{
M[q] = new double [m+1];
for(int k=0; k<=m; k++)
M[q][k] = -1;
}
for(int q=1; q<=num_chr; q++)
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %r13
movq %rcx, 0x10(%rsp)
movl %edx, %r14d
movq %rsi, 0x18(%rsp)
movq %rdi, 0x48(%rsp)
leal 0x1(%r14), %eax
movq %rax, 0x28(%rsp)
leaq (,%rax,8), %rdi
cmpl $-0x1, %edx
movq $-0x1, %rbx
cmovlq %rbx, %rdi
callq 0x4030
movq %rax,... | /shahab-sarmashghi[P]ISTAT/src/main_chr.cpp |
logsum2(double, double) | double logsum2(double a, double b)
{
if(a==1000)
return b;
else if(b==1000)
return a;
else if(a>b)
return a + log(1 + exp(b-a));
else
return b + log(1 + exp(a-b));
} | ucomisd 0x155b(%rip), %xmm0 # 0x9420
jne 0x7ec9
jnp 0x7f2d
ucomisd 0x154f(%rip), %xmm1 # 0x9420
jne 0x7edb
jp 0x7edb
movapd %xmm0, %xmm1
jmp 0x7f2d
pushq %rax
movapd %xmm0, %xmm2
subsd %xmm1, %xmm2
movapd %xmm1, %xmm3
subsd %xmm0, %xmm3
movapd %xmm0, %xmm4
movapd %xmm1, %xmm0
cmpltsd %xmm4, %xmm0
andpd %xmm0, %... | /shahab-sarmashghi[P]ISTAT/src/lib/func.cpp |
lognchoosek(int, int) | double lognchoosek(int nn, int k)
{
double s=0;
for (int i=1; i<=k; i++) s = s + log(nn-k+i)-log(i);
return s;
} | testl %esi, %esi
jle 0x7fbc
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebx
movl %edi, %r14d
negl %ebx
incl %r14d
xorpd %xmm1, %xmm1
movsd 0x10b9(%rip), %xmm0 # 0x9010
movsd %xmm0, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
leal (%r14,%rbx), %eax
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
callq 0x4160
addsd 0x8(%rsp), %... | /shahab-sarmashghi[P]ISTAT/src/lib/func.cpp |
first_geq(unsigned int*, int, int) | int first_geq(unsigned int* I_start, int m, int h)
{
int L = 0, R = m;
int i;
while(L<=R)
{
i = (L+R) / 2;
if(I_start[i]<h)
L = i + 1;
else if(I_start[i]>h)
R = i - 1;
else
return i;
}
return L;
} | xorl %eax, %eax
testl %esi, %esi
js 0x7fe0
leal (%rsi,%rax), %ecx
shrl %ecx
cmpl %edx, (%rdi,%rcx,4)
jae 0x7fd6
incl %ecx
movl %ecx, %eax
jmp 0x7fdc
jbe 0x7fe1
decl %ecx
movl %ecx, %esi
cmpl %esi, %eax
jle 0x7fc6
retq
movl %ecx, %eax
retq
| /shahab-sarmashghi[P]ISTAT/src/lib/func.cpp |
first_g(unsigned int*, int, int) | int first_g(unsigned int* I_end, int m, int h)
{
int L = 0, R = m;
int i;
while(L<=R)
{
i = (L+R) / 2;
if(I_end[i]<h)
L = i + 1;
else if(I_end[i]>h)
R = i - 1;
else
return i+1;
}
return L;
} | xorl %eax, %eax
testl %esi, %esi
js 0x8004
leal (%rsi,%rax), %ecx
shrl %ecx
cmpl %edx, (%rdi,%rcx,4)
jae 0x7ffa
incl %ecx
movl %ecx, %eax
jmp 0x8000
jbe 0x8005
decl %ecx
movl %ecx, %esi
cmpl %esi, %eax
jle 0x7fea
retq
incl %ecx
movl %ecx, %eax
retq
| /shahab-sarmashghi[P]ISTAT/src/lib/func.cpp |
c(int, int, int, unsigned int*, unsigned int*) | int first_geq(unsigned int* I_start, int m, int h)
{
int L = 0, R = m;
int i;
while(L<=R)
{
i = (L+R) / 2;
if(I_start[i]<h)
L = i + 1;
else if(I_start[i]>h)
R = i - 1;
else
return i;
}
return L;
} | testl %edx, %edx
js 0x80c8
xorl %eax, %eax
movl %edx, %r9d
leal (%rax,%r9), %r10d
shrl %r10d
cmpl %esi, (%rcx,%r10,4)
jae 0x802c
incl %r10d
movl %r10d, %eax
jmp 0x8034
jbe 0x803b
decl %r10d
movl %r10d, %r9d
cmpl %r9d, %eax
jle 0x8017
jmp 0x803e
movl %r10d, %eax
movl %esi, %r9d
subl %edi, %r9d
xorl %edi, %edi
movl %edx,... | /shahab-sarmashghi[P]ISTAT/src/lib/func.cpp |
Indicator(int, unsigned int, int, unsigned int*, unsigned int*) | int first_geq(unsigned int* I_start, int m, int h)
{
int L = 0, R = m;
int i;
while(L<=R)
{
i = (L+R) / 2;
if(I_start[i]<h)
L = i + 1;
else if(I_start[i]>h)
R = i - 1;
else
return i;
}
return L;
} | testl %edx, %edx
js 0x80f8
xorl %r9d, %r9d
movl %edx, %eax
leal (%r9,%rax), %r10d
shrl %r10d
cmpl %esi, (%rcx,%r10,4)
jae 0x80e9
incl %r10d
movl %r10d, %r9d
jmp 0x80f1
jbe 0x80fb
decl %r10d
movl %r10d, %eax
cmpl %eax, %r9d
jle 0x80d4
jmp 0x80fe
xorl %eax, %eax
retq
movl %r10d, %r9d
movl %esi, %r10d
subl %edi, %r10d
xor... | /shahab-sarmashghi[P]ISTAT/src/lib/func.cpp |
variance(int*, int) | double variance(int* I_l, int n_int)
{
double l_mean = double(sum(I_l,n_int)) / n_int;
double l_var = 0;
for(int i=1; i<=n_int; i++)
{
l_var += pow(I_l[i]-l_mean, 2);
}
l_var /= n_int-1;
return l_var;
} | xorpd %xmm0, %xmm0
testl %esi, %esi
jle 0x82b6
leal 0x1(%rsi), %eax
xorl %ecx, %ecx
movl $0x1, %edx
addl (%rdi,%rdx,4), %ecx
incq %rdx
cmpq %rdx, %rax
jne 0x8273
testl %esi, %esi
jle 0x82b6
cvtsi2sd %ecx, %xmm1
xorps %xmm0, %xmm0
cvtsi2sd %esi, %xmm0
divsd %xmm0, %xmm1
xorpd %xmm0, %xmm0
movl $0x1, %ecx
xorps %xmm2, %x... | /shahab-sarmashghi[P]ISTAT/src/lib/func.cpp |
write2file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double*, int) | void write2file(string output, double* p_value_dp, int m)
{
ofstream myfile (output);
if (myfile.is_open()) {
myfile << "k" << "\t" << "DP" << endl;
for(int k=0; k<=m; k++){
myfile << k << "\t" << p_value_dp[k] << endl;
}
myfile.close();
}
else cout << "Un... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %rsi
leaq 0x8(%rsp), %rdi
movl $0x10, %edx
callq 0x4340
leaq 0x78(%rsp), %rdi
callq 0x4080
testb %al, %al
je 0x83ed
leaq 0x1123(%rip), %rsi # 0x9428
leaq 0x8(%rsp)... | /shahab-sarmashghi[P]ISTAT/src/lib/func.cpp |
Curl_altsvc_cleanup | void Curl_altsvc_cleanup(struct altsvcinfo **altsvcp)
{
if(*altsvcp) {
struct Curl_llist_node *e;
struct Curl_llist_node *n;
struct altsvcinfo *altsvc = *altsvcp;
for(e = Curl_llist_head(&altsvc->list); e; e = n) {
struct altsvc *as = Curl_node_elem(e);
n = Curl_node_next(e);
altsvc_... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x11cc4
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x61a90
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x11c96
movq -0x10(%rbp), %rdi
callq 0... | /AraHaan[P]curl/lib/altsvc.c |
Curl_altsvc_save | CURLcode Curl_altsvc_save(struct Curl_easy *data,
struct altsvcinfo *altsvc, const char *file)
{
CURLcode result = CURLE_OK;
FILE *out;
char *tempstore = NULL;
if(!altsvc)
/* no cache activated */
return CURLE_OK;
/* if not new name is given, use the one we stored from the ... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq $0x0, -0x38(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x11d56
movl $0x0, -0x4(%rbp)
jmp 0x11e85
cmpq $0x0, -0x20(%rbp)
jne 0x11d72
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0x11d72
movq ... | /AraHaan[P]curl/lib/altsvc.c |
altsvc_out | static CURLcode altsvc_out(struct altsvc *as, FILE *fp)
{
struct tm stamp;
const char *dst6_pre = "";
const char *dst6_post = "";
const char *src6_pre = "";
const char *src6_post = "";
CURLcode result = Curl_gmtime(as->expires, &stamp);
if(result)
return result;
#ifdef USE_IPV6
else {
char ipv6_... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rdi, -0x38(%rbp)
movq %rsi, -0x40(%rbp)
leaq 0xbd62b(%rip), %rax # 0xcf4de
movq %rax, -0x80(%rbp)
leaq 0xbd620(%rip), %rax # 0xcf4de
movq %rax, -0x88(%rbp)
leaq 0xbd612(%rip), %rax ... | /AraHaan[P]curl/lib/altsvc.c |
altsvc_createid | static struct altsvc *altsvc_createid(const char *srchost,
size_t hlen,
const char *dsthost,
size_t dlen, /* dsthost length */
enum alpnid srcalpnid,
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movl %r9d, -0x30(%rbp)
movl $0x1, %edi
movl $0x50, %esi
leaq 0xda9c7(%rip), %rax # 0xed2f0
callq *(%rax)
movq %ra... | /AraHaan[P]curl/lib/altsvc.c |
hostcompare | static bool hostcompare(const char *host, const char *check)
{
size_t hlen = strlen(host);
size_t clen = strlen(check);
if(hlen && (host[hlen - 1] == '.'))
hlen--;
if(hlen != clen)
/* they cannot match if they have different lengths */
return FALSE;
return strncasecompare(host, check, hlen);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x10540
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10540
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x12be2
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%... | /AraHaan[P]curl/lib/altsvc.c |
Curl_async_shutdown | void Curl_async_shutdown(struct Curl_easy *data)
{
#ifdef CURLRES_ARES
Curl_async_ares_shutdown(data);
#endif
#ifdef CURLRES_THREADED
Curl_async_thrdd_shutdown(data);
#endif
#ifndef CURL_DISABLE_DOH
Curl_doh_cleanup(data);
#endif
Curl_safefree(data->state.async.hostname);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x13020
movq -0x8(%rbp), %rdi
callq 0x329f0
leaq 0xda373(%rip), %rax # 0xed2d8
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0xd48(%rcx), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movq $0x0, 0xd48(%rax)
addq $0x10, %rsp
popq %... | /AraHaan[P]curl/lib/asyn-base.c |
Curl_async_thrdd_shutdown | void Curl_async_thrdd_shutdown(struct Curl_easy *data)
{
struct async_thrdd_ctx *thrdd = &data->state.async.thrdd;
/* If we are still resolving, we must wait for the threads to fully clean up,
unfortunately. Otherwise, we can simply cancel to clean up any resolver
data. */
if(thrdd->addr && (thrdd->add... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xc00, %rax # imm = 0xC00
addq $0x130, %rax # imm = 0x130
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x13085
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, (%rax)
je 0x13085
m... | /AraHaan[P]curl/lib/asyn-thrdd.c |
getaddrinfo_thread | CURL_STDCALL getaddrinfo_thread(void *arg)
{
struct async_thrdd_addr_ctx *addr_ctx = arg;
char service[12];
int rc;
bool all_gone;
msnprintf(service, sizeof(service), "%d", addr_ctx->port);
rc = Curl_getaddrinfo_ex(addr_ctx->hostname, service,
&addr_ctx->hints, &addr_ctx->res);
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x1c(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x94(%rax), %ecx
movl $0xc, %esi
leaq 0xbd876(%rip), %rdx # 0xd1734
movb $0x0, %al
callq 0x106d0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x1c(%r... | /AraHaan[P]curl/lib/asyn-thrdd.c |
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.