name string | code string | asm string | file string |
|---|---|---|---|
ImGui::IsPopupOpen(unsigned int, int) | bool ImGui::IsPopupOpen(ImGuiID id, ImGuiPopupFlags popup_flags)
{
ImGuiContext& g = *GImGui;
if (popup_flags & ImGuiPopupFlags_AnyPopupId)
{
// Return true if any popup is open at the current BeginPopup() level of the popup stack
// This may be used to e.g. test for another popups already o... | movq 0xea5dd(%rip), %rdx # 0x1d2030
movl 0x4830(%rdx), %ecx
testb %sil, %sil
js 0xe7a81
btl $0x8, %esi
jb 0xe7a8f
movslq 0x4840(%rdx), %rax
cmpl %eax, %ecx
jle 0xe7ace
movq 0x4838(%rdx), %rcx
imulq $0x38, %rax, %rax
cmpl %edi, (%rcx,%rax)
sete %al
retq
btl $0x8, %esi
jb 0xe7ac8
cmpl 0x4840(%rdx), %ecx
jmp 0xe7aca
t... | /embree[P]embree/tutorials/common/imgui/imgui.cpp |
ImGui::PushItemFlag(int, bool) | void ImGui::PushItemFlag(ImGuiItemFlags option, bool enabled)
{
ImGuiContext& g = *GImGui;
ImGuiItemFlags item_flags = g.CurrentItemFlags;
IM_ASSERT(item_flags == g.ItemFlagsStack.back());
if (enabled)
item_flags |= option;
else
item_flags &= ~option;
g.CurrentItemFlags = item_fl... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0xddb6c(%rip), %r14 # 0x1d2030
movl %edi, %eax
notl %eax
movl 0x4708(%r14), %ebp
andl %ebp, %eax
orl %edi, %ebp
testl %esi, %esi
cmovel %eax, %ebp
movl 0x4810(%r14), %r15d
movl %ebp, 0x4708(%r14)
movl 0x4814(%r14), %eax
cmpl %eax, %r15d
jne 0xf4596
incl %r... | /embree[P]embree/tutorials/common/imgui/imgui.cpp |
ImGui::IsWindowHovered(int) | bool ImGui::IsWindowHovered(ImGuiHoveredFlags flags)
{
IM_ASSERT((flags & (ImGuiHoveredFlags_AllowWhenOverlapped | ImGuiHoveredFlags_AllowWhenDisabled)) == 0); // Flags not supported by this function
ImGuiContext& g = *GImGui;
ImGuiWindow* ref_window = g.HoveredWindow;
ImGuiWindow* cur_window = g.Curr... | movq 0xdd6a5(%rip), %rdx # 0x1d2030
movq 0x3ea8(%rdx), %rcx
testq %rcx, %rcx
je 0xf4ac4
testb $0x4, %dil
jne 0xf4a3e
movq 0x3ea0(%rdx), %rsi
testb $0x2, %dil
sete %al
testq %rsi, %rsi
sete %r8b
orb %al, %r8b
je 0xf49c4
movq %rsi, %rax
jmp 0xf49e0
movq 0x358(%rsi), %rax
testb $0x8, %dil
jne 0xf49d8
movq 0x360(%rax),... | /embree[P]embree/tutorials/common/imgui/imgui.cpp |
ImGui::SetItemDefaultFocus() | void ImGui::SetItemDefaultFocus()
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
if (!window->Appearing)
return;
if (g.NavWindow != window->RootWindowForNav || (!g.NavInitRequest && g.NavInitResultId == 0) || g.NavLayer != window->DC.NavLayerCurrent)
return;
g.N... | movq 0xdcebe(%rip), %rsi # 0x1d2030
movq 0x3ea0(%rsi), %rdi
cmpb $0x1, 0x9c(%rdi)
jne 0xf5192
movq 0x4868(%rsi), %rax
cmpq 0x370(%rdi), %rax
je 0xf5193
retq
cmpb $0x0, 0x48ad(%rsi)
jne 0xf51a5
cmpl $0x0, 0x48b0(%rsi)
je 0xf5192
movl 0x48a4(%rsi), %eax
cmpl 0x138(%rdi), %eax
jne 0xf5192
movb $0x0, 0x48ad(%rsi)
movl ... | /embree[P]embree/tutorials/common/imgui/imgui.cpp |
ImGui::PushID(char const*, char const*) | void ImGui::PushID(const char* str_id_begin, const char* str_id_end)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
ImGuiID id = window->GetID(str_id_begin, str_id_end);
window->IDStack.push_back(id);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %rsi
movq 0xdc9ce(%rip), %rax # 0x1d2030
movq 0x3ea0(%rax), %rbx
movq %rbx, %rdi
callq 0xe56c6
movl %eax, %ebp
movl 0xd0(%rbx), %r15d
movl 0xd4(%rbx), %eax
cmpl %eax, %r15d
jne 0xf5733
incl %r15d
testl %eax, %eax
je 0xf569d
movl %eax,... | /embree[P]embree/tutorials/common/imgui/imgui.cpp |
ImGui::GetKeyName(ImGuiKey) | inline bool IsLegacyKey(ImGuiKey key) { return key >= ImGuiKey_LegacyNativeKey_BEGIN && key < ImGuiKey_LegacyNativeKey_END; } | cmpl $0x1ff, %edi # imm = 0x1FF
ja 0xf5bea
movq 0xdc457(%rip), %rax # 0x1d2030
movl %edi, %ecx
movl 0x100(%rax,%rcx,4), %eax
cmpl $-0x1, %eax
cmovnel %eax, %edi
je 0xf5c49
testl %edi, %edi
je 0xf5c39
testl $0xf000, %edi # imm = 0xF000
je 0xf5c1a
leal -0x1000(%rdi), %eax
roll $0x14, %eax
cmpl $0... | /embree[P]embree/tutorials/common/imgui/imgui_internal.h |
ImGui::IsKeyReleased(ImGuiKey, unsigned int) | bool ImGui::IsKeyReleased(ImGuiKey key, ImGuiID owner_id)
{
const ImGuiKeyData* key_data = GetKeyData(key);
if (key_data->DownDurationPrev < 0.0f || key_data->Down)
return false;
if (!TestKeyOwner(key, owner_id))
return false;
return true;
} | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
callq 0xdfb10
xorps %xmm0, %xmm0
ucomiss 0x8(%rax), %xmm0
ja 0xf632d
cmpb $0x0, (%rax)
je 0xf6336
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl %ebp, %edi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xf6197
| /embree[P]embree/tutorials/common/imgui/imgui.cpp |
ImGui::BeginGroup() | void ImGui::BeginGroup()
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
g.GroupStack.resize(g.GroupStack.Size + 1);
ImGuiGroupData& group_data = g.GroupStack.back();
group_data.WindowID = window->ID;
group_data.BackupCursorPos = window->DC.CursorPos;
group_data.BackupCu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0xda803(%rip), %r14 # 0x1d2030
movq 0x3ea0(%r14), %r15
movslq 0x4820(%r14), %rcx
movq %rcx, %r12
incq %r12
movl 0x4824(%r14), %eax
cmpl %ecx, %eax
jg 0xf78f8
testl %eax, %eax
je 0xf7861
movl %eax, %ebp
shrl $0x1f, %ebp
addl %eax, %ebp
sarl %ebp
addl %eax, ... | /embree[P]embree/tutorials/common/imgui/imgui.cpp |
ImGui::BeginPopupContextVoid(char const*, int) | bool ImGui::BeginPopupContextVoid(const char* str_id, ImGuiPopupFlags popup_flags)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
if (!str_id)
str_id = "void_context";
ImGuiID id = window->GetID(str_id);
int mouse_button = (popup_flags & ImGuiPopupFlags_MouseButtonMask_)... | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movq 0xd954c(%rip), %rax # 0x1d2030
movq 0x3ea0(%rax), %rax
testq %rdi, %rdi
leaq 0x65843(%rip), %rsi # 0x15e338
cmovneq %rdi, %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0xe56c6
movl %eax, %ebp
movl %ebx, %edi
andl $0x1f, %edi
movq 0xd951f(%rip), %rax # 0x1d2... | /embree[P]embree/tutorials/common/imgui/imgui.cpp |
ImGui::NavMoveRequestForward(int, int, int, int) | void ImGui::NavMoveRequestForward(ImGuiDir move_dir, ImGuiDir clip_dir, ImGuiNavMoveFlags move_flags, ImGuiScrollFlags scroll_flags)
{
ImGuiContext& g = *GImGui;
IM_ASSERT(g.NavMoveForwardToNextFrame == false);
NavMoveRequestCancel();
g.NavMoveForwardToNextFrame = true;
g.NavMoveDir = move_dir;
... | movq 0xd8ffc(%rip), %rax # 0x1d2030
movw $0x100, 0x48c5(%rax) # imm = 0x100
movb $0x0, 0x48c4(%rax)
movb 0x48ad(%rax), %r8b
movb %r8b, 0x48ac(%rax)
movl %edi, 0x48d4(%rax)
movl %esi, 0x48dc(%rax)
orl $0x80, %edx
movl %edx, 0x48c8(%rax)
movl %ecx, 0x48cc(%rax)
retq
| /embree[P]embree/tutorials/common/imgui/imgui.cpp |
ImGui::NavInitRequestApplyResult() | void ImGui::NavInitRequestApplyResult()
{
// In very rare cases g.NavWindow may be null (e.g. clearing focus after requesting an init request, which does happen when releasing Alt while clicking on void)
ImGuiContext& g = *GImGui;
if (!g.NavWindow)
return;
// Apply result from previous navigati... | pushq %rbx
movq 0xd8ee0(%rip), %rbx # 0x1d2030
movq 0x4868(%rbx), %rax
testq %rax, %rax
je 0xf91fe
testb $0x8, 0x5c2c(%rbx)
je 0xf9186
movl 0x48a4(%rbx), %edx
movl 0x48b0(%rbx), %esi
movq (%rax), %rcx
leaq 0x65236(%rip), %rdi # 0x15e3b5
xorl %eax, %eax
callq 0xe2da5
movl 0x48a4(%rbx), %eax
movl 0x48b0(%rbx), %e... | /embree[P]embree/tutorials/common/imgui/imgui.cpp |
ImGui::ClearIniSettings() | void ImGui::ClearIniSettings()
{
ImGuiContext& g = *GImGui;
g.SettingsIniData.clear();
for (int handler_n = 0; handler_n < g.SettingsHandlers.Size; handler_n++)
if (g.SettingsHandlers[handler_n].ClearAllFn)
g.SettingsHandlers[handler_n].ClearAllFn(&g, &g.SettingsHandlers[handler_n]);
} | pushq %r15
pushq %r14
pushq %rbx
movq 0xd793a(%rip), %rbx # 0x1d2030
leaq 0x5b58(%rbx), %rdi
callq 0x102178
cmpl $0x0, 0x5b68(%rbx)
jle 0xfa73d
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x5b70(%rbx), %rsi
movq 0x10(%rsi,%r14), %rax
testq %rax, %rax
je 0xfa72a
addq %r14, %rsi
movq %rbx, %rdi
callq *%rax
incq %r15
mov... | /embree[P]embree/tutorials/common/imgui/imgui.cpp |
ImGui::DebugTextEncoding(char const*) | void ImGui::DebugTextEncoding(const char* str)
{
Text("Text: \"%s\"", str);
if (!BeginTable("list", 4, ImGuiTableFlags_Borders | ImGuiTableFlags_RowBg | ImGuiTableFlags_SizingFixedFit))
return;
TableSetupColumn("Offset");
TableSetupColumn("UTF-8");
TableSetupColumn("Glyph");
TableSetupCo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x63355(%rip), %rdi # 0x15e4cb
movq %rbx, %rsi
xorl %eax, %eax
callq 0x115b13
leaq 0x10(%rsp), %rcx
movq $0x0, (%rcx)
leaq 0x8b4de(%rip), %rdi # 0x186671
xorps %xmm0, %xmm0
movl $0x4, %esi
movl $0x27c0, %edx ... | /embree[P]embree/tutorials/common/imgui/imgui.cpp |
ImGuiTextBuffer::clear() | void clear() { Buf.clear(); } | pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x1021b3
movq $0x0, (%rbx)
movq 0xcfe9d(%rip), %rax # 0x1d2030
testq %rax, %rax
je 0x10219e
decl 0xf4(%rax)
movq 0xcfe9b(%rip), %rsi # 0x1d2040
callq *0xceeed(%rip) # 0x1d1098
movq $0x0, 0x8(%rbx)
popq %rbx
retq
nop
| /embree[P]embree/tutorials/common/imgui/imgui.h |
ImGuiTextBuffer::reserve(int) | inline void reserve(int new_capacity) { if (new_capacity <= Capacity) return; T* new_data = (T*)IM_ALLOC((size_t)new_capacity * sizeof(T)); if (Data) { memcpy(new_data, Data, (size_t)Size * sizeof(T)); IM_FREE(Data); } Data = new_data; Capacity = new_capacity; } | cmpl %esi, 0x4(%rdi)
jge 0x10329d
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movslq %esi, %rdi
movq 0xcedf7(%rip), %rax # 0x1d2030
testq %rax, %rax
je 0x103244
incl 0xf4(%rax)
movq 0xcedf5(%rip), %rsi # 0x1d2040
callq *0xcde3f(%rip) # 0x1d1090
movq %rax, %r15
movq 0x8(%r14), %rsi
... | /embree[P]embree/tutorials/common/imgui/imgui.h |
ImDrawListSharedData::SetCircleTessellationMaxError(float) | void ImDrawListSharedData::SetCircleTessellationMaxError(float max_error)
{
if (CircleSegmentMaxError == max_error)
return;
IM_ASSERT(max_error > 0.0f);
CircleSegmentMaxError = max_error;
for (int i = 0; i < IM_ARRAYSIZE(CircleSegmentCounts); i++)
{
const float radius = (float)i;
... | movss 0x18(%rdi), %xmm1
ucomiss %xmm0, %xmm1
jne 0x104503
jp 0x104503
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movss %xmm0, 0x18(%rdi)
xorl %r14d, %r14d
movl $0x200, %ebp # imm = 0x200
movl $0x4, %r15d
testq %r14, %r14
je 0x10457f
xorps %xmm0, %xmm0
cvtsi2ss %r14d, %xmm0
mo... | /embree[P]embree/tutorials/common/imgui/imgui_draw.cpp |
ImDrawList::AddCallback(void (*)(ImDrawList const*, ImDrawCmd const*), void*) | void ImDrawList::AddCallback(ImDrawCallback callback, void* callback_data)
{
IM_ASSERT_PARANOID(CmdBuffer.Size > 0);
ImDrawCmd* curr_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];
IM_ASSERT(curr_cmd->UserCallback == NULL);
if (curr_cmd->ElemCount != 0)
{
AddDrawCmd();
curr_cmd = &CmdBuff... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rdi), %rax
movslq (%rdi), %rcx
imulq $0x38, %rcx, %rcx
cmpl $0x0, -0x18(%rax,%rcx)
je 0x104c49
movq %r14, %rdi
callq 0x104b00
movslq (%r14), %rax
imulq $0x38, %rax, %rax
addq 0x8(%r14), %rax
jmp 0x104c4c
addq %rcx, %rax
movq %r15... | /embree[P]embree/tutorials/common/imgui/imgui_draw.cpp |
ImDrawList::_OnChangedClipRect() | void ImDrawList::_OnChangedClipRect()
{
// If current command is used with different settings we need to add a new command
IM_ASSERT_PARANOID(CmdBuffer.Size > 0);
ImDrawCmd* curr_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];
if (curr_cmd->ElemCount != 0 && memcmp(&curr_cmd->ClipRect, &_CmdHeader.ClipRect, ... | movq 0x8(%rdi), %rdx
movslq (%rdi), %rax
imulq $0x38, %rax, %rsi
leaq (%rdx,%rsi), %rcx
addq $-0x38, %rcx
movl 0x20(%rcx), %r8d
testl %r8d, %r8d
je 0x104d04
movdqu (%rcx), %xmm0
movdqu 0x88(%rdi), %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %r9d
cmpl $0xffff, %r9d # imm = 0xFFFF
jne 0x104b00
cmpl $0x2, %eax
jl... | /embree[P]embree/tutorials/common/imgui/imgui_draw.cpp |
ImDrawList::_OnChangedVtxOffset() | void ImDrawList::_OnChangedVtxOffset()
{
// We don't need to compare curr_cmd->VtxOffset != _CmdHeader.VtxOffset because we know it'll be different at the time we call this.
_VtxCurrentIdx = 0;
IM_ASSERT_PARANOID(CmdBuffer.Size > 0);
ImDrawCmd* curr_cmd = &CmdBuffer.Data[CmdBuffer.Size - 1];
//IM_AS... | movl $0x0, 0x34(%rdi)
movq 0x8(%rdi), %rax
movslq (%rdi), %rcx
imulq $0x38, %rcx, %rcx
cmpl $0x0, -0x18(%rax,%rcx)
jne 0x104b00
addq %rcx, %rax
movl 0xa0(%rdi), %ecx
movl %ecx, -0x20(%rax)
retq
| /embree[P]embree/tutorials/common/imgui/imgui_draw.cpp |
ImDrawList::PopTextureID() | inline void pop_back() { IM_ASSERT(Size > 0); Size--; } | movslq 0x68(%rdi), %rax
movl %eax, %ecx
decl %ecx
movl %ecx, 0x68(%rdi)
je 0x1050da
movq 0x70(%rdi), %rcx
movq -0x10(%rcx,%rax,8), %rax
jmp 0x1050dc
xorl %eax, %eax
movq %rax, 0x98(%rdi)
jmp 0x104d66
| /embree[P]embree/tutorials/common/imgui/imgui.h |
ImDrawList::_PathArcToN(ImVec2 const&, float, float, float, int) | void ImDrawList::_PathArcToN(const ImVec2& center, float radius, float a_min, float a_max, int num_segments)
{
if (radius < 0.5f)
{
_Path.push_back(center);
return;
}
// Note that we are adding a point at both a_min and a_max.
// If you are trying to draw a full closed circle you do... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movss %xmm2, 0x4(%rsp)
movss %xmm1, 0x8(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movss 0x4982e(%rip), %xmm1 # 0x150104
movaps %xmm0, 0x10(%rsp)
ucomiss %xmm0, %xmm1
movl 0x78(%rdi), %r12d
jbe 0x10690b
movl 0x7c(%rbx), %eax
cmpl %eax, %r1... | /embree[P]embree/tutorials/common/imgui/imgui_draw.cpp |
ImDrawList::PathBezierCubicCurveTo(ImVec2 const&, ImVec2 const&, ImVec2 const&, int) | void ImDrawList::PathBezierCubicCurveTo(const ImVec2& p2, const ImVec2& p3, const ImVec2& p4, int num_segments)
{
ImVec2 p1 = _Path.back();
if (num_segments == 0)
{
IM_ASSERT(_Data->CurveTessellationTol > 0.0f);
PathBezierCubicCurveToCasteljau(&_Path, p1.x, p1.y, p2.x, p2.y, p3.x, p3.y, p4.x... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r13
movq %rdx, %r12
movq %rdi, %rbx
movq 0x80(%rdi), %rax
movslq 0x78(%rdi), %rdi
movsd -0x8(%rax,%rdi,8), %xmm0
testl %r8d, %r8d
je 0x10739e
jle 0x1073e5
cvtsi2ss %r8d, %xmm1
movss 0x48f29(%rip), %xmm3 # 0x150100
movaps %... | /embree[P]embree/tutorials/common/imgui/imgui_draw.cpp |
ImDrawList::PathRect(ImVec2 const&, ImVec2 const&, float, int) | void ImDrawList::PathRect(const ImVec2& a, const ImVec2& b, float rounding, ImDrawFlags flags)
{
flags = FixRectCornerFlags(flags);
rounding = ImMin(rounding, ImFabs(b.x - a.x) * ( ((flags & ImDrawFlags_RoundCornersTop) == ImDrawFlags_RoundCornersTop) || ((flags & ImDrawFlags_RoundCornersBottom) == ImDrawFlag... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpl $-0x1, %ecx
je 0x107a3f
leal -0x1(%rcx), %eax
cmpl $0xe, %eax
ja 0x107a46
shll $0x4, %ecx
jmp 0x107a58
movl $0xf0, %ecx
jmp 0x107a58
movl %ecx, %eax
orl $0xf0, %eax
testl $0x1f0, %ecx ... | /embree[P]embree/tutorials/common/imgui/imgui_draw.cpp |
ImDrawList::AddRect(ImVec2 const&, ImVec2 const&, unsigned int, float, int, float) | void ImDrawList::AddRect(const ImVec2& p_min, const ImVec2& p_max, ImU32 col, float rounding, ImDrawFlags flags, float thickness)
{
if ((col & IM_COL32_A_MASK) == 0)
return;
if (Flags & ImDrawListFlags_AntiAliasedLines)
PathRect(p_min + ImVec2(0.50f, 0.50f), p_max - ImVec2(0.50f, 0.50f), roundin... | cmpl $0x1000000, %ecx # imm = 0x1000000
jb 0x1080a1
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movq %rdi, %rbx
movss %xmm1, 0x4(%rsp)
testb $0x1, 0x30(%rdi)
jne 0x108043
movsd (%rsi), %xmm1
addps 0x54d12(%rip), %xmm1 # 0x15cd40
leaq 0x10(%rsp), %rsi
movlps %xmm1, (%rsi)
movsd (%rdx), %xmm1
addps 0... | /embree[P]embree/tutorials/common/imgui/imgui_draw.cpp |
ImDrawList::AddQuad(ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, unsigned int, float) | void ImDrawList::AddQuad(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, const ImVec2& p4, ImU32 col, float thickness)
{
if ((col & IM_COL32_A_MASK) == 0)
return;
PathLineTo(p1);
PathLineTo(p2);
PathLineTo(p3);
PathLineTo(p4);
PathStroke(col, ImDrawFlags_Closed, thickness);
} | cmpl $0x1000000, %r9d # imm = 0x1000000
jb 0x10859f
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %ebp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movl 0x78(%rdi), %r15d
movl 0x7c(%rdi), %eax
cmpl %eax, %r15d
movss %xmm0, 0x4(%rsp)
jne 0x10837e
incl %r15d
testl... | /embree[P]embree/tutorials/common/imgui/imgui_draw.cpp |
ImDrawList::AddNgon(ImVec2 const&, float, unsigned int, int, float) | void ImDrawList::AddNgon(const ImVec2& center, float radius, ImU32 col, int num_segments, float thickness)
{
if ((col & IM_COL32_A_MASK) == 0 || num_segments <= 2)
return;
// Because we are filling a closed shape we remove 1 from the count of segments/points
const float a_max = (IM_PI * 2.0f) * ((f... | pushq %rbp
pushq %rbx
pushq %rax
movl %edx, %ebp
cmpl $0x1000000, %edx # imm = 0x1000000
setb %al
cmpl $0x3, %ecx
setl %dl
orb %al, %dl
jne 0x108e7b
movq %rdi, %rbx
movss %xmm1, 0x4(%rsp)
xorps %xmm1, %xmm1
cvtsi2ss %ecx, %xmm1
movss 0x4730c(%rip), %xmm2 # 0x15013c
addss %xmm1, %xmm2
mulss 0x4d418(%rip), %xmm... | /embree[P]embree/tutorials/common/imgui/imgui_draw.cpp |
ImDrawList::AddBezierCubic(ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, unsigned int, float, int) | void ImDrawList::AddBezierCubic(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, const ImVec2& p4, ImU32 col, float thickness, int num_segments)
{
if ((col & IM_COL32_A_MASK) == 0)
return;
PathLineTo(p1);
PathBezierCubicCurveTo(p2, p3, p4, num_segments);
PathStroke(col, 0, thickness);
} | cmpl $0x1000000, %r9d # imm = 0x1000000
jb 0x109002
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %ebp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movss %xmm0, 0x4(%rsp)
movl 0x50(%rsp), %r9d
movl 0x78(%rdi), %r14d
movl 0x7c(%rdi), %eax
cmpl %ea... | /embree[P]embree/tutorials/common/imgui/imgui_draw.cpp |
ImGui::ShadeVertsLinearUV(ImDrawList*, int, int, ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, bool) | void ImGui::ShadeVertsLinearUV(ImDrawList* draw_list, int vert_start_idx, int vert_end_idx, const ImVec2& a, const ImVec2& b, const ImVec2& uv_a, const ImVec2& uv_b, bool clamp)
{
const ImVec2 size = b - a;
const ImVec2 uv_size = uv_b - uv_a;
const ImVec2 scale = ImVec2(
size.x != 0.0f ? (uv_size.x ... | movq 0x8(%rsp), %rax
movsd (%r8), %xmm1
movsd (%rcx), %xmm0
subps %xmm0, %xmm1
movsd (%rax), %xmm4
movsd (%r9), %xmm3
movaps %xmm4, %xmm0
subps %xmm3, %xmm0
xorps %xmm2, %xmm2
cmpneqps %xmm1, %xmm2
divps %xmm1, %xmm0
andps %xmm2, %xmm0
movq 0x28(%rdi), %rdi
movslq %esi, %rax
leaq (%rax,%rax,4), %rax
leaq (%rdi,%rax,4),... | /embree[P]embree/tutorials/common/imgui/imgui_draw.cpp |
ImFontConfig::ImFontConfig() | ImFontConfig::ImFontConfig()
{
memset(this, 0, sizeof(*this));
FontDataOwnedByAtlas = true;
OversampleH = 3; // FIXME: 2 may be a better default?
OversampleV = 1;
GlyphMaxAdvanceX = FLT_MAX;
RasterizerMultiply = 1.0f;
EllipsisChar = (ImWchar)-1;
} | pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x24(%rdi)
movl $0x88, %edx
xorl %esi, %esi
callq 0x17600
movb $0x1, 0xc(%rbx)
movabsq $0x100000003, %rax # imm = 0x100000003
movq %rax, 0x18(%rbx)
movl $0x7f7fffff, 0x44(%rbx) # imm = 0x7F7FFFFF
movl $0x3f800000, 0x50(%rbx) # imm = 0x3F800000
movw $0xfff... | /embree[P]embree/tutorials/common/imgui/imgui_draw.cpp |
ImFontAtlas::ClearInputData() | void ImFontAtlas::ClearInputData()
{
IM_ASSERT(!Locked && "Cannot modify a locked ImFontAtlas between NewFrame() and EndFrame/Render()!");
for (int i = 0; i < ConfigData.Size; i++)
if (ConfigData[i].FontData && ConfigData[i].FontDataOwnedByAtlas)
{
IM_FREE(ConfigData[i].FontData);... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x68(%rdi)
jle 0x10a955
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x70(%rbx), %rax
movq (%rax,%r14), %rdi
testq %rdi, %rdi
je 0x10a942
cmpb $0x1, 0xc(%rax,%r14)
jne 0x10a942
callq 0xe0cc3
movq 0x70(%rbx), %rax
movq $0x0, (%rax,%r14)
incq %r15
movslq 0x68(%rbx),... | /embree[P]embree/tutorials/common/imgui/imgui_draw.cpp |
ImFont::BuildLookupTable() | void ImFont::BuildLookupTable()
{
int max_codepoint = 0;
for (int i = 0; i != Glyphs.Size; i++)
max_codepoint = ImMax(max_codepoint, (int)Glyphs[i].Codepoint);
// Build lookup table
IM_ASSERT(Glyphs.Size < 0xFFFF); // -1 is reserved
IndexAdvanceX.clear();
IndexLookup.clear();
DirtyL... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x28(%rdi), %ecx
testq %rcx, %rcx
je 0x1102f5
movq 0x30(%rbx), %rax
shlq $0x3, %rcx
leaq (%rcx,%rcx,4), %rcx
xorl %edx, %edx
xorl %ebp, %ebp
movl %ebp, %esi
movl (%rax,%rdx), %ebp
shrl $0x2, %ebp
cmpl %ebp, %esi
cmovgl %esi, %e... | /embree[P]embree/tutorials/common/imgui/imgui_draw.cpp |
ImFontAtlas::GetGlyphRangesChineseFull() | const ImWchar* ImFontAtlas::GetGlyphRangesChineseFull()
{
static const ImWchar ranges[] =
{
0x0020, 0x00FF, // Basic Latin + Latin Supplement
0x2000, 0x206F, // General Punctuation
0x3000, 0x30FF, // CJK Symbols and Punctuations, Hiragana, Katakana
0x31F0, 0x31FF, // Katakana Ph... | leaq 0x50731(%rip), %rax # 0x160e30
retq
| /embree[P]embree/tutorials/common/imgui/imgui_draw.cpp |
ImFontAtlas::GetGlyphRangesJapanese() | const ImWchar* ImFontAtlas::GetGlyphRangesJapanese()
{
// 2999 ideograms code points for Japanese
// - 2136 Joyo (meaning "for regular use" or "for common use") Kanji code points
// - 863 Jinmeiyo (meaning "for personal name") Kanji code points
// - Sourced from the character information database of th... | cmpw $0x0, 0xc408e(%rip) # 0x1d4800
jne 0x1107c4
movaps 0x531f5(%rip), %xmm0 # 0x163970
movaps %xmm0, 0xc407e(%rip) # 0x1d4800
movl $0xfffdfffd, 0xc4084(%rip) # imm = 0xFFFDFFFD
movl $0x4e00, %ecx # imm = 0x4E00
xorl %eax, %eax
leaq 0xc4066(%rip), %rdx # 0x1d4800
leaq 0x51a5f(%rip), %rsi # 0... | /embree[P]embree/tutorials/common/imgui/imgui_draw.cpp |
ImFont::FindGlyphNoFallback(unsigned short) const | const ImFontGlyph* ImFont::FindGlyphNoFallback(ImWchar c) const
{
if (c >= (size_t)IndexLookup.Size)
return NULL;
const ImWchar i = IndexLookup.Data[c];
if (i == (ImWchar)-1)
return NULL;
return &Glyphs.Data[i];
} | movl %esi, %eax
movslq 0x18(%rdi), %rcx
cmpq %rcx, %rax
jae 0x110cc4
movq 0x20(%rdi), %rcx
movzwl (%rcx,%rax,2), %ecx
leaq (%rcx,%rcx,4), %rdx
shll $0x3, %edx
addq 0x30(%rdi), %rdx
xorl %eax, %eax
cmpq $0xffff, %rcx # imm = 0xFFFF
cmovneq %rdx, %rax
retq
xorl %eax, %eax
retq
nop
| /embree[P]embree/tutorials/common/imgui/imgui_draw.cpp |
stbtt__close_shape(stbtt_vertex*, int, int, int, int, int, int, int, int, int) | static int stbtt__close_shape(stbtt_vertex *vertices, int num_vertices, int was_off, int start_off,
stbtt_int32 sx, stbtt_int32 sy, stbtt_int32 scx, stbtt_int32 scy, stbtt_int32 cx, stbtt_int32 cy)
{
if (start_off) {
if (was_off)
stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, (cx+scx)>>1... | pushq %rbp
pushq %rbx
movl %esi, %eax
movl 0x30(%rsp), %r10d
movl 0x28(%rsp), %r11d
testl %ecx, %ecx
je 0x114b1c
movl 0x20(%rsp), %ecx
movl 0x18(%rsp), %ebx
testl %edx, %edx
je 0x114af3
movslq %eax, %rdx
incl %eax
leaq (%rdx,%rdx), %rsi
shlq $0x4, %rdx
subq %rsi, %rdx
leal (%r11,%rbx), %esi
shrl %esi
leal (%r10,%rcx), ... | /embree[P]embree/tutorials/common/imgui/imstb_truetype.h |
ImGui::AlignTextToFramePadding() | inline ImGuiWindow* GetCurrentWindow() { ImGuiContext& g = *GImGui; g.CurrentWindow->WriteAccessed = true; return g.CurrentWindow; } | leaq 0xb94b9(%rip), %rax # 0x1d2030
movq (%rax), %rcx
movq 0x3ea0(%rcx), %rax
movb $0x1, 0x98(%rax)
movq 0x3ea0(%rcx), %rax
cmpb $0x0, 0x9b(%rax)
jne 0x118bf9
movss 0x3820(%rcx), %xmm0
addss %xmm0, %xmm0
addss 0x3c00(%rcx), %xmm0
movss 0x10c(%rax), %xmm1
movss 0x118(%rax), %xmm2
movaps %xmm0, %xmm3
cmpless %xmm1, %... | /embree[P]embree/tutorials/common/imgui/imgui_internal.h |
ImGui::ColorEditOptionsPopup(float const*, int) | void ImGui::ColorEditOptionsPopup(const float* col, ImGuiColorEditFlags flags)
{
bool allow_opt_inputs = !(flags & ImGuiColorEditFlags_DisplayMask_);
bool allow_opt_datatype = !(flags & ImGuiColorEditFlags_DataTypeMask_);
if ((!allow_opt_inputs && !allow_opt_datatype) || !BeginPopup("context"))
retu... | testl $0x700000, %esi # imm = 0x700000
setne %al
testl $0x1800000, %esi # imm = 0x1800000
setne %cl
testb %cl, %al
jne 0x122d93
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x4602b(%rip), %rdi # 0x1689e0
xorl %esi, %esi
callq ... | /embree[P]embree/tutorials/common/imgui/imgui_widgets.cpp |
ImGui::TreeNodeExV(char const*, int, char const*, __va_list_tag*) | bool ImGui::TreeNodeExV(const char* str_id, ImGuiTreeNodeFlags flags, const char* fmt, va_list args)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return false;
const char* label, *label_end;
ImFormatStringToTempBufferV(&label, &label_end, fmt, args);
return TreeNodeBeh... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
leaq 0xaca9d(%rip), %rax # 0x1d2030
movq (%rax), %rax
movq 0x3ea0(%rax), %rsi
movb $0x1, 0x98(%rsi)
movq 0x3ea0(%rax), %r15
cmpb $0x0, 0x9b(%r15)
je 0x1255b9
xorl %eax, %eax
jmp 0x1255ed
movq %rdi, %r14
leaq 0x8(%rsp), %r12
movq... | /embree[P]embree/tutorials/common/imgui/imgui_widgets.cpp |
ImGui::CollapsingHeader(char const*, bool*, int) | bool ImGui::CollapsingHeader(const char* label, bool* p_visible, ImGuiTreeNodeFlags flags)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return false;
if (p_visible && !*p_visible)
return false;
ImGuiID id = window->GetID(label);
flags |= ImGuiTreeNodeFlags_Col... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r15
leaq 0xabc9d(%rip), %r13 # 0x1d2030
movq (%r13), %rax
movq 0x3ea0(%rax), %rcx
movb $0x1, 0x98(%rcx)
movq 0x3ea0(%rax), %rdi
cmpb $0x0, 0x9b(%rdi)
jne 0x1263ca
movl %edx, %ebp
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1263... | /embree[P]embree/tutorials/common/imgui/imgui_widgets.cpp |
checkOptions(smf::Options&, int, char**) | void checkOptions(Options& opts, int argc, char* argv[]) {
opts.define("author=b", "author of program");
opts.define("version=b", "compilation info");
opts.define("example=b", "example usages");
opts.define("h|help=b", "short description");
opts.define("t|track=i:-1", "which track to extract");
opts.define("r|... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x164c8(%rip), %rsi # 0x2802c
leaq 0x164c9(%rip), %rdx # 0x28034
movq %rsp, %rdi
callq 0x129ba
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
le... | /craigsapp[P]midifile/tools/perfid.cpp |
smf::Option_register::Option_register(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Option_register::Option_register(const std::string& aDefinition, char aType,
const std::string& aDefaultOption) {
m_modifiedQ = false;
setType(aType);
setDefinition(aDefinition);
setDefault(aDefaultOption);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x30(%rdi), %r13
movq %r13, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb %al, 0x30(%rdi)
leaq 0x4... | /craigsapp[P]midifile/src/Options.cpp |
smf::Options::getCommand[abi:cxx11]() | std::string Options::getCommand(void) {
if (m_argument.size() == 0) {
return "";
} else {
return m_argument[0];
}
} | pushq %rbx
movq %rdi, %rbx
movq 0x48(%rsi), %rax
leaq 0x10(%rdi), %rcx
cmpq %rax, 0x50(%rsi)
movq %rcx, (%rdi)
je 0x13d73
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x150ba
jmp 0x13d85
leaq 0x14516(%rip), %rdx # 0x28290
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x129ba
movq %rbx, %rax
... | /craigsapp[P]midifile/src/Options.cpp |
smf::Options::getDouble(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | double Options::getDouble(const std::string& optionName) {
return strtod(getString(optionName).c_str(), (char**)NULL);
} | pushq %rbx
subq $0x30, %rsp
movq %rsi, %rdx
movq %rdi, %rsi
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x13e4a
movq (%rbx), %rdi
xorl %esi, %esi
callq 0x11250
movq (%rbx), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x13e44
movsd %xmm0, 0x8(%rsp)
callq 0x112d0
movsd 0x8(%rsp), %xmm0
addq $0x30, %rsp
popq %rbx
retq
| /craigsapp[P]midifile/src/Options.cpp |
smf::Options::getChar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | char Options::getChar(const std::string& optionName) {
return getString(optionName).c_str()[0];
} | pushq %rbx
subq $0x20, %rsp
movq %rsi, %rdx
movq %rdi, %rsi
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x13e4a
movq (%rbx), %rdi
movb (%rdi), %bl
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x13ee8
callq 0x112d0
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
retq
| /craigsapp[P]midifile/src/Options.cpp |
wabt::(anonymous namespace)::BinaryReaderIR::OnFunctionNamesCount(unsigned int) | Result BinaryReaderIR::OnFunctionNamesCount(Index count) {
if (count > module_->funcs.size()) {
PrintError("expected function name count (%" PRIindex
") <= function count (%" PRIzd ")",
count, module_->funcs.size());
return Result::Error;
}
return Result::Ok;
} | movl %esi, %edx
movq 0x18(%rdi), %rax
movq 0x90(%rax), %rcx
subq 0x88(%rax), %rcx
movl %esi, %esi
sarq $0x3, %rcx
xorl %eax, %eax
cmpq %rsi, %rcx
jae 0x36f21
pushq %rax
leaq 0x6f32f(%rip), %rsi # 0xa6240
xorl %eax, %eax
callq 0x37f7e
movl $0x1, %eax
addq $0x8, %rsp
retq
| /dcodeIO[P]wabt/src/binary-reader-ir.cc |
std::unique_ptr<wabt::TableInitExpr, std::default_delete<wabt::TableInitExpr>> wabt::MakeUnique<wabt::TableInitExpr, wabt::Var, wabt::Var>(wabt::Var&&, wabt::Var&&) | std::unique_ptr<T> MakeUnique(Args&&... args) {
return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0xd0, %edi
callq 0x1d5a0
movq %rax, %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x24(%rax)
movl $0x30, 0x38(%rax)
leaq 0xad115(%rip), %rax # 0xe8768
movq %rax, (%r1... | /dcodeIO[P]wabt/src/make-unique.h |
wabt::ReturnCallIndirectExpr::~ReturnCallIndirectExpr() | explicit ReturnCallIndirectExpr(const Location &loc = Location())
: ExprMixin<ExprType::ReturnCallIndirect>(loc) {} | pushq %rbx
movq %rdi, %rbx
leaq 0xad20d(%rip), %rax # 0xe8b18
movq %rax, (%rdi)
addq $0xc0, %rdi
callq 0x566e2
movq 0xa8(%rbx), %rdi
testq %rdi, %rdi
je 0x3b92b
callq 0x1d540
movq 0x90(%rbx), %rdi
testq %rdi, %rdi
je 0x3b93c
callq 0x1d540
addq $0x48, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x566e2
nop
| /dcodeIO[P]wabt/src/ir.h |
wabt::ReturnCallIndirectExpr::~ReturnCallIndirectExpr() | explicit ReturnCallIndirectExpr(const Location &loc = Location())
: ExprMixin<ExprType::ReturnCallIndirect>(loc) {} | pushq %rbx
movq %rdi, %rbx
leaq 0xad1c3(%rip), %rax # 0xe8b18
movq %rax, (%rdi)
addq $0xc0, %rdi
callq 0x566e2
movq 0xa8(%rbx), %rdi
testq %rdi, %rdi
je 0x3b975
callq 0x1d540
movq 0x90(%rbx), %rdi
testq %rdi, %rdi
je 0x3b986
callq 0x1d540
leaq 0x48(%rbx), %rdi
callq 0x566e2
movq %rbx, %rdi
popq %rbx
jmp 0x1d540
| /dcodeIO[P]wabt/src/ir.h |
wabt::EventModuleField::~EventModuleField() | explicit EventModuleField(const Location& loc = Location(),
string_view name = string_view())
: ModuleFieldMixin<ModuleFieldType::Event>(loc), event(name) {} | pushq %rbx
movq %rdi, %rbx
leaq 0xac079(%rip), %rax # 0xe8f10
movq %rax, (%rdi)
movq 0xc8(%rdi), %rdi
testq %rdi, %rdi
je 0x3ceab
callq 0x1d540
movq 0xb0(%rbx), %rdi
testq %rdi, %rdi
je 0x3cebc
callq 0x1d540
leaq 0x68(%rbx), %rdi
callq 0x566e2
movq 0x40(%rbx), %rdi
addq $0x50, %rbx
cmpq %rbx, %rdi
je 0x3ced8
popq %... | /dcodeIO[P]wabt/src/ir.h |
wabt::(anonymous namespace)::BinaryWriter::WriteSectionHeader(char const*, wabt::BinarySection) | void BinaryWriter::WriteSectionHeader(const char* desc,
BinarySection section_code) {
assert(last_section_leb_size_guess_ == 0);
WriteHeader(desc, PRINT_HEADER_NO_INDEX);
stream_->WriteU8Enum(section_code, "section code");
last_section_type_ = section_code;
last_section_l... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpq $0x0, 0xd8(%rdi)
jne 0x441a5
movl %edx, %ebp
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x4412e
movq %rsi, %rdx
leaq 0x65c3c(%rip), %rsi # 0xa9d5d
movq %rax, %rdi
xorl %eax, %eax
callq 0x639b6
movq (%rbx), %rdi
leaq 0x5eb2f(%rip... | /dcodeIO[P]wabt/src/binary-writer.cc |
wabt::HashCombine(unsigned long, unsigned long) | hash_code HashCombine(hash_code seed, hash_code y) {
#if SIZEOF_SIZE_T == 4
constexpr hash_code magic = 0x9e3779b9;
#elif SIZEOF_SIZE_T == 8
constexpr hash_code magic = 0x9e3779b97f4a7c16;
#else
#error "weird sizeof size_t"
#endif
seed ^= y + magic + (seed << 6) + (seed >> 2);
return seed;
} | movq %rdi, %rcx
shlq $0x6, %rcx
addq %rsi, %rcx
movq %rdi, %rdx
shrq $0x2, %rdx
movabsq $-0x61c8864680b583ea, %rax # imm = 0x9E3779B97F4A7C16
addq %rdx, %rax
addq %rcx, %rax
xorq %rdi, %rax
retq
nopl (%rax)
| /dcodeIO[P]wabt/src/hash-util.cc |
wabt::Module::IsImport(wabt::ExternalKind, wabt::Var const&) const | bool Module::IsImport(ExternalKind kind, const Var& var) const {
switch (kind) {
case ExternalKind::Func:
return GetFuncIndex(var) < num_func_imports;
case ExternalKind::Global:
return GetGlobalIndex(var) < num_global_imports;
case ExternalKind::Memory:
return GetMemoryIndex(var) < num... | cmpl $0x4, %esi
ja 0x55138
pushq %rbx
movq %rdi, %rbx
movl %esi, %eax
leaq 0x57fa8(%rip), %rcx # 0xad070
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x1b0(%rbx), %rdi
movq %rdx, %rsi
callq 0x479d8
cmpl 0x5c(%rbx), %eax
jmp 0x55133
leaq 0x178(%rbx), %rdi
movq %rdx, %rsi
callq 0x479d8
cmpl 0x58(%rbx), ... | /dcodeIO[P]wabt/src/ir.cc |
wabt::LocalTypes::Set(std::vector<wabt::Type, std::allocator<wabt::Type>> const&) | 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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
cmpq %rax, 0x8(%rdi)
je 0x5515a
movq %rax, 0x8(%rbx)
movq (%r14), %rax
movq 0x8(%r14), %rcx
cmpq %rcx, %rax
je 0x551ee
movl (%rax), %edx
movl %edx, 0x4(%rsp)
movl $0x1, (%rsp)
movq %rcx, %rsi
s... | /dcodeIO[P]wabt/src/ir.cc |
wabt::Module::GetFunc(wabt::Var const&) const | const Func* Module::GetFunc(const Var& var) const {
return const_cast<Module*>(this)->GetFunc(var);
} | pushq %rbx
movq %rdi, %rbx
addq $0x1b0, %rdi # imm = 0x1B0
callq 0x479d8
movl %eax, %eax
movq 0x88(%rbx), %rcx
movq 0x90(%rbx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rax, %rdx
jbe 0x55334
movq (%rcx,%rax,8), %rax
jmp 0x55336
xorl %eax, %eax
popq %rbx
retq
| /dcodeIO[P]wabt/src/ir.cc |
wabt::Module::GetGlobal(wabt::Var const&) const | const Global* Module::GetGlobal(const Var& var) const {
return const_cast<Module*>(this)->GetGlobal(var);
} | pushq %rbx
movq %rdi, %rbx
addq $0x1e8, %rdi # imm = 0x1E8
callq 0x479d8
movl %eax, %eax
movq 0xa0(%rbx), %rcx
movq 0xa8(%rbx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rax, %rdx
jbe 0x553a0
movq (%rcx,%rax,8), %rax
jmp 0x553a2
xorl %eax, %eax
popq %rbx
retq
| /dcodeIO[P]wabt/src/ir.cc |
wabt::Module::GetTable(wabt::Var const&) const | const Table* Module::GetTable(const Var& var) const {
return const_cast<Module*>(this)->GetTable(var);
} | pushq %rbx
movq %rdi, %rbx
addq $0x290, %rdi # imm = 0x290
callq 0x479d8
movl %eax, %eax
movq 0x100(%rbx), %rcx
movq 0x108(%rbx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rax, %rdx
jbe 0x5540c
movq (%rcx,%rax,8), %rax
jmp 0x5540e
xorl %eax, %eax
popq %rbx
retq
| /dcodeIO[P]wabt/src/ir.cc |
wabt::Module::GetElemSegment(wabt::Var const&) const | const ElemSegment* Module::GetElemSegment(const Var& var) const {
return const_cast<Module*>(this)->GetElemSegment(var);
} | pushq %rbx
movq %rdi, %rbx
addq $0x338, %rdi # imm = 0x338
callq 0x479d8
movl %eax, %eax
movq 0x118(%rbx), %rcx
movq 0x120(%rbx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rax, %rdx
jbe 0x55580
movq (%rcx,%rax,8), %rax
jmp 0x55582
xorl %eax, %eax
popq %rbx
retq
| /dcodeIO[P]wabt/src/ir.cc |
wabt::Module::GetFuncType(wabt::Var const&) | FuncType* Module::GetFuncType(const Var& var) {
Index index = type_bindings.FindIndex(var);
if (index >= types.size()) {
return nullptr;
}
return dyn_cast<FuncType>(types[index]);
} | pushq %rbx
movq %rdi, %rbx
addq $0x258, %rdi # imm = 0x258
callq 0x479d8
movl %eax, %eax
movq 0xe8(%rbx), %rcx
movq 0xf0(%rbx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rax, %rdx
jbe 0x555fc
movq (%rcx,%rax,8), %rcx
xorl %eax, %eax
cmpl $0x0, 0x48(%rcx)
cmoveq %rcx, %rax
jmp 0x555fe
xorl %eax, %eax
popq %r... | /dcodeIO[P]wabt/src/ir.cc |
wabt::Module::AppendField(std::unique_ptr<wabt::ElemSegmentModuleField, std::default_delete<wabt::ElemSegmentModuleField>>) | void Module::AppendField(std::unique_ptr<ElemSegmentModuleField> field) {
ElemSegment& elem_segment = field->elem_segment;
if (!elem_segment.name.empty()) {
elem_segment_bindings.emplace(elem_segment.name,
Binding(field->loc, elem_segments.size()));
}
elem_segments.push_bac... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
cmpq $0x0, 0x50(%r15)
je 0x557ca
leaq 0x48(%r15), %rdx
movq 0x120(%rbx), %rax
subq 0x118(%rbx), %rax
leaq 0x338(%rbx), %rdi
shrq $0x3, %rax
movups 0x18(%r15), %xmm0
movups 0x28(%r15), %xmm1
movq %rsp, %rcx
movaps %xmm1, ... | /dcodeIO[P]wabt/src/ir.cc |
wabt::Module::AppendField(std::unique_ptr<wabt::EventModuleField, std::default_delete<wabt::EventModuleField>>) | void Module::AppendField(std::unique_ptr<EventModuleField> field) {
Event& event = field->event;
if (!event.name.empty()) {
event_bindings.emplace(event.name, Binding(field->loc, events.size()));
}
events.push_back(&event);
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 0x558b1
movq 0x78(%rbx), %rdx
subq 0x70(%rbx), %rdx
leaq 0x178(%rbx), %rdi
shrq $0x3, %rdx
movups 0x18(%rax), %xmm0
movups 0x28(%rax), %xmm1
movq %rsp, %rcx
movaps %xmm1, 0x... | /dcodeIO[P]wabt/src/ir.cc |
wabt::Module::AppendField(std::unique_ptr<wabt::FuncModuleField, std::default_delete<wabt::FuncModuleField>>) | void Module::AppendField(std::unique_ptr<FuncModuleField> field) {
Func& func = field->func;
if (!func.name.empty()) {
func_bindings.emplace(func.name, Binding(field->loc, funcs.size()));
}
funcs.push_back(&func);
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 0x55a7f
movq 0x90(%rbx), %rdx
subq 0x88(%rbx), %rdx
leaq 0x1b0(%rbx), %rdi
shrq $0x3, %rdx
movups 0x18(%rax), %xmm0
movups 0x28(%rax), %xmm1
movq %rsp, %rcx
movaps %xmm1, 0x... | /dcodeIO[P]wabt/src/ir.cc |
wabt::Module::AppendField(std::unique_ptr<wabt::TypeModuleField, std::default_delete<wabt::TypeModuleField>>) | void Module::AppendField(std::unique_ptr<TypeModuleField> field) {
TypeEntry& type = *field->type;
if (!type.name.empty()) {
type_bindings.emplace(type.name, Binding(field->loc, types.size()));
}
types.push_back(&type);
fields.push_back(std::move(field));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x40(%rax), %r15
cmpq $0x0, 0x30(%r15)
je 0x55b68
leaq 0x28(%r15), %rdx
movq 0xf0(%rbx), %rsi
subq 0xe8(%rbx), %rsi
leaq 0x258(%rbx), %rdi
shrq $0x3, %rsi
movups 0x18(%rax), %xmm0
movups 0x28(%rax), %xmm1
movq %rsp,... | /dcodeIO[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 0x55fe3
movq 0x138(%rbx), %rdx
subq 0x130(%rbx), %rdx
leaq 0x2c8(%rbx), %rdi
shrq $0x3, %rdx
movups 0x18(%rax), %xmm0
movups 0x28(%rax), %xmm1
movq %rsp, %rcx
movaps %xmm1, ... | /dcodeIO[P]wabt/src/ir.cc |
wabt::Module::AppendField(std::unique_ptr<wabt::TableModuleField, std::default_delete<wabt::TableModuleField>>) | void Module::AppendField(std::unique_ptr<TableModuleField> field) {
Table& table = field->table;
if (!table.name.empty()) {
table_bindings.emplace(table.name, Binding(field->loc, tables.size()));
}
tables.push_back(&table);
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 0x5616d
movq 0x108(%rbx), %rdx
subq 0x100(%rbx), %rdx
leaq 0x290(%rbx), %rdi
shrq $0x3, %rdx
movups 0x18(%rax), %xmm0
movups 0x28(%rax), %xmm1
movq %rsp, %rcx
movaps %xmm1, ... | /dcodeIO[P]wabt/src/ir.cc |
wabt::Var::operator=(wabt::Var&&) | Var& Var::operator=(Var&& rhs) {
loc = rhs.loc;
if (rhs.is_index()) {
set_index(rhs.index_);
} else {
set_name(rhs.name_);
}
return *this;
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
cmpl $0x0, 0x20(%rsi)
je 0x565b5
movq 0x28(%rsi), %rax
movq 0x30(%rsi), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x56696
jmp 0x565da
movl 0x28(%rsi), %ebp
cmpl $0x1, 0x20(%rbx)
... | /dcodeIO[P]wabt/src/ir.cc |
wabt::Var::set_index(unsigned int) | void Var::set_index(Index index) {
Destroy();
type_ = VarType::Index;
index_ = index;
} | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpl $0x1, 0x20(%rdi)
jne 0x56681
movq 0x28(%r14), %rdi
leaq 0x38(%r14), %rax
cmpq %rax, %rdi
je 0x56681
callq 0x1d540
movl $0x0, 0x20(%r14)
movl %ebx, 0x28(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /dcodeIO[P]wabt/src/ir.cc |
wabt::Var::set_name(wabt::string_view) | void Var::set_name(string_view name) {
set_name(name.to_string());
} | pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x28(%rsp), %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x64198
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5671a
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x566d9
callq 0x1d540
addq $0x38... | /dcodeIO[P]wabt/src/ir.cc |
wabt::Var::~Var() | bool is_name() const { return type_ == VarType::Name; } | cmpl $0x1, 0x20(%rdi)
jne 0x566fd
movq 0x28(%rdi), %rax
addq $0x38, %rdi
cmpq %rdi, %rax
je 0x566fd
movq %rax, %rdi
jmp 0x1d540
retq
| /dcodeIO[P]wabt/src/ir.h |
wabt::Var::set_name(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&) | void Var::set_name(std::string&& name) {
Destroy();
type_ = VarType::Name;
Construct(name_, std::move(name));
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x1, 0x20(%rdi)
jne 0x5673c
movq 0x28(%r14), %rdi
leaq 0x38(%r14), %rax
cmpq %rax, %rdi
je 0x5673c
callq 0x1d540
movl $0x1, 0x20(%r14)
leaq 0x38(%r14), %rcx
movq %rcx, 0x28(%r14)
movq (%rbx), %rdx
leaq 0x10(%rbx), %rax
cmpq %rax, %rdx
je 0x56765
mov... | /dcodeIO[P]wabt/src/ir.cc |
wabt::Label::Label(wabt::LabelType, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<wabt::Type, std::allocator<wabt::Type>> const&, std::vector<wabt::Type, std::allocator<wabt::Type>> const&) | Label(LabelType label_type,
const std::string& name,
const TypeVector& param_types,
const TypeVector& result_types)
: name(name),
label_type(label_type),
param_types(param_types),
result_types(result_types) {} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movl %esi, %ebp
movq %rdi, %r15
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
callq 0x1d250
movl %ebp, 0x20(%r15)
leaq 0x28(%r15), %rdi
movq %r14, %rsi
callq 0x3ba14
addq $0x40, %r15
mo... | /dcodeIO[P]wabt/src/ir-util.h |
wabt::WriteFixedU32Leb128At(wabt::Stream*, unsigned long, unsigned int, char const*) | Offset WriteFixedU32Leb128At(Stream* stream,
Offset offset,
uint32_t value,
const char* desc) {
uint8_t data[MAX_U32_LEB128_BYTES];
Offset length =
WriteFixedU32Leb128Raw(data, data + MAX_U32_LEB128_BYTES, value);
stream-... | pushq %rax
movq %rcx, %r8
movl %edx, %eax
movl %eax, %ecx
orb $-0x80, %cl
leaq 0x3(%rsp), %rdx
movb %cl, (%rdx)
movl %eax, %ecx
shrl $0x7, %ecx
orb $-0x80, %cl
movb %cl, 0x1(%rdx)
movl %eax, %ecx
shrl $0xe, %ecx
orb $-0x80, %cl
movb %cl, 0x2(%rdx)
movl %eax, %ecx
shrl $0x15, %ecx
orb $-0x80, %cl
movb %cl, 0x3(%rdx)
shr... | /dcodeIO[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
cmpl $0x80, %edx
jb 0x582d0
movl %edx, %eax
shrl $0x7, %edx
movl %eax, %ecx
orb $-0x80, %cl
movb %cl, 0xb(%rsp,%rbx)
incq %rbx
cmpl $0x3fff, %eax # imm = 0x3FFF
movl %edx, %eax
ja 0x582b8
movb %dl, 0xb(%rsp,%rbx)
incq %rbx
subq %rdi, %rsi
cmpq %rbx, %rsi
jae 0x582e3... | /dcodeIO[P]wabt/src/leb128.cc |
wabt::WriteS64Leb128(wabt::Stream*, unsigned long, char const*) | void WriteS64Leb128(Stream* stream, uint64_t value, const char* desc) {
WriteS64Leb128(stream, Bitcast<int64_t>(value), desc);
} | subq $0x18, %rsp
movq %rdx, %rcx
testq %rsi, %rsi
js 0x583c5
cmpq $0x40, %rsi
jb 0x5840e
xorl %edx, %edx
movl %esi, %r8d
movq %rsi, %rax
shrq $0x7, %rsi
orb $-0x80, %r8b
movb %r8b, 0xe(%rsp,%rdx)
incq %rdx
movl %esi, %r8d
cmpq $0x1fff, %rax # imm = 0x1FFF
movq %rsi, %rax
ja 0x583a5
jmp 0x58410
movq %rsi, %rax... | /dcodeIO[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 0x5849b
movsbl (%rdi), %ecx
testl %ecx, %ecx
js 0x5849b
movl $0x1, %eax
jmp 0x58585
leaq 0x1(%rdi), %rax
cmpq %rsi, %rax
jae 0x584c0
movsbl (%rax), %eax
testl %eax, %eax
js 0x584c0
shll $0x7, %eax
movzbl (%rdi), %ecx
andl $0x7f, %ecx
orl %eax, %ecx
movl $0x2, %eax
jmp 0x58585
leaq 0x2(%rdi), %rax
cm... | /dcodeIO[P]wabt/src/leb128.cc |
wabt::LexerSourceLineFinder::GetCachedLine(int) const | bool LexerSourceLineFinder::IsLineCached(int line) const {
return static_cast<size_t>(line) < line_ranges_.size();
} | movslq %esi, %rcx
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rax
subq %rdx, %rax
sarq $0x4, %rax
cmpq %rcx, %rax
jbe 0x59479
shlq $0x4, %rcx
movq (%rdx,%rcx), %rax
movq 0x8(%rdx,%rcx), %rdx
retq
pushq %rax
leaq 0x542ab(%rip), %rdi # 0xad72c
leaq 0x542b7(%rip), %rsi # 0xad73f
leaq 0x54316(%rip), %rcx # 0xad7a5
m... | /dcodeIO[P]wabt/src/lexer-source-line-finder.cc |
wabt::ParseUint64(char const*, char const*, unsigned long*) | Result ParseUint64(const char* s, const char* end, uint64_t* out) {
if (s == end) {
return Result::Error;
}
uint64_t value = 0;
if (*s == '0' && s + 1 < end && s[1] == 'x') {
s += 2;
if (s == end) {
return Result::Error;
}
constexpr uint64_t kMaxDiv16 = UINT64_MAX / 16;
constexpr u... | movl $0x1, %eax
cmpq %rsi, %rdi
je 0x5991a
cmpb $0x30, (%rdi)
jne 0x598c0
leaq 0x1(%rdi), %rcx
cmpq %rsi, %rcx
jae 0x598c0
cmpb $0x78, (%rcx)
jne 0x598c0
addq $0x2, %rdi
cmpq %rsi, %rdi
je 0x5991a
jae 0x59913
xorl %ecx, %ecx
movsbl (%rdi), %r8d
cmpl $0x5f, %r8d
je 0x598b6
leal -0x30(%r8), %r9d
cmpl $0xa, %r9d
jb 0x598a... | /dcodeIO[P]wabt/src/literal.cc |
wabt::ParseDouble(wabt::LiteralType, char const*, char const*, unsigned long*) | Result FloatParser<T>::Parse(LiteralType literal_type,
const char* s,
const char* end,
Uint* out_bits) {
#if COMPILER_IS_MSVC
if (literal_type == LiteralType::Int && StringStartsWith(s, end, "0x")) {
// Some MSVC crt implementa... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x4, %edi
ja 0x5a737
movq %rcx, %r8
movl %edi, %eax
leaq 0x5371a(%rip), %rcx # 0xad858
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rsi, %rdi
movq %rdx, %rsi
movq %r8, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5ae3c... | /dcodeIO[P]wabt/src/literal.cc |
wabt::Result wabt::ParseInt<unsigned int>(char const*, char const*, unsigned int*, wabt::ParseIntType) | Result ParseInt(const char* s,
const char* end,
U* out,
ParseIntType parse_type) {
typedef typename std::make_signed<U>::type S;
uint64_t value;
bool has_sign = false;
if (*s == '-' || *s == '+') {
if (parse_type == ParseIntType::UnsignedOnly) {
return R... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movzbl (%rdi), %r14d
cmpl $0x2d, %r14d
je 0x5b063
cmpl $0x2b, %r14d
jne 0x5b0a5
movl $0x1, %ebp
testl %ecx, %ecx
je 0x5b0d2
incq %rdi
leaq 0x8(%rsp), %rdx
callq 0x59838
cmpl $0x1, %eax
je 0x5b0d2
movq 0x8(%rsp), %rax
cmpb $0x2d, %r14b
jne 0x5b0dd
movl $0... | /dcodeIO[P]wabt/src/literal.cc |
wabt::Opcode::IsNaturallyAligned(unsigned long) const | Opcode::Info Opcode::GetInfo() const {
if (enum_ < Invalid) {
return infos_[enum_];
}
Info invalid_info = infos_[Opcode::Invalid];
DecodeInvalidOpcode(enum_, &invalid_info.prefix, &invalid_info.code);
invalid_info.prefix_code = PrefixCode(invalid_info.prefix, invalid_info.code);
return invalid_info;
} | movl (%rdi), %eax
imulq $0x38, %rax, %rcx
cmpq $0x1d6, %rax # imm = 0x1D6
leaq 0x915bf(%rip), %rax # 0xec7c0
leaq 0x20(%rcx,%rax), %rax
leaq 0x97ca3(%rip), %rcx # 0xf2eb0
cmovbq %rax, %rcx
cmpq $-0x1, %rsi
sete %dl
cmpq %rsi, (%rcx)
sete %al
orb %dl, %al
retq
nop
| /dcodeIO[P]wabt/src/opcode.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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl (%rsi), %eax
cmpq $0x1d5, %rax # imm = 0x1D5
ja 0x5b2f1
imulq $0x38, %rax, %rcx
leaq 0x914dd(%rip), %rdx # 0xec7c0
movb 0x28(%rcx,%rdx), %al
testb %al, %al
jne 0x5b2fd
movl ... | /dcodeIO[P]wabt/src/opcode.cc |
wabt::interp::Thread::PopValues(std::vector<wabt::Type, std::allocator<wabt::Type>> const&, std::vector<wabt::interp::Value, std::allocator<wabt::interp::Value>>*) | void Thread::PopValues(const ValueTypes& types, Values* out_values) {
assert(values_.size() >= types.size());
out_values->resize(types.size());
std::copy(values_.end() - types.size(), values_.end(), out_values->begin());
values_.resize(values_.size() - types.size());
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq 0x60(%rdi), %rax
subq 0x58(%rdi), %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
imulq %r13, %rax
movq 0x8(%rsi), %rsi
subq (%r14), %rsi
sarq $0x2, %rsi
cmpq %rsi, %rax
jb 0x87956
movq %rdx, %r12
movq %rdi, %... | /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::HostFunc::HostFunc(wabt::interp::Store&, wabt::interp::FuncType, std::function<wabt::Result (wabt::interp::Thread&, std::vector<wabt::interp::Value, std::allocator<wabt::interp::Value>> const&, std::vector<wabt::interp::Value, std::allocator<wabt::interp::Value>>&, wabt::interp::RefPtr<wabt::interp::Trap>... | HostFunc::HostFunc(Store&, FuncType type, Callback callback)
: Func(skind, type), callback_(callback) {} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rdx, %r13
movq %rdi, %r14
movl 0x8(%rdx), %eax
leaq 0x18(%rsp), %r15
movl %eax, -0x8(%r15)
leaq 0x63f00(%rip), %rbp # 0xeb8a0
movq %rbp, -0x10(%r15)
leaq 0x10(%rdx), %rsi
movq %r15, %rdi
callq 0x3ba14
leaq 0x30(... | /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::Table::Init(wabt::interp::Store&, unsigned int, wabt::interp::ElemSegment const&, unsigned int, unsigned int) | Result Table::Init(Store& store,
u32 dst_offset,
const ElemSegment& src,
u32 src_offset,
u32 size) {
if (IsValidRange(dst_offset, size) && src.IsValidRange(src_offset, size) &&
TypesMatch(type_.element, src.desc().type)) {
std::copy... | pushq %rbp
pushq %rbx
pushq %rax
movl %edx, %eax
movq 0x68(%rdi), %r10
movq 0x70(%rdi), %rsi
subq %r10, %rsi
sarq $0x3, %rsi
movl %r9d, %edx
subq %rdx, %rsi
setae %r11b
movl %eax, %eax
cmpq %rax, %rsi
setae %sil
andb %r11b, %sil
movl $0x1, %ebx
cmpb $0x1, %sil
jne 0x87e8b
movq 0x8(%rcx), %rsi
movq 0x10(%rcx), %r11
subq... | /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::Table::Copy(wabt::interp::Store&, wabt::interp::Table&, unsigned int, wabt::interp::Table const&, unsigned int, unsigned int) | Result Table::Copy(Store& store,
Table& dst,
u32 dst_offset,
const Table& src,
u32 src_offset,
u32 size) {
if (dst.IsValidRange(dst_offset, size) &&
src.IsValidRange(src_offset, size) &&
TypesMatch(dst.type_.ele... | pushq %rbp
pushq %rbx
pushq %rax
movl %edx, %eax
movq 0x68(%rsi), %rdi
movq 0x70(%rsi), %r11
subq %rdi, %r11
sarq $0x3, %r11
movl %r9d, %edx
subq %rdx, %r11
setae %bl
movl %eax, %r10d
cmpq %r10, %r11
setae %al
andb %bl, %al
movl $0x1, %ebx
cmpb $0x1, %al
jne 0x87f46
movq 0x68(%rcx), %rax
movq 0x70(%rcx), %r11
subq %rax... | /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::Thread::PushCall(wabt::interp::HostFunc const&, wabt::interp::RefPtr<wabt::interp::Trap>*) | RunResult Thread::PushCall(const HostFunc& func, Trap::Ptr* out_trap) {
TRAP_IF(frames_.size() == frames_.capacity(), "call stack exhausted");
inst_ = nullptr;
mod_ = nullptr;
frames_.emplace_back(func.self(), values_.size(), 0, inst_, mod_);
return RunResult::Ok;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
leaq 0x40(%rdi), %rbx
movq 0x48(%rdi), %rax
cmpq 0x50(%rdi), %rax
je 0x89e08
leaq 0x90(%rdi), %r8
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%rdi)
movq 0x38(%rsi), %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq 0x60(%rdi), %rax
subq 0x58(%... | /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::Thread::DoMemoryCopy(wabt::interp::Instr, wabt::interp::RefPtr<wabt::interp::Trap>*) | RunResult Thread::DoMemoryCopy(Instr instr, Trap::Ptr* out_trap) {
Memory::Ptr mem_dst{store_, inst_->memories()[instr.imm_u32x2.fst]};
Memory::Ptr mem_src{store_, inst_->memories()[instr.imm_u32x2.snd]};
auto size = PopPtr(mem_src);
auto src = PopPtr(mem_src);
auto dst = PopPtr(mem_dst);
// TODO: change to... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x88(%rdi), %rsi
movq 0x90(%rdi), %rax
movl 0xa8(%rsp), %ecx
movq 0x90(%rax), %rax
movq (%rax,%rcx,8), %rdx
leaq 0x18(%rsp), %rdi
callq 0x90132
movq 0x88(%r14), %rsi
movq 0x90(%r14), %rax
movl 0xac(%r... | /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::Thread::DoTableCopy(wabt::interp::Instr, wabt::interp::RefPtr<wabt::interp::Trap>*) | RunResult Thread::DoTableCopy(Instr instr, Trap::Ptr* out_trap) {
Table::Ptr table_dst{store_, inst_->tables()[instr.imm_u32x2.fst]};
Table::Ptr table_src{store_, inst_->tables()[instr.imm_u32x2.snd]};
auto size = Pop<u32>();
auto src = Pop<u32>();
auto dst = Pop<u32>();
TRAP_IF(Failed(Table::Copy(store_, *... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x88(%rdi), %rsi
movq 0x90(%rdi), %rax
movl 0xa8(%rsp), %ecx
movq 0x78(%rax), %rax
movq (%rax,%rcx,8), %rdx
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x900d0
movq 0x88(%r14), %rsi
movq 0x90(%r14), %... | /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::Result wabt::interp::Extern::MatchImpl<wabt::interp::TableType>(wabt::interp::Store&, wabt::interp::ImportType const&, wabt::interp::TableType const&, wabt::interp::RefPtr<wabt::interp::Trap>*) | Result Extern::MatchImpl(Store& store,
const ImportType& import_type,
const T& actual,
Trap::Ptr* out_trap) {
const T* extern_type = dyn_cast<T>(import_type.type.get());
if (!extern_type) {
*out_trap = Trap::New(
store,
S... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %rbx
movq %rdx, %rax
movq %rsi, %r14
movq 0x40(%rdx), %rdi
movslq 0x8(%rdi), %rsi
cmpq $0x1, %rsi
sete %dl
testq %rdi, %rdi
setne %r8b
testb %dl, %r8b
jne 0x8f7da
movq (%rax), %rdx
movq 0x20(%rax), %rcx
cmpl $0x4, %esi
jg 0x8f8... | /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::RefPtr<wabt::interp::Func>::RefPtr(wabt::interp::Store&, wabt::interp::Ref) | RefPtr<T>::RefPtr(Store& store, Ref ref) {
#ifndef NDEBUG
if (!store.Is<T>(ref)) {
ObjectKind ref_kind;
if (ref == Ref::Null) {
ref_kind = ObjectKind::Null;
} else {
ref_kind = store.objects_.Get(ref.index)->kind();
}
fprintf(stderr, "Invalid conversion from Ref (%s) to RefPtr<%s>!\n",... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x996c4
testb %al, %al
je 0x901ea
leaq 0x8(%rsp), %rsi
movq %r15, (%rsi)
leaq 0x68(%rbx), %rdi
callq 0x8f0bc
movq %rax, 0x10(%r14)
leaq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0x8f40a
m... | /dcodeIO[P]wabt/src/interp/interp-inl.h |
wabt::interp::RunResult wabt::interp::Thread::DoStore<float, float>(wabt::interp::Instr, wabt::interp::RefPtr<wabt::interp::Trap>*) | RunResult Thread::DoStore(Instr instr, Trap::Ptr* out_trap) {
Memory::Ptr memory{store_, inst_->memories()[instr.imm_u32x2.fst]};
V val = static_cast<V>(Pop<T>());
u64 offset = PopPtr(memory);
TRAP_IF(Failed(memory->Store(offset, instr.imm_u32x2.snd, val)),
StringPrintf("out of bounds memory access: a... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x90(%rsp), %r12
movq 0x88(%rdi), %rsi
movq 0x90(%rdi), %rax
movl 0x8(%r12), %ecx
movq 0x90(%rax), %rax
movq (%rax,%rcx,8), %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x90132
movq %r14, %rdi
callq 0x9ab08
m... | /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::RunResult wabt::interp::IntDiv<int>(int, int, int*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | RunResult WABT_VECTORCALL IntDiv(T lhs, T rhs, T* out, std::string* out_msg) {
if (WABT_UNLIKELY(rhs == 0)) {
*out_msg = "integer divide by zero";
return RunResult::Trap;
}
if (WABT_LIKELY(IsNormalDivRem(lhs, rhs))) {
*out = lhs / rhs;
return RunResult::Ok;
} else {
*out_msg = "integer overf... | pushq %rax
testl %esi, %esi
je 0x91471
movq %rdx, %r8
leal -0x80000000(%rdi), %eax
movl %esi, %edx
notl %edx
orl %eax, %edx
je 0x9147a
movl %edi, %eax
cltd
idivl %esi
movl %eax, (%r8)
xorl %eax, %eax
popq %rcx
retq
leaq 0x24fb6(%rip), %rsi # 0xb642e
jmp 0x91481
leaq 0x24fc4(%rip), %rsi # 0xb6445
movq %rcx, %rdi... | /dcodeIO[P]wabt/src/interp/interp-math.h |
wabt::interp::RunResult wabt::interp::IntDiv<unsigned long>(unsigned long, unsigned long, unsigned long*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | RunResult WABT_VECTORCALL IntDiv(T lhs, T rhs, T* out, std::string* out_msg) {
if (WABT_UNLIKELY(rhs == 0)) {
*out_msg = "integer divide by zero";
return RunResult::Trap;
}
if (WABT_LIKELY(IsNormalDivRem(lhs, rhs))) {
*out = lhs / rhs;
return RunResult::Ok;
} else {
*out_msg = "integer overf... | testq %rsi, %rsi
je 0x91795
movq %rdx, %r8
movq %rdi, %rax
xorl %edi, %edi
xorl %edx, %edx
divq %rsi
movq %rax, (%r8)
movl %edi, %eax
retq
pushq %rax
leaq 0x24c91(%rip), %rsi # 0xb642e
movq %rcx, %rdi
callq 0x1d8a0
movl $0x2, %edi
addq $0x8, %rsp
jmp 0x91792
| /dcodeIO[P]wabt/src/interp/interp-math.h |
wabt::interp::RunResult wabt::interp::Thread::DoSimdBinop<unsigned short, unsigned short>(unsigned short (*)(unsigned short, unsigned short)) | RunResult Thread::DoSimdBinop(BinopFunc<R, T> f) {
using ST = typename Simd128<T>::Type;
using SR = typename Simd128<R>::Type;
static_assert(ST::lanes == SR::lanes, "SIMD lanes don't match");
auto rhs = Pop<ST>();
auto lhs = Pop<ST>();
SR result;
for (u8 i = 0; i < SR::lanes; ++i) {
result[i] = f(lhs[... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x9afea
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq %rbx, %rdi
callq 0x9afea
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
xorl %r15d, %r15d
movzwl 0x10(%rsp,%r15,2), %edi
movzwl 0x20(%rsp,%r15,2), %esi
callq *%r14
movw %ax, (%rs... | /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::RunResult wabt::interp::Thread::DoSimdBinop<unsigned int, unsigned int>(unsigned int (*)(unsigned int, unsigned int)) | RunResult Thread::DoSimdBinop(BinopFunc<R, T> f) {
using ST = typename Simd128<T>::Type;
using SR = typename Simd128<R>::Type;
static_assert(ST::lanes == SR::lanes, "SIMD lanes don't match");
auto rhs = Pop<ST>();
auto lhs = Pop<ST>();
SR result;
for (u8 i = 0; i < SR::lanes; ++i) {
result[i] = f(lhs[... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x9b126
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq %rbx, %rdi
callq 0x9b126
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
xorl %r15d, %r15d
movl 0x10(%rsp,%r15,4), %edi
movl 0x20(%rsp,%r15,4), %esi
callq *%r14
movl %eax, (%rsp,%... | /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::RunResult wabt::interp::Thread::DoSimdIsTrue<wabt::interp::Simd<unsigned char, (unsigned char)16>, (unsigned char)16>() | RunResult Thread::DoSimdIsTrue() {
using L = typename S::LaneType;
auto val = Pop<S>();
Push(std::count_if(std::begin(val.v), std::end(val.v),
[](L x) { return x != 0; }) >= count);
return RunResult::Ok;
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x95f6a
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
pxor %xmm0, %xmm0
xorl %eax, %eax
pcmpeqd %xmm2, %xmm2
movdqa 0x21f2c(%rip), %xmm3 # 0xb4820
pxor %xmm1, %xmm1
movzwl (%rsp,%rax), %ecx
movd %ecx, %xmm4
pcmpeqb %xmm0, %xmm4
pxor %xmm2, %xmm4
punpcklbw %xmm4, %xmm4 # ... | /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::RunResult wabt::interp::Thread::DoSimdIsTrue<wabt::interp::Simd<unsigned short, (unsigned char)8>, (unsigned char)1>() | RunResult Thread::DoSimdIsTrue() {
using L = typename S::LaneType;
auto val = Pop<S>();
Push(std::count_if(std::begin(val.v), std::end(val.v),
[](L x) { return x != 0; }) >= count);
return RunResult::Ok;
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x9afea
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
pxor %xmm0, %xmm0
xorl %eax, %eax
movdqa 0x21d4c(%rip), %xmm2 # 0xb4820
pxor %xmm1, %xmm1
movd (%rsp,%rax,2), %xmm3
pshufd $0x0, %xmm3, %xmm3 # xmm3 = xmm3[0,0,0,0]
pshufhw $0x55, %xmm3, %xmm3 # xmm3 = xmm3[0,1,... | /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::RunResult wabt::interp::Thread::DoSimdIsTrue<wabt::interp::Simd<unsigned short, (unsigned char)8>, (unsigned char)8>() | RunResult Thread::DoSimdIsTrue() {
using L = typename S::LaneType;
auto val = Pop<S>();
Push(std::count_if(std::begin(val.v), std::end(val.v),
[](L x) { return x != 0; }) >= count);
return RunResult::Ok;
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x9afea
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
pxor %xmm0, %xmm0
xorl %eax, %eax
movdqa 0x21c76(%rip), %xmm2 # 0xb4820
pxor %xmm1, %xmm1
movd (%rsp,%rax,2), %xmm3
pshufd $0x0, %xmm3, %xmm3 # xmm3 = xmm3[0,0,0,0]
pshufhw $0x55, %xmm3, %xmm3 # xmm3 = xmm3[0,1,... | /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::RunResult wabt::interp::Thread::DoSimdBitmask<wabt::interp::Simd<int, (unsigned char)4>>() | RunResult Thread::DoSimdBitmask() {
auto val = Pop<S>();
u32 result = 0;
for (u8 i = 0; i < S::lanes; ++i) {
if (val[i] < 0) {
result |= 1 << i;
}
}
Push(result);
return RunResult::Ok;
} | pushq %rbx
movq %rdi, %rbx
callq 0x9b0ac
movq %rdx, %xmm0
movq %rax, %xmm1
punpcklqdq %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
psrad $0x1f, %xmm1
pand 0x21a50(%rip), %xmm1 # 0xb4830
pshufd $0xee, %xmm1, %xmm0 # xmm0 = xmm1[2,3,2,3]
por %xmm1, %xmm0
pshufd $0x55, %xmm0, %xmm1 # xmm1 = xmm0[1,1,1,1]
por %xmm0,... | /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::RunResult wabt::interp::Thread::DoSimdShift<unsigned int, unsigned int>(unsigned int (*)(unsigned int, unsigned int)) | RunResult Thread::DoSimdShift(BinopFunc<R, T> f) {
using ST = typename Simd128<T>::Type;
using SR = typename Simd128<R>::Type;
static_assert(ST::lanes == SR::lanes, "SIMD lanes don't match");
auto amount = Pop<u32>();
auto lhs = Pop<ST>();
SR result;
for (u8 i = 0; i < SR::lanes; ++i) {
result[i] = f(... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x90562
movl %eax, %ebp
movq %rbx, %rdi
callq 0x9b126
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
xorl %r15d, %r15d
movl 0x18(%rsp,%r15,4), %edi
movl %ebp, %esi
callq *%r14
movl %eax, 0x8(%rsp,%r15,4)
incq %r15
cmpq $0x4,... | /dcodeIO[P]wabt/src/interp/interp.cc |
wabt::interp::RunResult wabt::interp::Thread::DoSimdLoadSplat<wabt::interp::Simd<unsigned int, (unsigned char)4>, unsigned int>(wabt::interp::Instr, wabt::interp::RefPtr<wabt::interp::Trap>*) | RunResult Thread::DoSimdLoadSplat(Instr instr, Trap::Ptr* out_trap) {
using L = typename S::LaneType;
L val;
if (Load<L>(instr, &val, out_trap) != RunResult::Ok) {
return RunResult::Trap;
}
S result;
std::fill(std::begin(result.v), std::end(result.v), val);
Push(result);
return RunResult::Ok;
} | pushq %rbx
subq $0x20, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movdqa 0x30(%rsp), %xmm0
movdqu %xmm0, (%rsp)
leaq 0x1c(%rsp), %rsi
callq 0x99f40
movl %eax, %ecx
movl $0x2, %eax
testl %ecx, %ecx
jne 0x9329a
movd 0x1c(%rsp), %xmm0
pshufd $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0... | /dcodeIO[P]wabt/src/interp/interp.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.