name string | code string | asm string | file string |
|---|---|---|---|
ImGui::GetColumnOffset(int) | float ImGui::GetColumnOffset(int column_index)
{
ImGuiWindow* window = GetCurrentWindowRead();
ImGuiOldColumns* columns = window->DC.CurrentColumns;
if (columns == NULL)
return 0.0f;
if (column_index < 0)
column_index = columns->Current;
IM_ASSERT(column_index < columns->Columns.Siz... | pushq %rax
leaq 0x95cb5(%rip), %rax # 0x12f138
movq (%rax), %rax
movq 0x3fe0(%rax), %rax
movq 0x1c0(%rax), %rax
testq %rax, %rax
je 0x994d3
testl %edi, %edi
jns 0x994a0
movl 0xc(%rax), %edi
cmpl 0x60(%rax), %edi
jge 0x994d8
testl %edi, %edi
js 0x994f7
movq 0x68(%rax), %rcx
movl %edi, %edx
leaq (%rdx,%rdx,8), %rsi
l... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_tables.cpp |
ImGui::SetColumnOffset(int, float) | void ImGui::SetColumnOffset(int column_index, float offset)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
ImGuiOldColumns* columns = window->DC.CurrentColumns;
IM_ASSERT(columns != NULL);
if (column_index < 0)
column_index = columns->Current;
IM_ASSERT(column_index... | pushq %rbx
leaq 0x95b86(%rip), %rax # 0x12f138
movq (%rax), %rcx
movq 0x3fe0(%rcx), %rdx
movq 0x1c0(%rdx), %rdx
testq %rdx, %rdx
je 0x99768
testl %edi, %edi
jns 0x995d3
movl 0xc(%rdx), %edi
movl 0x60(%rdx), %r10d
cmpl %r10d, %edi
jge 0x99787
movl 0x4(%rdx), %r8d
testb $0x4, %r8b
jne 0x995f7
movl 0x10(%rdx), %esi
de... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_tables.cpp |
ImGui::PushColumnClipRect(int) | inline ImGuiWindow* GetCurrentWindowRead() { ImGuiContext& g = *GImGui; return g.CurrentWindow; } | leaq 0x95923(%rip), %rax # 0x12f138
movq (%rax), %rax
movq 0x3fe0(%rax), %rax
movq 0x1c0(%rax), %rax
testl %edi, %edi
jns 0x9982d
movl 0xc(%rax), %edi
testl %edi, %edi
js 0x9985e
cmpl %edi, 0x60(%rax)
jle 0x9985e
movq 0x68(%rax), %rax
movl %edi, %ecx
leaq (%rcx,%rcx,8), %rdx
leaq (%rdx,%rdx,2), %rdx
addq %rcx, %rdx... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_internal.h |
ImGui::PopColumnsBackground() | inline ImGuiWindow* GetCurrentWindowRead() { ImGuiContext& g = *GImGui; return g.CurrentWindow; } | leaq 0x9583d(%rip), %rax # 0x12f138
movq (%rax), %rax
movq 0x3fe0(%rax), %rax
movq 0x1c0(%rax), %rdi
cmpl $0x1, 0x10(%rdi)
jne 0x99913
retq
movsd 0x3c(%rdi), %xmm0
movhps 0x44(%rdi), %xmm0 # xmm0 = xmm0[0,1],mem[0,1]
movups 0x3c(%rdi), %xmm1
movups %xmm1, 0x250(%rax)
movq 0x2b8(%rax), %rcx
movups %xmm0, 0x88(... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_internal.h |
ImGui::FindOrCreateColumns(ImGuiWindow*, unsigned int) | ImGuiOldColumns* ImGui::FindOrCreateColumns(ImGuiWindow* window, ImGuiID id)
{
// We have few columns per window so for now we don't need bother much with turning this into a faster lookup.
for (int n = 0; n < window->ColumnsStorage.Size; n++)
if (window->ColumnsStorage[n].ID == id)
return &... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %esi, %ebx
movq %rdi, %r14
movslq 0x298(%rdi), %r12
testq %r12, %r12
setg %cl
jle 0x999bc
movq 0x2a0(%r14), %rax
cmpl %ebx, (%rax)
je 0x999c1
movl $0x1, %ecx
cmpq %rcx, %r12
je 0x999be
leaq 0x88(%rax), %rdx
incq %rcx
cmpl %ebx, 0x88(%rax)
movq %rdx, %rax... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_tables.cpp |
ImGui::GetColumnsID(char const*, int) | ImGuiID ImGui::GetColumnsID(const char* str_id, int columns_count)
{
ImGuiWindow* window = GetCurrentWindow();
// Differentiate column ID with an arbitrary prefix for cases where users name their columns set the same as another widget.
// In addition, when an identifier isn't explicitly provided we include... | pushq %r14
pushq %rbx
pushq %rax
leaq 0x95600(%rip), %rax # 0x12f138
movq (%rax), %rax
movq 0x3fe0(%rax), %rbx
movb $0x1, 0xcd(%rbx)
movl $0x11223347, %ecx # imm = 0x11223347
leal (%rsi,%rcx), %eax
testq %rdi, %rdi
cmovnel %ecx, %eax
leaq 0x5e24b(%rip), %r14 # 0xf7da9
cmovneq %rdi, %r14
movl %eax, %edi
ca... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_tables.cpp |
ImGuiTableTempData::~ImGuiTableTempData() | struct IMGUI_API ImGuiTableTempData
{
int TableIndex; // Index in g.Tables.Buf[] pool
float LastTimeActive; // Last timestamp this structure was used
ImVec2 UserOuterSize; // outer_size.x passed to B... | pushq %rbx
movq %rdi, %rbx
addq $0x10, %rdi
callq 0x7f2fa
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x9a96d
callq 0x4a49e
popq %rbx
retq
jmp 0x9a971
movq %rax, %rdi
callq 0xf024
nop
| /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_internal.h |
ImBitArray<132, 0>::SetBitRange(int, int) | void SetBitRange(int n, int n2) { n += OFFSET; n2 += OFFSET; IM_ASSERT(n >= 0 && n < BITCOUNT && n2 > n && n2 <= BITCOUNT); ImBitArraySetBitRange(Storage, n, n2); } | cmpl $0x83, %esi
ja 0x9aa49
cmpl %esi, %edx
jle 0x9aa49
cmpl $0x85, %edx
jge 0x9aa49
leal -0x1(%rdx), %eax
movl %eax, %r8d
andl $0x1f, %r8d
incl %r8d
movl $0x20, %r9d
movl %esi, %ecx
orl $0x1f, %ecx
cmpl %ecx, %eax
movl %r8d, %ecx
cmovgl %r9d, %ecx
movq $-0x1, %r10
shlq %cl, %r10
notl %r10d
movl %esi, %ecx
shrl %cl, %r... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_internal.h |
ImChunkStream<ImGuiTableSettings>::alloc_chunk(unsigned long) | T* alloc_chunk(size_t sz) { size_t HDR_SZ = 4; sz = IM_MEMALIGN(HDR_SZ + sz, 4u); int off = Buf.Size; Buf.resize(off + (int)sz); ((int*)(void*)(Buf.Data + off))[0] = (int)sz; return (T*)(void*)(Buf.Data + off + (int)HDR_SZ); } | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movslq (%rdi), %r12
addl $0x7, %ebx
andl $-0x4, %ebx
leal (%r12,%rbx), %ebp
movl 0x4(%rdi), %eax
cmpl %ebp, %eax
jge 0x9ab57
testl %eax, %eax
je 0x9ab15
movl %eax, %r13d
shrl $0x1f, %r13d
addl %eax, %r13d
sarl %... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_internal.h |
ImPool<ImGuiTable>::Add() | T* Add() { int idx = FreeIdx; if (idx == Buf.Size) { Buf.resize(Buf.Size + 1); FreeIdx++; } else { FreeIdx = *(int*)&Buf[idx]; } IM_PLACEMENT_NEW(&Buf[idx]) T(); AliveCount++; return &Buf[idx]; } | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %ecx
movl 0x20(%rdi), %r15d
cmpl %ecx, %r15d
jne 0x9ac38
leal 0x1(%rcx), %ebp
movl 0x4(%rbx), %eax
cmpl %ecx, %eax
jg 0x9acaa
testl %eax, %eax
je 0x9ac5a
movl %eax, %r12d
shrl $0x1f, %r12d
addl %eax, %r12d
sarl %r12d
addl %eax, %r12d
jm... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_internal.h |
ImGui::TextColoredV(ImVec4 const&, char const*, __va_list_tag*) | void ImGui::TextColoredV(const ImVec4& col, const char* fmt, va_list args)
{
PushStyleColor(ImGuiCol_Text, col);
if (fmt[0] == '%' && fmt[1] == 's' && fmt[2] == 0)
TextEx(va_arg(args, const char*), NULL, ImGuiTextFlags_NoWidthForLargeClippedText); // Skip formatting
else
TextV(fmt, args);
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rsi
xorl %edi, %edi
callq 0x4d27c
cmpb $0x25, (%r14)
jne 0x9b3c6
cmpb $0x73, 0x1(%r14)
jne 0x9b3c6
cmpb $0x0, 0x2(%r14)
je 0x9b3e2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x9b2b2
movl $0x1, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4d3b0
mo... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
ImGui::TextWrappedV(char const*, __va_list_tag*) | void ImGui::TextWrappedV(const char* fmt, va_list args)
{
ImGuiContext& g = *GImGui;
bool need_backup = (g.CurrentWindow->DC.TextWrapPos < 0.0f); // Keep existing wrap position if one is already set
if (need_backup)
PushTextWrapPos(0.0f);
if (fmt[0] == '%' && fmt[1] == 's' && fmt[2] == 0)
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x93b7f(%rip), %rax # 0x12f138
movq (%rax), %rax
movq 0x3fe0(%rax), %rax
movss 0x1d8(%rax), %xmm1
xorps %xmm0, %xmm0
movss %xmm1, 0x4(%rsp)
ucomiss %xmm1, %xmm0
jbe 0x9b5de
callq 0x63ea7
cmpb $0x25, (%r14)
jne 0x9b5f2
cmpb $0x73, 0x1(%r14)
jne 0x... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
ImGui::ButtonBehavior(ImRect const&, unsigned int, bool*, bool*, int) | bool ImGui::ButtonBehavior(const ImRect& bb, ImGuiID id, bool* out_hovered, bool* out_held, ImGuiButtonFlags flags)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = GetCurrentWindow();
// Default only reacts to left mouse button
if ((flags & ImGuiButtonFlags_MouseButtonMask_) == 0)
flags |= I... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movl %esi, %r12d
leaq 0x93606(%rip), %rax # 0x12f138
movq (%rax), %r14
movq 0x3fe0(%r14), %rdx
movb $0x1, 0xcd(%rdx)
xorl %eax, %eax
testb $0x7, %r8b
sete %al
leal (%rax,%r8), %r15d
addl $0... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
ImGui::SmallButton(char const*) | bool ImGui::SmallButton(const char* label)
{
ImGuiContext& g = *GImGui;
float backup_padding_y = g.Style.FramePadding.y;
g.Style.FramePadding.y = 0.0f;
bool pressed = ButtonEx(label, ImVec2(0, 0), ImGuiButtonFlags_AlignTextBaseLine);
g.Style.FramePadding.y = backup_padding_y;
return pressed;
} | pushq %rbx
subq $0x10, %rsp
leaq 0x92db4(%rip), %rax # 0x12f138
movq (%rax), %rbx
movss 0x3948(%rbx), %xmm0
movss %xmm0, 0x4(%rsp)
movl $0x0, 0x3948(%rbx)
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
movl $0x8000, %edx # imm = 0x8000
callq 0x9c0ff
movss 0x4(%rsp), %xmm0
movss %xmm0, 0x3948(%rbx)
addq $0x10, %rs... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
ImGui::Combo(char const*, int*, bool (*)(void*, int, char const**), void*, int, int) | bool ImGui::Combo(const char* label, int* current_item, bool (*items_getter)(void*, int, const char**), void* data, int items_count, int popup_max_height_in_items)
{
ImGuiContext& g = *GImGui;
// Call the getter to obtain the preview string which is a parameter to BeginCombo()
const char* preview_value = N... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, %ebp
movl %r8d, %ebx
movq %rcx, 0x10(%rsp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
leaq 0x8f846(%rip), %r14 # 0x12f138
movq (%r14), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x18(%rsp)
movl (%rsi), %esi
testl %esi, %esi... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
ImGui::Combo(char const*, int*, char const*, int) | bool ImGui::Combo(const char* label, int* current_item, const char* items_separated_by_zeros, int height_in_items)
{
int items_count = 0;
const char* p = items_separated_by_zeros; // FIXME-OPT: Avoid computing this, or at least only when combo is open
while (*p)
{
p += strlen(p) + 1;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
cmpb $0x0, (%rdx)
je 0x9fff3
xorl %ebp, %ebp
movq %r14, %r13
movq %r13, %rdi
callq 0xc3c0
addq %rax, %r13
incq %r13
incl %ebp
cmpb $0x0, (%r13)
jne 0x9ffda
jmp 0x9fff5
xorl %ebp, ... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
ImGui::DataTypeCompare(int, void const*, void const*) | int ImGui::DataTypeCompare(ImGuiDataType data_type, const void* arg_1, const void* arg_2)
{
switch (data_type)
{
case ImGuiDataType_S8: return DataTypeCompareT<ImS8 >((const ImS8* )arg_1, (const ImS8* )arg_2);
case ImGuiDataType_U8: return DataTypeCompareT<ImU8 >((const ImU8* )arg_1, (const... | cmpl $0x9, %edi
ja 0xa0779
movl %edi, %eax
leaq 0x57ff8(%rip), %rcx # 0xf86f0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb (%rsi), %al
cmpb (%rdx), %al
jmp 0xa0752
movl (%rsi), %eax
cmpl (%rdx), %eax
jmp 0xa0752
movsd (%rsi), %xmm0
movsd (%rdx), %xmm1
ucomisd %xmm0, %xmm1
seta %al
ucomisd %xmm1, %xmm0... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
ImGui::DragBehavior(unsigned int, int, void*, float, void const*, void const*, char const*, int) | bool ImGui::DragBehavior(ImGuiID id, ImGuiDataType data_type, void* p_v, float v_speed, const void* p_min, const void* p_max, const char* format, ImGuiSliderFlags flags)
{
// Read imgui.cpp "API BREAKING CHANGES" section for 1.78 if you hit this assert.
IM_ASSERT((flags == 1 || (flags & ImGuiSliderFlags_Invalid... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r11
movl 0x50(%rsp), %r10d
cmpl $0x1, %r10d
setne %al
testl $0x7000000f, %r10d # imm = 0x7000000F
setne %cl
testb %cl, %al
jne 0xa0d2e
movq %rdx, %r15
movl %esi, %r13d
movl %edi, %r14d
leaq 0x8e7b9(%rip), %rax # 0x12... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
ImGui::DragFloatRange2(char const*, float*, float*, float, float, float, char const*, char const*, int) | bool ImGui::DragFloatRange2(const char* label, float* v_current_min, float* v_current_max, float v_speed, float v_min, float v_max, const char* format, const char* format_max, ImGuiSliderFlags flags)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return false;
ImGuiContext& g = ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movss %xmm0, 0x18(%rsp)
leaq 0x8d9a8(%rip), %rax # 0x12f138
movq (%rax), %r12
movq 0x3fe0(%r12), %rax
movb $0x1, 0xcd(%rax)
cmpb $0x0, 0xd0(%rax)
je 0xa17b3
xorl %r13d, %r13d
jmp 0xa1946
movl %r9d, %ebp
movq %rcx, %r14
movq %rdx, %r1... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
ImStb::stb_textedit_paste(ImGuiInputTextState*, ImStb::STB_TexteditState*, unsigned short const*, int) | static int stb_textedit_paste(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, STB_TEXTEDIT_CHARTYPE const *ctext, int len)
{
return stb_textedit_paste_internal(str, state, (STB_TEXTEDIT_CHARTYPE *) ctext, len);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
callq 0xa7d97
movq %r12, %rdi
movq %r14, %rsi
callq 0xb2c3b
movl (%r14), %esi
movq %r12, %rdi
movq %r15, %rdx
movl %ebx, %ecx
callq 0xb2a48
testb %al, %al
je 0xa809f
movl (%r14), %esi
leaq 0x20(%r14), ... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imstb_textedit.h |
InputTextCalcTextSizeW(unsigned short const*, unsigned short const*, unsigned short const**, ImVec2*, bool) | static ImVec2 InputTextCalcTextSizeW(const ImWchar* text_begin, const ImWchar* text_end, const ImWchar** remaining, ImVec2* out_offset, bool stop_on_new_line)
{
ImGuiContext& g = *GImGui;
ImFont* font = g.Font;
const float line_height = g.FontSize;
const float scale = line_height / font->FontSize;
... | leaq 0x87086(%rip), %rax # 0x12f138
movq (%rax), %r8
movq 0x3d48(%r8), %rax
movss 0x3d50(%r8), %xmm0
movaps %xmm0, %xmm3
divss 0x14(%rax), %xmm3
leaq 0x10(%rax), %r8
xorps %xmm2, %xmm2
xorps %xmm1, %xmm1
cmpq %rsi, %rdi
jae 0xa8142
movzwl (%rdi), %r9d
cmpl $0xd, %r9d
je 0xa8136
cmpl $0xa, %r9d
jne 0xa8116
movaps %x... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
ColorEditRestoreHS(float const*, float*, float*, float*) | static void ColorEditRestoreHS(const float* col, float* H, float* S, float* V)
{
// This check is optional. Suppose we have two color widgets side by side, both widgets display different colors, but both colors have hue and/or saturation undefined.
// With color check: hue/saturation is preserved in one widget.... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
leaq 0x85f5b(%rip), %rax # 0x12f138
movq (%rax), %r12
movl 0x5480(%r12), %ebp
movq (%rdi), %rax
movss 0x8(%rdi), %xmm0
movq %rsp, %rdi
movq %rax, (%rdi)
movss %xmm0, 0x8(%rdi)
movl $0x0, 0xc(%rdi)... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
RenderArrowsForVerticalBar(ImDrawList*, ImVec2, ImVec2, float, float) | static void RenderArrowsForVerticalBar(ImDrawList* draw_list, ImVec2 pos, ImVec2 half_sz, float bar_w, float alpha)
{
ImU32 alpha8 = IM_F32_TO_INT8_SAT(alpha);
ImGui::RenderArrowPointingAt(draw_list, ImVec2(pos.x + half_sz.x + 1, pos.y), ImVec2(half_sz.x + 2, half_sz.y + 1), ImGuiDir_Right, IM_COL32(0,0... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movaps %xmm2, 0x20(%rsp)
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, %xmm2
movq %rdi, %rbx
movss 0x2bc7e(%rip), %xmm0 # 0xd73fc
movaps %xmm2, %xmm5
movaps %xmm2, %xmm6
movaps %xmm2, (%rsp)
addps %xmm1, %xmm5
movaps %xmm5, 0x40(%rsp)
addss %xmm0, %xmm5
movaps %xmm1, %xmm2
... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
ImGui::ColorTooltip(char const*, float const*, int) | void ImGui::ColorTooltip(const char* text, const float* col, ImGuiColorEditFlags flags)
{
ImGuiContext& g = *GImGui;
BeginTooltipEx(ImGuiTooltipFlags_OverridePreviousTooltip, ImGuiWindowFlags_None);
const char* text_end = text ? FindRenderedTextEnd(text, NULL) : text;
if (text_end > text)
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8389a(%rip), %rax # 0x12f138
movq (%rax), %r13
xorl %r15d, %r15d
movl $0x1, %edi
xorl %esi, %esi
callq 0x675cf
testq %r14, %r14
je 0xab8c2
movq %r14, %rdi
xorl %esi, %esi
callq 0... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
ImGui::SetColorEditOptions(int) | void ImGui::SetColorEditOptions(ImGuiColorEditFlags flags)
{
ImGuiContext& g = *GImGui;
if ((flags & ImGuiColorEditFlags_DisplayMask_) == 0)
flags |= ImGuiColorEditFlags_DefaultOptions_ & ImGuiColorEditFlags_DisplayMask_;
if ((flags & ImGuiColorEditFlags_DataTypeMask_) == 0)
flags |= ImGuiCo... | pushq %rax
movl %edi, %eax
orl $0x100000, %eax # imm = 0x100000
testl $0x700000, %edi # imm = 0x700000
cmovnel %edi, %eax
movl %eax, %ecx
orl $0x800000, %ecx # imm = 0x800000
testl $0x1800000, %eax # imm = 0x1800000
cmovnel %eax, %ecx
movl %ecx, %edx
orl $0x2000000, %edx # imm = 0x... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
ImGui::TreeNodeBehaviorIsOpen(unsigned int, int) | bool ImGui::TreeNodeBehaviorIsOpen(ImGuiID id, ImGuiTreeNodeFlags flags)
{
if (flags & ImGuiTreeNodeFlags_Leaf)
return true;
// We only write to the tree storage if the user clicks (or explicitly use the SetNextItemOpen function)
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movb $0x1, %bpl
btl $0x8, %esi
jb 0xac8e7
movl %esi, %ebx
movl %edi, %r14d
leaq 0x828f5(%rip), %rax # 0x12f138
movq (%rax), %r12
movq 0x3fe0(%r12), %r13
movq 0x1b8(%r13), %r15
testb $0x2, 0x409c(%r12)
jne 0xac875
movl %ebx, %edx
shrl $0x5,... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
ImGui::SetNextItemOpen(bool, int) | void ImGui::SetNextItemOpen(bool is_open, ImGuiCond cond)
{
ImGuiContext& g = *GImGui;
if (g.CurrentWindow->SkipItems)
return;
g.NextItemData.Flags |= ImGuiNextItemDataFlags_HasOpen;
g.NextItemData.OpenVal = is_open;
g.NextItemData.OpenCond = cond ? cond : ImGuiCond_Always;
} | leaq 0x82676(%rip), %rax # 0x12f138
movq (%rax), %rax
movq 0x3fe0(%rax), %rcx
cmpb $0x0, 0xd0(%rcx)
jne 0xacaef
orb $0x2, 0x409c(%rax)
movb %dil, 0x40ac(%rax)
cmpl $0x1, %esi
adcl $0x0, %esi
movl %esi, 0x40a8(%rax)
retq
| /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/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 0x825dd(%rip), %r13 # 0x12f138
movq (%r13), %rax
movq 0x3fe0(%rax), %rdi
movb $0x1, 0xcd(%rdi)
cmpb $0x0, 0xd0(%rdi)
jne 0xacb8b
movl %edx, %ebp
movq %rsi, %rbx
testq %rsi, %rsi
je 0xacb92
movl $0x10001e, %r12d ... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
ImGui::ListBoxHeader(char const*, int, int) | bool ImGui::ListBoxHeader(const char* label, int items_count, int height_in_items)
{
// If height_in_items == -1, default height is maximum 7.
ImGuiContext& g = *GImGui;
float height_in_items_f = (height_in_items < 0 ? ImMin(items_count, 7) : height_in_items) + 0.25f;
ImVec2 size;
size.x = 0.0f;
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x7, %esi
movl $0x7, %eax
cmovll %esi, %eax
leaq 0x821be(%rip), %rcx # 0x12f138
testl %edx, %edx
cmovnsl %edx, %eax
movq (%rcx), %r15
cvtsi2ss %eax, %xmm0
addss 0x3567a(%rip), %xmm0 # 0xe2608
movss %xmm0, 0x4(%rsp)
leaq 0x8(%rsp), %r14
movq ... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
ImGui::EndListBox() | void ImGui::EndListBox()
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
IM_ASSERT((window->Flags & ImGuiWindowFlags_ChildWindow) && "Mismatched BeginListBox/EndListBox calls. Did you test the return value of BeginListBox?");
IM_UNUSED(window);
EndChildFrame();
EndGroup(); /... | pushq %rax
leaq 0x82159(%rip), %rax # 0x12f138
movq (%rax), %rax
movq 0x3fe0(%rax), %rax
testb $0x1, 0xf(%rax)
je 0xacffa
callq 0x610ce
popq %rax
jmp 0x66258
leaq 0x4d206(%rip), %rdi # 0xfa207
leaq 0x4b880(%rip), %rsi # 0xf8888
leaq 0x4d285(%rip), %rcx # 0xfa294
movl $0x18e3, %edx # imm = 0x18... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
ImGui::PlotEx(ImGuiPlotType, char const*, float (*)(void*, int), void*, int, int, char const*, float, float, ImVec2) | int ImGui::PlotEx(ImGuiPlotType plot_type, const char* label, float (*values_getter)(void* data, int idx), void* data, int values_count, int values_offset, const char* overlay_text, float scale_min, float scale_max, ImVec2 frame_size)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = GetCurrentWindow();
if... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %r9, 0x30(%rsp)
movq %rcx, 0x58(%rsp)
leaq 0x81f4e(%rip), %rax # 0x12f138
movq (%rax), %r13
movq 0x3fe0(%r13), %rbx
movb $0x1, 0xcd(%rbx)
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
cmpb $0x0, 0xd0(... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
ImGuiMenuColumns::Update(float, bool) | void ImGuiMenuColumns::Update(float spacing, bool window_reappearing)
{
if (window_reappearing)
memset(Widths, 0, sizeof(Widths));
Spacing = (ImU16)spacing;
CalcNextTotalWidth(true);
memset(Widths, 0, sizeof(Widths));
TotalWidth = NextTotalWidth;
NextTotalWidth = 0;
} | pushq %rbx
movq %rdi, %rbx
testl %esi, %esi
je 0xadce4
movq $0x0, 0x12(%rbx)
cvttss2si %xmm0, %eax
movw %ax, 0x8(%rbx)
movq %rbx, %rdi
movl $0x1, %esi
callq 0xadd10
movq $0x0, 0x12(%rbx)
movl 0x4(%rbx), %eax
movl %eax, (%rbx)
movl $0x0, 0x4(%rbx)
popq %rbx
retq
nop
| /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
ImGuiMenuColumns::DeclColumns(float, float, float, float) | static inline T ImMin(T lhs, T rhs) { return lhs < rhs ? lhs : rhs; } | movzwl 0x12(%rdi), %eax
cvttss2si %xmm0, %ecx
cmpw %cx, %ax
cmoval %eax, %ecx
movw %cx, 0x12(%rdi)
movl 0x14(%rdi), %eax
cvttss2si %xmm1, %ecx
cmpw %cx, %ax
cmoval %eax, %ecx
movw %cx, 0x14(%rdi)
movzwl 0x16(%rdi), %eax
cvttss2si %xmm2, %ecx
cmpw %cx, %ax
cmoval %eax, %ecx
movw %cx, 0x16(%rdi)
movl 0x18(%rdi), %eax
cvt... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_internal.h |
ImGui::BeginViewportSideBar(char const*, ImGuiViewport*, int, float, int) | bool ImGui::BeginViewportSideBar(const char* name, ImGuiViewport* viewport_p, ImGuiDir dir, float axis_size, ImGuiWindowFlags window_flags)
{
IM_ASSERT(dir != ImGuiDir_None);
ImGuiWindow* bar_window = FindWindowByName(name);
ImGuiViewportP* viewport = (ImGuiViewportP*)(void*)(viewport_p ? viewport_p : GetM... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movss %xmm0, 0x4(%rsp)
cmpl $-0x1, %edx
je 0xae420
movl %ecx, %ebx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
callq 0x610e6
movq %rax, %r12
testq %r15, %r15
jne 0xae258
callq 0x5ee9f
movq %rax, %r15
testq %r12, %r12
je 0xae26d
cmpw ... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
ImGui::BeginTabBar(char const*, int) | bool ImGui::BeginTabBar(const char* str_id, ImGuiTabBarFlags flags)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
if (window->SkipItems)
return false;
ImGuiID id = window->GetID(str_id);
ImGuiTabBar* tab_bar = g.TabBars.GetOrAddByKey(id);
ImRect tab_bar_bb = ImR... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x7fd41(%rip), %rax # 0x12f138
movq (%rax), %r15
movq 0x3fe0(%r15), %r14
cmpb $0x0, 0xd0(%r14)
je 0xaf412
xorl %eax, %eax
jmp 0xaf497
movl %esi, %ebx
movq %rdi, %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x4f0c6
movl %eax, %ebp
leaq 0x4528(%r15), %rd... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
ImGui::BeginTabBarEx(ImGuiTabBar*, ImRect const&, int, ImGuiDockNode*) | bool ImGui::BeginTabBarEx(ImGuiTabBar* tab_bar, const ImRect& tab_bar_bb, ImGuiTabBarFlags flags, ImGuiDockNode* dock_node)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
if (window->SkipItems)
return false;
if ((flags & ImGuiTabBarFlags_DockNode) == 0)
PushOverr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq 0x7fc81(%rip), %r13 # 0x12f138
movq (%r13), %r12
movq 0x3fe0(%r12), %r15
movb 0xd0(%r15), %bl
testb %bl, %bl
jne 0xaf7e7
movl %edx, %ebp
movq %rdi, %r14
movq %rsi, 0x18(%rsp)
movq %rcx, 0x20(%rsp)
btl $0x14, %edx
jb 0xaf4f0
movl... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
ImGui::EndTabBar() | void ImGui::EndTabBar()
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
if (window->SkipItems)
return;
ImGuiTabBar* tab_bar = g.CurrentTabBar;
if (tab_bar == NULL)
{
IM_ASSERT_USER_ERROR(tab_bar != NULL, "Mismatched BeginTabBar()/EndTabBar()!");
re... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x7f923(%rip), %r15 # 0x12f138
movq (%r15), %r14
movq 0x3fe0(%r14), %r12
cmpb $0x0, 0xd0(%r12)
jne 0xaf94c
movq 0x4520(%r14), %rbx
testq %rbx, %rbx
je 0xaf958
cmpb $0x1, 0x6b(%rbx)
jne 0xaf84c
movq %rbx, %rdi
callq 0xaf9d4
cmpb $0x0, 0x6c(%rbx)
je 0xaf890
... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
ImGui::TabBarRemoveTab(ImGuiTabBar*, unsigned int) | void ImGui::TabBarRemoveTab(ImGuiTabBar* tab_bar, ImGuiID tab_id)
{
if (ImGuiTabItem* tab = TabBarFindTabByID(tab_bar, tab_id))
tab_bar->Tabs.erase(tab);
if (tab_bar->VisibleTabId == tab_id) { tab_bar->VisibleTabId = 0; }
if (tab_bar->SelectedTabId == tab_id) { tab_bar->SelectedTabId = 0; }... | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
testl %esi, %esi
je 0xb0ca2
movslq (%rbx), %rax
testq %rax, %rax
setg %cl
jle 0xb0c90
movq 0x8(%rbx), %rdi
movb $0x1, %cl
cmpl %ebp, (%rdi)
je 0xb0c9e
leaq (%rax,%rax,2), %rcx
shlq $0x4, %rcx
addq %rdi, %rcx
addq $-0x30, %rcx
movl $0x1, %r8d
movq %r8, %rd... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
ImGui::TabBarCloseTab(ImGuiTabBar*, ImGuiTabItem*) | void ImGui::TabBarCloseTab(ImGuiTabBar* tab_bar, ImGuiTabItem* tab)
{
IM_ASSERT(!(tab->Flags & ImGuiTabItemFlags_Button));
if (!(tab->Flags & ImGuiTabItemFlags_UnsavedDocument))
{
// This will remove a frame of lag for selecting another tab on closure.
// However we don't run it in the case ... | movl 0x4(%rsi), %eax
btl $0x15, %eax
jb 0xb0d73
testb $0x1, %al
jne 0xb0d68
movb $0x1, 0x2c(%rsi)
movl 0x20(%rdi), %eax
cmpl (%rsi), %eax
jne 0xb0d72
movl $0xffffffff, 0x10(%rsi) # imm = 0xFFFFFFFF
movq $0x0, 0x18(%rdi)
retq
movl (%rsi), %eax
cmpl %eax, 0x20(%rdi)
je 0xb0d72
movl %eax, 0x1c(%rdi)
retq
pushq %rax
leaq 0... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
ImGui::TabBarQueueReorder(ImGuiTabBar*, ImGuiTabItem const*, int) | void ImGui::TabBarQueueReorder(ImGuiTabBar* tab_bar, const ImGuiTabItem* tab, int offset)
{
IM_ASSERT(offset != 0);
IM_ASSERT(tab_bar->ReorderRequestTabId == 0);
tab_bar->ReorderRequestTabId = tab->ID;
tab_bar->ReorderRequestOffset = (ImS16)offset;
} | pushq %rax
testl %edx, %edx
je 0xb0da9
cmpl $0x0, 0x64(%rdi)
jne 0xb0dc8
movl (%rsi), %eax
movl %eax, 0x64(%rdi)
movw %dx, 0x68(%rdi)
popq %rax
retq
leaq 0x4985a(%rip), %rdi # 0xfa60a
leaq 0x47ad1(%rip), %rsi # 0xf8888
leaq 0x49858(%rip), %rcx # 0xfa616
movl $0x1e2e, %edx # imm = 0x1E2E
callq 0xc5... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
ImGui::TabBarQueueReorderFromMousePos(ImGuiTabBar*, ImGuiTabItem const*, ImVec2) | void ImGui::TabBarQueueReorderFromMousePos(ImGuiTabBar* tab_bar, const ImGuiTabItem* src_tab, ImVec2 mouse_pos)
{
ImGuiContext& g = *GImGui;
IM_ASSERT(tab_bar->ReorderRequestTabId == 0);
if ((tab_bar->Flags & ImGuiTabBarFlags_Reorderable) == 0)
return;
const bool is_central_section = (src_tab->... | pushq %rbp
pushq %r14
pushq %rbx
cmpl $0x0, 0x64(%rdi)
jne 0xb0f19
testb $0x1, 0x10(%rdi)
je 0xb0f0b
movl 0x4(%rsi), %eax
movss 0x2c(%rdi), %xmm1
xorps %xmm2, %xmm2
testb $-0x40, %al
jne 0xb0e13
movss 0x50(%rdi), %xmm2
subss %xmm2, %xmm1
movss 0x18(%rsi), %xmm2
addss %xmm1, %xmm2
xorl %r11d, %r11d
ucomiss %xmm0, %xmm2
... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
ImGui::TabBarProcessReorder(ImGuiTabBar*) | bool ImGui::TabBarProcessReorder(ImGuiTabBar* tab_bar)
{
ImGuiTabItem* tab1 = TabBarFindTabByID(tab_bar, tab_bar->ReorderRequestTabId);
if (tab1 == NULL || (tab1->Flags & ImGuiTabItemFlags_NoReorder))
return false;
//IM_ASSERT(tab_bar->Flags & ImGuiTabBarFlags_Reorderable); // <- this may happen wh... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movl 0x64(%rdi), %ecx
testl %ecx, %ecx
je 0xb0fc2
movslq (%rbx), %rax
testq %rax, %rax
setg %dl
jle 0xb0fb0
movq 0x8(%rbx), %r14
movb $0x1, %dl
cmpl %ecx, (%r14)
je 0xb0fbe
leaq (%rax,%rax,2), %rdx
shlq $0x4, %rdx
addq %r14, %rdx
addq $-0x30, %rdx
movl $... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
ImGui::BeginTabItem(char const*, bool*, int) | bool ImGui::BeginTabItem(const char* label, bool* p_open, ImGuiTabItemFlags flags)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
if (window->SkipItems)
return false;
ImGuiTabBar* tab_bar = g.CurrentTabBar;
if (tab_bar == NULL)
{
IM_ASSERT_USER_ERROR(tab_... | pushq %rbp
pushq %r14
pushq %rbx
leaq 0x7e0a8(%rip), %rax # 0x12f138
movq (%rax), %rax
movq 0x3fe0(%rax), %rcx
cmpb $0x0, 0xd0(%rcx)
je 0xb10a7
xorl %ebx, %ebx
jmp 0xb1101
movq 0x4520(%rax), %r14
testq %r14, %r14
je 0xb1108
movl %edx, %ebp
btl $0x15, %edx
jb 0xb1127
movq %rsi, %rdx
movq %rdi, %rsi
movq %r14, %rdi
m... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
ImGui::EndTabItem() | void ImGui::EndTabItem()
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
if (window->SkipItems)
return;
ImGuiTabBar* tab_bar = g.CurrentTabBar;
if (tab_bar == NULL)
{
IM_ASSERT_USER_ERROR(tab_bar != NULL, "Needs to be called between BeginTabBar() and EndTa... | pushq %rax
leaq 0x7d32a(%rip), %rax # 0x12f138
movq (%rax), %rax
movq 0x3fe0(%rax), %rcx
cmpb $0x0, 0xd0(%rcx)
jne 0xb1e55
movq 0x4520(%rax), %rax
testq %rax, %rax
je 0xb1e57
movswl 0x70(%rax), %ecx
testl %ecx, %ecx
js 0xb1e76
cmpl %ecx, (%rax)
jle 0xb1e95
movq 0x8(%rax), %rax
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), ... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
ImGui::TabItemButton(char const*, int) | bool ImGui::TabItemButton(const char* label, ImGuiTabItemFlags flags)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
if (window->SkipItems)
return false;
ImGuiTabBar* tab_bar = g.CurrentTabBar;
if (tab_bar == NULL)
{
IM_ASSERT_USER_ERROR(tab_bar != NULL, ... | leaq 0x7d27d(%rip), %rax # 0x12f138
movq (%rax), %rax
movq 0x3fe0(%rax), %rdx
cmpb $0x0, 0xd0(%rdx)
je 0xb1ed1
xorl %eax, %eax
retq
movl %esi, %ecx
movq %rdi, %rsi
movq 0x4520(%rax), %rdi
testq %rdi, %rdi
je 0xb1ef2
orl $0x200020, %ecx # imm = 0x200020
xorl %edx, %edx
xorl %r8d, %r8d
jmp 0xb1165
pushq %rax
... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
ImStb::stb_text_makeundo_replace(ImGuiInputTextState*, ImStb::STB_TexteditState*, int, int, int) | static void stb_text_makeundo_replace(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int old_length, int new_length)
{
int i;
STB_TEXTEDIT_CHARTYPE *p = stb_text_createundo(&state->undostate, where, old_length, new_length);
if (p) {
for (i=0; i < old_length; ++i)
p[i] = STB_TEXTE... | pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %ebp
movl %edx, %ebx
movq %rdi, %r14
leaq 0x20(%rsi), %rdi
movl %edx, %esi
movl %ecx, %edx
movl %r8d, %ecx
callq 0xb2f5c
testq %rax, %rax
sete %cl
testl %ebp, %ebp
setle %dl
orb %cl, %dl
jne 0xb29bd
movl %ebx, %ecx
movl %ebp, %edx
leaq (%rcx,%rcx), %rsi
xorl %edi, %edi
testl ... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imstb_textedit.h |
ImStb::STB_TEXTEDIT_DELETECHARS(ImGuiInputTextState*, int, int) | static void STB_TEXTEDIT_DELETECHARS(ImGuiInputTextState* obj, int pos, int n)
{
ImWchar* dst = obj->TextW.Data + pos;
// We maintain our buffer length in both UTF-8 and wchar formats
obj->Edited = true;
obj->CurLenA -= ImTextCountUtf8BytesFromStr(dst, dst + n);
obj->CurLenW -= n;
// Offset re... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movslq %esi, %r15
addq %r15, %r15
movq 0x18(%rdi), %rbx
addq %r15, %rbx
movb $0x1, 0xe7e(%rdi)
movslq %edx, %r12
leaq (%rbx,%r12,2), %rsi
movq %rbx, %rdi
callq 0x4ac6b
subl %eax, 0x8(%r14)
subl %r12d, 0x4(%r14)
addq 0x18(%r14), %r15
leaq (%r15,%r12,... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
ImStb::stb_textedit_delete_selection(ImGuiInputTextState*, ImStb::STB_TexteditState*) | static void stb_textedit_delete_selection(STB_TEXTEDIT_STRING *str, STB_TexteditState *state)
{
stb_textedit_clamp(str, state);
if (STB_TEXT_HAS_SELECTION(state)) {
if (state->select_start < state->select_end) {
stb_textedit_delete(str, state, state->select_start, state->select_end - state->select_... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa7d97
leaq 0x4(%rbx), %r12
movl 0x4(%rbx), %edx
movl 0x8(%rbx), %ecx
leaq 0x8(%rbx), %r15
movl %edx, %eax
subl %ecx, %eax
je 0xb2c96
jge 0xb2c76
subl %edx, %ecx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb2ebe
movq %r12, %rax
jm... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imstb_textedit.h |
ImStb::STB_TEXTEDIT_GETWIDTH(ImGuiInputTextState*, int, int) | inline T& operator[](int i) { IM_ASSERT(i >= 0 && i < Size); return Data[i]; } | addl %edx, %esi
js 0xb2e9e
cmpl %esi, 0x10(%rdi)
jle 0xb2e9e
movq 0x18(%rdi), %rax
movl %esi, %ecx
movzwl (%rax,%rcx,2), %eax
cmpl $0xa, %eax
jne 0xb2e66
movss 0x2219f(%rip), %xmm0 # 0xd5004
retq
leaq 0x7c2cb(%rip), %rcx # 0x12f138
movq (%rcx), %rcx
movq 0x3d48(%rcx), %rdx
leal (,%rax,4), %esi
addq 0x8(%rdx), %r... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui.h |
ImStb::stb_textedit_delete(ImGuiInputTextState*, ImStb::STB_TexteditState*, int, int) | static void stb_textedit_delete(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, int where, int len)
{
stb_text_makeundo_delete(str, state, where, len);
STB_TEXTEDIT_DELETECHARS(str, where, len);
state->has_preferred_x = 0;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x20(%rsi), %rdi
movl %edx, %esi
movl %ecx, %edx
xorl %ecx, %ecx
callq 0xb2f5c
testq %rax, %rax
sete %cl
testl %ebp, %ebp
setle %dl
orb %cl, %dl
jne 0xb2f21
testl %r14d, %r14d
js 0xb2f3d
movl %r1... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imstb_textedit.h |
ImStb::stb_text_createundo(ImStb::StbUndoState*, int, int, int) | static STB_TEXTEDIT_CHARTYPE *stb_text_createundo(StbUndoState *state, int pos, int insert_len, int delete_len)
{
StbUndoRecord *r = stb_text_create_undo_record(state, insert_len);
if (r == NULL)
return NULL;
r->where = pos;
r->insert_length = (STB_TEXTEDIT_POSITIONTYPE) insert_len;
r->delete_leng... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %ebx
movl %esi, %r15d
movq %rdi, %r14
movw $0x63, 0xe00(%rdi)
movl $0x3e7, 0xe08(%rdi) # imm = 0x3E7
cmpw $0x63, 0xdfe(%rdi)
jne 0xb2f92
movq %r14, %rdi
callq 0xb303a
cmpl $0x3e7, %ebx # imm = 0x3E7
jle 0xb2fb3
movw $0x0, 0... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imstb_textedit.h |
ImStb::is_word_boundary_from_right(ImGuiInputTextState*, int) | static int is_word_boundary_from_right(ImGuiInputTextState* obj, int idx) { if (obj->Flags & ImGuiInputTextFlags_Password) return 0; return idx > 0 ? (is_separator(obj->TextW[idx - 1]) && !is_separator(obj->TextW[idx]) ) : 1; } | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %ebx, %ebx
testb $-0x80, 0xe81(%rdi)
jne 0xb312d
movl %esi, %ebp
testl %esi, %esi
jle 0xb3128
movl 0x10(%rdi), %r14d
cmpl %ebp, %r14d
jl 0xb3138
movq 0x18(%rdi), %r15
movl %ebp, %r12d
movzwl -0x2(%r15,%r12,2), %edi
callq 0xb3157
testb %al, %al
je 0xb312d
cmpl ... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
ImStb::stb_text_locate_coord(ImGuiInputTextState*, float, float) | static int stb_text_locate_coord(STB_TEXTEDIT_STRING *str, float x, float y)
{
StbTexteditRow r;
int n = STB_TEXTEDIT_STRINGLEN(str);
float base_y = 0, prev_x;
int i=0, k;
r.x0 = r.x1 = 0;
r.ymin = r.ymax = 0;
r.num_chars = 0;
// search rows to find one that straddles 'y'
while (i < n) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movaps %xmm0, %xmm3
movq %rdi, %rbx
movl 0x4(%rdi), %ebp
testl %ebp, %ebp
setg %r15b
jle 0xb324f
movss %xmm3, 0x4(%rsp)
xorps %xmm3, %xmm3
xorl %r14d, %r14d
movss %xmm1, 0xc(%rsp)
movss %xmm3, 0x8(%rsp)
movq 0x18(%rbx), %rax
movq $0x0, 0... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imstb_textedit.h |
char const* ImAtoi<long long>(char const*, long long*) | static const char* ImAtoi(const char* src, TYPE* output)
{
int negative = 0;
if (*src == '-') { negative = 1; src++; }
if (*src == '+') { src++; }
TYPE v = 0;
while (*src >= '0' && *src <= '9')
v = (v * 10) + (*src++ - '0');
*output = negative ? -v : v;
return src;
} | movb (%rdi), %al
xorl %edx, %edx
cmpb $0x2d, %al
sete %dl
leaq (%rdi,%rdx), %rcx
xorl %r8d, %r8d
cmpb $0x2b, (%rdi,%rdx)
sete %r8b
movb (%r8,%rcx), %cl
leal -0x30(%rcx), %r9d
cmpb $0x9, %r9b
ja 0xb3439
addq %rdx, %r8
addq %r8, %rdi
incq %rdi
xorl %edx, %edx
leaq (%rdx,%rdx,4), %rdx
addb $-0x30, %cl
movzbl %cl, %ecx
lea... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
bool ImGui::CheckboxFlagsT<int>(char const*, int*, int) | bool ImGui::CheckboxFlagsT(const char* label, T* flags, T flags_value)
{
bool all_on = (*flags & flags_value) == flags_value;
bool any_on = (*flags & flags_value) != 0;
bool pressed;
if (!all_on && any_on)
{
ImGuiContext& g = *GImGui;
ImGuiItemFlags backup_item_flags = g.CurrentItemF... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movl (%rsi), %eax
andl %edx, %eax
cmpl %edx, %eax
sete 0x7(%rsp)
sete %cl
testl %eax, %eax
sete %al
orb %cl, %al
je 0xb347a
leaq 0x7(%rsp), %rsi
callq 0x9d8af
jmp 0xb34a8
leaq 0x7bcb7(%rip), %rax # 0x12f138
movq (%rax), %r15
movl... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
bool ImGui::CheckboxFlagsT<long long>(char const*, long long*, long long) | bool ImGui::CheckboxFlagsT(const char* label, T* flags, T flags_value)
{
bool all_on = (*flags & flags_value) == flags_value;
bool any_on = (*flags & flags_value) != 0;
bool pressed;
if (!all_on && any_on)
{
ImGuiContext& g = *GImGui;
ImGuiItemFlags backup_item_flags = g.CurrentItemF... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq (%rsi), %rax
andq %rdx, %rax
cmpq %rdx, %rax
sete 0x7(%rsp)
sete %cl
testq %rax, %rax
sete %al
orb %cl, %al
je 0xb357f
leaq 0x7(%rsp), %rsi
callq 0x9d8af
jmp 0xb35ad
leaq 0x7bbb2(%rip), %rax # 0x12f138
movq (%rax), %r15
movl... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
bool ImGui::DragBehaviorT<unsigned int, int, float>(int, unsigned int*, float, unsigned int, unsigned int, char const*, int) | bool ImGui::DragBehaviorT(ImGuiDataType data_type, TYPE* v, float v_speed, const TYPE v_min, const TYPE v_max, const char* format, ImGuiSliderFlags flags)
{
ImGuiContext& g = *GImGui;
const ImGuiAxis axis = (flags & ImGuiSliderFlags_Vertical) ? ImGuiAxis_Y : ImGuiAxis_X;
const bool is_clamped = (v_min < v_m... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, 0x28(%rsp)
movl %edx, %r14d
movaps %xmm0, %xmm3
movq %rsi, 0x48(%rsp)
movl %edi, %r13d
leaq 0x7b6cb(%rip), %rax # 0x12f138
movl %r9d, %ebp
andl $0x100000, %ebp # imm = 0x100000
movl %ecx, 0x4(%rsp)
movl %ecx, %r15d
... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
bool ImGui::DragBehaviorT<long long, long long, double>(int, long long*, float, long long, long long, char const*, int) | bool ImGui::DragBehaviorT(ImGuiDataType data_type, TYPE* v, float v_speed, const TYPE v_min, const TYPE v_max, const char* format, ImGuiSliderFlags flags)
{
ImGuiContext& g = *GImGui;
const ImGuiAxis axis = (flags & ImGuiSliderFlags_Vertical) ? ImGuiAxis_Y : ImGuiAxis_X;
const bool is_clamped = (v_min < v_m... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %r9d, %ebp
movq %r8, 0x38(%rsp)
movaps %xmm0, %xmm3
movq %rsi, %r14
movl %edi, %r15d
leaq 0x7b269(%rip), %rax # 0x12f138
movq (%rax), %rbx
movl %r9d, 0x14(%rsp)
andl $0x100000, %ebp # imm = 0x100000
movq %rcx, %r13
movq ... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
bool ImGui::DragBehaviorT<float, float, float>(int, float*, float, float, float, char const*, int) | bool ImGui::DragBehaviorT(ImGuiDataType data_type, TYPE* v, float v_speed, const TYPE v_min, const TYPE v_max, const char* format, ImGuiSliderFlags flags)
{
ImGuiContext& g = *GImGui;
const ImGuiAxis axis = (flags & ImGuiSliderFlags_Vertical) ? ImGuiAxis_Y : ImGuiAxis_X;
const bool is_clamped = (v_min < v_m... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %ecx, %ebp
movq %rdx, 0x48(%rsp)
movaps %xmm0, %xmm5
movq %rsi, %r12
movl %edi, %r13d
leaq 0x7a9c4(%rip), %rax # 0x12f138
movq (%rax), %r15
movl %ecx, %ebx
andl $0x100000, %ebx # imm = 0x100000
xorps %xmm0, %xmm0
ucomiss... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
bool ImGui::DragBehaviorT<double, double, double>(int, double*, float, double, double, char const*, int) | bool ImGui::DragBehaviorT(ImGuiDataType data_type, TYPE* v, float v_speed, const TYPE v_min, const TYPE v_max, const char* format, ImGuiSliderFlags flags)
{
ImGuiContext& g = *GImGui;
const ImGuiAxis axis = (flags & ImGuiSliderFlags_Vertical) ? ImGuiAxis_Y : ImGuiAxis_X;
const bool is_clamped = (v_min < v_m... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %ecx, %ebp
movq %rdx, 0x40(%rsp)
movaps %xmm0, %xmm5
movq %rsi, %r12
movl %edi, %r13d
leaq 0x7a557(%rip), %rax # 0x12f138
movq (%rax), %r15
movl %ecx, %ebx
andl $0x100000, %ebx # imm = 0x100000
xorps %xmm0, %xmm0
ucomiss... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
bool ImGui::SliderBehaviorT<int, int, float>(ImRect const&, unsigned int, int, int*, int, int, char const*, int, ImRect*) | bool ImGui::SliderBehaviorT(const ImRect& bb, ImGuiID id, ImGuiDataType data_type, TYPE* v, const TYPE v_min, const TYPE v_max, const char* format, ImGuiSliderFlags flags, ImRect* out_grab_bb)
{
ImGuiContext& g = *GImGui;
const ImGuiStyle& style = g.Style;
const ImGuiAxis axis = (flags & ImGuiSliderFlags_V... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, 0x48(%rsp)
movl %edx, %ebx
movl %esi, %r13d
movl 0xd8(%rsp), %r15d
leaq 0x7a08d(%rip), %rax # 0x12f138
movq (%rax), %r14
movl %r15d, %ebp
andl $0x100000, %ebp # imm = 0x100000
movl %edx, 0x50(%rsp)
andl $-0x2, %ebx... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
bool ImGui::SliderBehaviorT<unsigned int, int, float>(ImRect const&, unsigned int, int, unsigned int*, unsigned int, unsigned int, char const*, int, ImRect*) | bool ImGui::SliderBehaviorT(const ImRect& bb, ImGuiID id, ImGuiDataType data_type, TYPE* v, const TYPE v_min, const TYPE v_max, const char* format, ImGuiSliderFlags flags, ImRect* out_grab_bb)
{
ImGuiContext& g = *GImGui;
const ImGuiStyle& style = g.Style;
const ImGuiAxis axis = (flags & ImGuiSliderFlags_V... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, 0x58(%rsp)
movl %edx, %ebx
movl %esi, %r12d
movl %r8d, %eax
subl %r9d, %eax
negl %eax
movl %r8d, 0x1c(%rsp)
movl %r8d, %r14d
movl %r9d, 0x20(%rsp)
subl %r9d, %r14d
movl 0xd8(%rsp), %r13d
leaq 0x79915(%rip), %rcx # 0x12f138... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
bool ImGui::SliderBehaviorT<long long, long long, double>(ImRect const&, unsigned int, int, long long*, long long, long long, char const*, int, ImRect*) | bool ImGui::SliderBehaviorT(const ImRect& bb, ImGuiID id, ImGuiDataType data_type, TYPE* v, const TYPE v_min, const TYPE v_max, const char* format, ImGuiSliderFlags flags, ImRect* out_grab_bb)
{
ImGuiContext& g = *GImGui;
const ImGuiStyle& style = g.Style;
const ImGuiAxis axis = (flags & ImGuiSliderFlags_V... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, 0x48(%rsp)
movl %edx, %ebx
movl %esi, %r13d
movl 0xd8(%rsp), %ebp
leaq 0x791e4(%rip), %rax # 0x12f138
movq (%rax), %r15
movl %ebp, %r14d
andl $0x100000, %r14d # imm = 0x100000
movl %edx, 0x50(%rsp)
andl $-0x2, %ebx
... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
bool ImGui::SliderBehaviorT<unsigned long long, long long, double>(ImRect const&, unsigned int, int, unsigned long long*, unsigned long long, unsigned long long, char const*, int, ImRect*) | bool ImGui::SliderBehaviorT(const ImRect& bb, ImGuiID id, ImGuiDataType data_type, TYPE* v, const TYPE v_min, const TYPE v_max, const char* format, ImGuiSliderFlags flags, ImRect* out_grab_bb)
{
ImGuiContext& g = *GImGui;
const ImGuiStyle& style = g.Style;
const ImGuiAxis axis = (flags & ImGuiSliderFlags_V... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r8, %r15
movq %rcx, 0x48(%rsp)
movl %edx, %ebx
movl %esi, %r12d
movq %r8, %rax
subq %r9, %rax
negq %rax
movq %r8, 0x38(%rsp)
movq %r9, 0x40(%rsp)
subq %r9, %r15
movl 0xd8(%rsp), %r13d
leaq 0x78a61(%rip), %rcx # 0x12f138
movq (%... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
bool ImGui::SliderBehaviorT<float, float, float>(ImRect const&, unsigned int, int, float*, float, float, char const*, int, ImRect*) | bool ImGui::SliderBehaviorT(const ImRect& bb, ImGuiID id, ImGuiDataType data_type, TYPE* v, const TYPE v_min, const TYPE v_max, const char* format, ImGuiSliderFlags flags, ImRect* out_grab_bb)
{
ImGuiContext& g = *GImGui;
const ImGuiStyle& style = g.Style;
const ImGuiAxis axis = (flags & ImGuiSliderFlags_V... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %r9d, %ebp
movq %r8, 0x58(%rsp)
movl %edx, %r14d
movl %esi, %r13d
movq %rdi, %rbx
leaq 0x78301(%rip), %rax # 0x12f138
movq (%rax), %r12
movl %r9d, %r15d
andl $0x100000, %r15d # imm = 0x100000
movl %edx, 0x18(%rsp)
movl %r... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
float ImGui::ScaleRatioFromValueT<int, int, float>(int, int, int, int, bool, float, float) | float ImGui::ScaleRatioFromValueT(ImGuiDataType data_type, TYPE v, TYPE v_min, TYPE v_max, bool is_logarithmic, float logarithmic_zero_epsilon, float zero_deadzone_halfsize)
{
if (v_min == v_max)
return 0.0f;
IM_UNUSED(data_type);
const TYPE v_clamped = (v_min < v_max) ? ImClamp(v, v_min, v_max) : ... | pushq %rbp
pushq %rbx
subq $0x48, %rsp
movl %ecx, %ebp
xorps %xmm6, %xmm6
subl %edx, %ecx
je 0xb7ffa
movl %edx, %ebx
movl %ebp, %edx
cmovgl %ebx, %edx
movl %ebp, %eax
cmovll %ebx, %eax
cmpl %eax, %esi
cmovll %esi, %eax
cmpl %esi, %edx
cmovgl %edx, %eax
testb %r8b, %r8b
je 0xb7f09
movaps %xmm0, %xmm4
cmpl %ebx, %ebp
mov... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
int ImGui::RoundScalarWithFormatT<int, int>(char const*, int, int) | TYPE ImGui::RoundScalarWithFormatT(const char* format, ImGuiDataType data_type, TYPE v)
{
const char* fmt_start = ImParseFormatFindStart(format);
if (fmt_start[0] != '%' || fmt_start[1] == '%') // Don't apply if the value is not visible in the format string
return v;
// Sanitize format
char fmt... | pushq %r14
pushq %rbx
subq $0x78, %rsp
movl %edx, %eax
movl %esi, %ebx
movl %edx, 0xc(%rsp)
movb (%rdi), %sil
testb %sil, %sil
je 0xb8338
cmpb $0x25, %sil
jne 0xb8325
movl $0x1, %edx
cmpb $0x25, 0x1(%rdi)
jne 0xb833f
xorl %edx, %edx
cmpb $0x25, %sil
sete %dl
addq %rdx, %rdi
incq %rdi
xorl %edx, %edx
jmp 0xb8342
movl $0... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
unsigned int ImGui::ScaleValueFromRatioT<unsigned int, int, float>(int, float, unsigned int, unsigned int, bool, float, float) | TYPE ImGui::ScaleValueFromRatioT(ImGuiDataType data_type, float t, TYPE v_min, TYPE v_max, bool is_logarithmic, float logarithmic_zero_epsilon, float zero_deadzone_halfsize)
{
if (v_min == v_max)
return v_min;
const bool is_floating_point = (data_type == ImGuiDataType_Float) || (data_type == ImGuiDataTy... | movl %esi, %eax
movl %edx, %esi
subl %eax, %esi
jne 0xb84a5
retq
movaps %xmm0, %xmm2
testb %cl, %cl
je 0xb84df
xorps %xmm0, %xmm0
ucomiss %xmm2, %xmm0
jae 0xb84a4
ucomiss 0x1ef41(%rip), %xmm2 # 0xd73fc
jae 0xb853b
movl %eax, %ecx
cvtsi2ss %rcx, %xmm3
movl %edx, %ecx
cvtsi2ss %rcx, %xmm4
movaps %xmm1, %xmm0
maxss %xm... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
unsigned int ImGui::RoundScalarWithFormatT<unsigned int, int>(char const*, int, unsigned int) | TYPE ImGui::RoundScalarWithFormatT(const char* format, ImGuiDataType data_type, TYPE v)
{
const char* fmt_start = ImParseFormatFindStart(format);
if (fmt_start[0] != '%' || fmt_start[1] == '%') // Don't apply if the value is not visible in the format string
return v;
// Sanitize format
char fmt... | pushq %r14
pushq %rbx
subq $0x78, %rsp
movl %edx, %eax
movl %esi, %ebx
movl %edx, 0xc(%rsp)
movb (%rdi), %sil
testb %sil, %sil
je 0xb85b6
cmpb $0x25, %sil
jne 0xb85a3
movl $0x1, %edx
cmpb $0x25, 0x1(%rdi)
jne 0xb85bd
xorl %edx, %edx
cmpb $0x25, %sil
sete %dl
addq %rdx, %rdi
incq %rdi
xorl %edx, %edx
jmp 0xb85c0
movl $0... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
float ImGui::ScaleRatioFromValueT<long long, long long, double>(int, long long, long long, long long, bool, float, float) | float ImGui::ScaleRatioFromValueT(ImGuiDataType data_type, TYPE v, TYPE v_min, TYPE v_max, bool is_logarithmic, float logarithmic_zero_epsilon, float zero_deadzone_halfsize)
{
if (v_min == v_max)
return 0.0f;
IM_UNUSED(data_type);
const TYPE v_clamped = (v_min < v_max) ? ImClamp(v, v_min, v_max) : ... | xorps %xmm6, %xmm6
movq %rcx, %rax
subq %rdx, %rax
je 0xb87e2
pushq %r14
pushq %rbx
leaq -0x38(%rsp), %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rcx, %rdx
cmovgq %rbx, %rdx
cmovlq %rbx, %rcx
cmpq %rcx, %rsi
cmovlq %rsi, %rcx
cmpq %rsi, %rdx
cmovgq %rdx, %rcx
testb %r8b, %r8b
je 0xb86aa
cmpq %rbx, %r14
movq %rbx, %rdx
c... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
long long ImGui::RoundScalarWithFormatT<long long, long long>(char const*, int, long long) | TYPE ImGui::RoundScalarWithFormatT(const char* format, ImGuiDataType data_type, TYPE v)
{
const char* fmt_start = ImParseFormatFindStart(format);
if (fmt_start[0] != '%' || fmt_start[1] == '%') // Don't apply if the value is not visible in the format string
return v;
// Sanitize format
char fmt... | pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdx, %rax
movl %esi, %ebx
movq %rdx, 0x8(%rsp)
movb (%rdi), %sil
testb %sil, %sil
je 0xb8baa
cmpb $0x25, %sil
jne 0xb8b97
movl $0x1, %edx
cmpb $0x25, 0x1(%rdi)
jne 0xb8bb1
xorl %edx, %edx
cmpb $0x25, %sil
sete %dl
addq %rdx, %rdi
incq %rdi
xorl %edx, %edx
jmp 0xb8bb4
movl $0... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
float ImGui::ScaleRatioFromValueT<unsigned long long, long long, double>(int, unsigned long long, unsigned long long, unsigned long long, bool, float, float) | float ImGui::ScaleRatioFromValueT(ImGuiDataType data_type, TYPE v, TYPE v_min, TYPE v_max, bool is_logarithmic, float logarithmic_zero_epsilon, float zero_deadzone_halfsize)
{
if (v_min == v_max)
return 0.0f;
IM_UNUSED(data_type);
const TYPE v_clamped = (v_min < v_max) ? ImClamp(v, v_min, v_max) : ... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
xorps %xmm1, %xmm1
subq %rdx, %rcx
je 0xb8d73
movq %rdx, %rbx
movq %r14, %rdx
cmovaq %rbx, %rdx
movq %r14, %rax
cmovbq %rbx, %rax
cmpq %rax, %rsi
cmovbq %rsi, %rax
cmpq %rsi, %rdx
cmovaq %rdx, %rax
testb %r8b, %r8b
je 0xb8d37
cmpq %rbx, %r14
movq %rbx, %rdx
cmovbq ... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
unsigned long long ImGui::ScaleValueFromRatioT<unsigned long long, long long, double>(int, float, unsigned long long, unsigned long long, bool, float, float) | TYPE ImGui::ScaleValueFromRatioT(ImGuiDataType data_type, float t, TYPE v_min, TYPE v_max, bool is_logarithmic, float logarithmic_zero_epsilon, float zero_deadzone_halfsize)
{
if (v_min == v_max)
return v_min;
const bool is_floating_point = (data_type == ImGuiDataType_Float) || (data_type == ImGuiDataTy... | movq %rsi, %rax
movq %rdx, %rsi
subq %rax, %rsi
jne 0xb8d8a
retq
testb %cl, %cl
je 0xb8e09
xorps %xmm2, %xmm2
ucomiss %xmm0, %xmm2
jae 0xb8d89
ucomiss 0x1e65f(%rip), %xmm0 # 0xd73fc
jae 0xb8e5d
movq %rax, %xmm2
movq 0x3f8c0(%rip), %xmm3 # 0xf8670
punpckldq %xmm3, %xmm2 # xmm2 = xmm2[0],xmm3[0],xmm2[1],xmm3[1]
... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
unsigned long long ImGui::RoundScalarWithFormatT<unsigned long long, long long>(char const*, int, unsigned long long) | TYPE ImGui::RoundScalarWithFormatT(const char* format, ImGuiDataType data_type, TYPE v)
{
const char* fmt_start = ImParseFormatFindStart(format);
if (fmt_start[0] != '%' || fmt_start[1] == '%') // Don't apply if the value is not visible in the format string
return v;
// Sanitize format
char fmt... | pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdx, %rax
movl %esi, %ebx
movq %rdx, 0x8(%rsp)
movb (%rdi), %sil
testb %sil, %sil
je 0xb8f5b
cmpb $0x25, %sil
jne 0xb8f48
movl $0x1, %edx
cmpb $0x25, 0x1(%rdi)
jne 0xb8f62
xorl %edx, %edx
cmpb $0x25, %sil
sete %dl
addq %rdx, %rdi
incq %rdi
xorl %edx, %edx
jmp 0xb8f65
movl $0... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
float ImGui::ScaleRatioFromValueT<float, float, float>(int, float, float, float, bool, float, float) | float ImGui::ScaleRatioFromValueT(ImGuiDataType data_type, TYPE v, TYPE v_min, TYPE v_max, bool is_logarithmic, float logarithmic_zero_epsilon, float zero_deadzone_halfsize)
{
if (v_min == v_max)
return 0.0f;
IM_UNUSED(data_type);
const TYPE v_clamped = (v_min < v_max) ? ImClamp(v, v_min, v_max) : ... | movaps %xmm0, %xmm8
xorps %xmm0, %xmm0
ucomiss %xmm2, %xmm1
jne 0xb900a
jp 0xb900a
retq
movaps %xmm1, %xmm5
minss %xmm2, %xmm5
movaps %xmm2, %xmm6
maxss %xmm1, %xmm6
minss %xmm8, %xmm6
movaps %xmm8, %xmm0
cmpltss %xmm5, %xmm0
andps %xmm0, %xmm5
andnps %xmm6, %xmm0
orps %xmm5, %xmm0
testb %sil, %sil
je 0xb90d3
movaps %x... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
float ImGui::ScaleValueFromRatioT<float, float, float>(int, float, float, float, bool, float, float) | TYPE ImGui::ScaleValueFromRatioT(ImGuiDataType data_type, float t, TYPE v_min, TYPE v_max, bool is_logarithmic, float logarithmic_zero_epsilon, float zero_deadzone_halfsize)
{
if (v_min == v_max)
return v_min;
const bool is_floating_point = (data_type == ImGuiDataType_Float) || (data_type == ImGuiDataTy... | subq $0x18, %rsp
ucomiss %xmm2, %xmm1
jne 0xb92ed
jp 0xb92ed
movaps %xmm1, %xmm0
addq $0x18, %rsp
retq
movaps %xmm0, %xmm9
testb %sil, %sil
je 0xb946d
xorps %xmm0, %xmm0
ucomiss %xmm9, %xmm0
jae 0xb92e5
ucomiss 0x1e0f1(%rip), %xmm9 # 0xd73fc
jae 0xb94be
movaps 0x1e1d8(%rip), %xmm0 # 0xd74f0
andps %xmm1, %xmm0
uco... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
float ImGui::RoundScalarWithFormatT<float, float>(char const*, int, float) | TYPE ImGui::RoundScalarWithFormatT(const char* format, ImGuiDataType data_type, TYPE v)
{
const char* fmt_start = ImParseFormatFindStart(format);
if (fmt_start[0] != '%' || fmt_start[1] == '%') // Don't apply if the value is not visible in the format string
return v;
// Sanitize format
char fmt... | pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movl %esi, %ebx
movb (%rdi), %dl
testb %dl, %dl
je 0xb955f
cmpb $0x25, %dl
jne 0xb954d
movl $0x1, %ecx
cmpb $0x25, 0x1(%rdi)
jne 0xb9566
xorl %ecx, %ecx
cmpb $0x25, %dl
sete %cl
addq %rcx, %rdi
incq %rdi
xorl %ecx, %ecx
jmp 0xb9569
movl $0x3, %ecx
jmp 0xb9569
movq %rdi,... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
float ImGui::ScaleRatioFromValueT<double, double, double>(int, double, double, double, bool, float, float) | float ImGui::ScaleRatioFromValueT(ImGuiDataType data_type, TYPE v, TYPE v_min, TYPE v_max, bool is_logarithmic, float logarithmic_zero_epsilon, float zero_deadzone_halfsize)
{
if (v_min == v_max)
return 0.0f;
IM_UNUSED(data_type);
const TYPE v_clamped = (v_min < v_max) ? ImClamp(v, v_min, v_max) : ... | xorps %xmm11, %xmm11
ucomisd %xmm2, %xmm1
jne 0xb9654
jnp 0xb9994
movapd %xmm0, %xmm8
movapd %xmm1, %xmm6
minsd %xmm2, %xmm6
movapd %xmm2, %xmm5
maxsd %xmm1, %xmm5
minsd %xmm0, %xmm5
cmpltsd %xmm6, %xmm0
andpd %xmm0, %xmm6
andnpd %xmm5, %xmm0
orpd %xmm6, %xmm0
testb %sil, %sil
je 0xb96bf
movapd %xmm2, %xmm5
minsd %xmm1... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
double ImGui::RoundScalarWithFormatT<double, double>(char const*, int, double) | TYPE ImGui::RoundScalarWithFormatT(const char* format, ImGuiDataType data_type, TYPE v)
{
const char* fmt_start = ImParseFormatFindStart(format);
if (fmt_start[0] != '%' || fmt_start[1] == '%') // Don't apply if the value is not visible in the format string
return v;
// Sanitize format
char fmt... | pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movl %esi, %ebx
movb (%rdi), %dl
testb %dl, %dl
je 0xb9c52
cmpb $0x25, %dl
jne 0xb9c40
movl $0x1, %ecx
cmpb $0x25, 0x1(%rdi)
jne 0xb9c59
xorl %ecx, %ecx
cmpb $0x25, %dl
sete %cl
addq %rcx, %rdi
incq %rdi
xorl %ecx, %ecx
jmp 0xb9c5c
movl $0x3, %ecx
jmp 0xb9c5c
movq %rdi,... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_widgets.cpp |
ImPool<ImGuiTabBar>::Add() | T* Add() { int idx = FreeIdx; if (idx == Buf.Size) { Buf.resize(Buf.Size + 1); FreeIdx++; } else { FreeIdx = *(int*)&Buf[idx]; } IM_PLACEMENT_NEW(&Buf[idx]) T(); AliveCount++; return &Buf[idx]; } | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %ecx
movl 0x20(%rdi), %r15d
cmpl %ecx, %r15d
jne 0xb9d6c
leal 0x1(%rcx), %ebp
movl 0x4(%rbx), %eax
cmpl %ecx, %eax
jg 0xb9dde
testl %eax, %eax
je 0xb9d8e
movl %eax, %r12d
shrl $0x1f, %r12d
addl %eax, %r12d
sarl %r12d
addl %eax, %r12d
jm... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/imgui_internal.h |
ImGui::InputText(char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, int, int (*)(ImGuiInputTextCallbackData*), void*) | bool ImGui::InputText(const char* label, std::string* str, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, void* user_data)
{
IM_ASSERT((flags & ImGuiInputTextFlags_CallbackResize) == 0);
flags |= ImGuiInputTextFlags_CallbackResize;
InputTextCallback_UserData cb_user_data;
cb_user_data.Str ... | subq $0x18, %rsp
btl $0x12, %edx
jb 0xb9ea7
movl %edx, %eax
orl $0x40000, %eax # imm = 0x40000
movq %rsp, %r9
movq %rsi, (%r9)
movq %rcx, 0x8(%r9)
movq %r8, 0x10(%r9)
leaq 0x10(%rsi), %rdx
movq (%rsi), %rcx
movq 0x10(%rsi), %rsi
incq %rsi
cmpq %rdx, %rcx
movl $0x10, %edx
cmovneq %rsi, %rdx
leaq 0x2e(%rip), %r8... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/misc/cpp/imgui_stdlib.cpp |
InputTextCallback(ImGuiInputTextCallbackData*) | static int InputTextCallback(ImGuiInputTextCallbackData* data)
{
InputTextCallback_UserData* user_data = (InputTextCallback_UserData*)data->UserData;
if (data->EventFlag == ImGuiInputTextFlags_CallbackResize)
{
// Resize string callback
// If for some reason we refuse the new length (BufText... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpl $0x40000, (%rdi) # imm = 0x40000
jne 0xb9efc
movq (%rax), %r14
movq 0x18(%rbx), %rax
cmpq (%r14), %rax
jne 0xb9f23
movslq 0x20(%rbx), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0xc260
movq (%r14), %rax
movq %rax, 0x18(%rbx)
jmp 0xb9f19
mo... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/misc/cpp/imgui_stdlib.cpp |
ImGui::InputTextMultiline(char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, ImVec2 const&, int, int (*)(ImGuiInputTextCallbackData*), void*) | bool ImGui::InputTextMultiline(const char* label, std::string* str, const ImVec2& size, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, void* user_data)
{
IM_ASSERT((flags & ImGuiInputTextFlags_CallbackResize) == 0);
flags |= ImGuiInputTextFlags_CallbackResize;
InputTextCallback_UserData cb_use... | subq $0x28, %rsp
movl %ecx, %eax
btl $0x12, %ecx
jb 0xb9f9b
movq %rdx, %rcx
orl $0x40000, %eax # imm = 0x40000
leaq 0x10(%rsp), %r10
movq %rsi, (%r10)
movq %r8, 0x8(%r10)
movq %r9, 0x10(%r10)
leaq 0x10(%rsi), %rdx
movq (%rsi), %r8
movq 0x10(%rsi), %rsi
incq %rsi
cmpq %rdx, %r8
movl $0x10, %edx
cmovneq %rsi, %r... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/misc/cpp/imgui_stdlib.cpp |
ImGui::InputTextWithHint(char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, int, int (*)(ImGuiInputTextCallbackData*), void*) | bool ImGui::InputTextWithHint(const char* label, const char* hint, std::string* str, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, void* user_data)
{
IM_ASSERT((flags & ImGuiInputTextFlags_CallbackResize) == 0);
flags |= ImGuiInputTextFlags_CallbackResize;
InputTextCallback_UserData cb_user_d... | subq $0x28, %rsp
btl $0x12, %ecx
jb 0xba010
movl %ecx, %eax
orl $0x40000, %eax # imm = 0x40000
leaq 0x10(%rsp), %r10
movq %rdx, (%r10)
movq %r8, 0x8(%r10)
movq %r9, 0x10(%r10)
leaq 0x10(%rdx), %rcx
movq (%rdx), %r8
movq 0x10(%rdx), %rdx
incq %rdx
cmpq %rcx, %r8
movl $0x10, %ecx
cmovneq %rdx, %rcx
movq %r10, (%... | /johnor[P]n_e_s_vis/build_O1/_deps/imgui-src/misc/cpp/imgui_stdlib.cpp |
fmt::v8::detail::assert_fail(char const*, int, char const*) | FMT_FUNC void assert_fail(const char* file, int line, const char* message) {
// Use unchecked std::fprintf to avoid triggering another assertion when
// writing to stderr fails
std::fprintf(stderr, "%s:%d: assertion failed: %s", file, line, message);
// Chosen instead of std::abort to satisfy Clang in CUDA mode... | pushq %rax
movq %rdx, %r8
movl %esi, %ecx
movq %rdi, %rdx
movq 0x72f60(%rip), %rax # 0x12cfa0
movq (%rax), %rdi
leaq 0x4152e(%rip), %rsi # 0xfb578
xorl %eax, %eax
callq 0xcdb0
callq 0xc210
| /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format-inl.h |
fmt::v8::detail::format_error_code(fmt::v8::detail::buffer<char>&, int, fmt::v8::basic_string_view<char>) | FMT_FUNC void format_error_code(detail::buffer<char>& out, int error_code,
string_view message) FMT_NOEXCEPT {
// Report error code making sure that the output fits into
// inline_buffer_size to avoid dynamic memory allocation and potential
// bad_alloc.
out.try_resize(0);
stat... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq $0x0, 0x10(%rdi)
movl %esi, %eax
negl %eax
cmovsl %esi, %eax
movl %eax, %ecx
orl $0x1, %ecx
bsrl %ecx, %ecx
leaq 0x41c80(%rip), %rdx # 0xfbd50
addq (%rdx,%rcx,8), %rax
js 0xba27c
movl %esi, %ebp
m... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format-inl.h |
fmt::v8::detail::report_error(void (*)(fmt::v8::detail::buffer<char>&, int, char const*), int, char const*) | FMT_FUNC void report_error(format_func func, int error_code,
const char* message) FMT_NOEXCEPT {
memory_buffer full_message;
func(full_message, error_code, message);
// Don't use fwrite_fully because the latter may throw.
if (std::fwrite(full_message.data(), full_message.size(), 1, st... | pushq %rbx
subq $0x220, %rsp # imm = 0x220
movq %rdi, %rax
xorps %xmm0, %xmm0
leaq 0x28(%rsp), %rbx
movups %xmm0, -0x18(%rbx)
leaq 0x71a92(%rip), %rcx # 0x12bd68
movq %rcx, -0x20(%rbx)
movq %rbx, -0x18(%rbx)
movq $0x1f4, -0x8(%rbx) # imm = 0x1F4
leaq 0x8(%rsp), %rdi
callq *%rax
leaq 0x10(%rsp), %rdi... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format-inl.h |
fmt::v8::vsystem_error(int, fmt::v8::basic_string_view<char>, fmt::v8::basic_format_args<fmt::v8::basic_format_context<fmt::v8::appender, char>>) | FMT_FUNC std::system_error vsystem_error(int error_code, string_view format_str,
format_args args) {
auto ec = std::error_code(error_code, std::generic_category());
return std::system_error(ec, vformat(format_str, args));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movl %esi, 0x4(%rsp)
movq %rdi, %rbx
callq 0xc420
movq %rax, %rbp
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0xba3be
movq %rbx, ... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format-inl.h |
fmt::v8::vformat[abi:cxx11](fmt::v8::basic_string_view<char>, fmt::v8::basic_format_args<fmt::v8::basic_format_context<fmt::v8::appender, char>>) | FMT_FUNC std::string vformat(string_view fmt, format_args args) {
// Don't optimize the "{}" case to keep the binary size small and because it
// can be better optimized in fmt::format anyway.
auto buffer = memory_buffer();
detail::vformat_to(buffer, fmt, args);
return to_string(buffer);
} | pushq %r14
pushq %rbx
subq $0x238, %rsp # imm = 0x238
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r14
movups %xmm0, -0x18(%r14)
leaq 0x71989(%rip), %rax # 0x12bd68
movq %rax, -0x20(%r14)
movq %r14, -0x18(%r14)
movq $0x1f4, -0x8(%r14) # imm = 0x1F4
movq %rsp, %rdi
xorl %r9d, %r9d
callq 0xbad... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format-inl.h |
fmt::v8::detail::utf8_to_utf16::utf8_to_utf16(fmt::v8::basic_string_view<char>) | FMT_FUNC detail::utf8_to_utf16::utf8_to_utf16(string_view s) {
for_each_codepoint(s, [this](uint32_t cp, string_view) {
if (cp == invalid_code_point) FMT_THROW(std::runtime_error("invalid utf8"));
if (cp <= 0xFFFF) {
buffer_.push_back(static_cast<wchar_t>(cp));
} else {
cp -= 0x10000;
bu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
leaq 0x718fd(%rip), %rax # 0x12bda8
movq %rax, (%rdi)
leaq 0x20(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rax, 0x8(%rdi)
movq $0x1f4, 0x18(%rdi)... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format-inl.h |
fmt::v8::format_system_error(fmt::v8::detail::buffer<char>&, int, char const*) | FMT_FUNC void format_system_error(detail::buffer<char>& out, int error_code,
const char* message) FMT_NOEXCEPT {
FMT_TRY {
auto ec = std::error_code(error_code, std::generic_category());
write(std::back_inserter(out), std::system_error(ec, message).what());
return;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0xc420
leaq 0x8(%rsp), %rdi
movl %ebp, %esi
movq %rax, %rdx
movq %rbx, %rcx
callq 0xbab8e
leaq 0x8(%rsp), %rdi
callq 0xccd0
movq %r14, %rdi
movq %rax, %rsi
callq 0xbab55
leaq 0x8(%rsp), %rdi
callq 0xd3c8
a... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format-inl.h |
fmt::v8::detail::print(_IO_FILE*, fmt::v8::basic_string_view<char>) | FMT_FUNC void print(std::FILE* f, string_view text) {
#ifdef _WIN32
auto fd = _fileno(f);
if (_isatty(fd)) {
detail::utf8_to_utf16 u16(string_view(text.data(), text.size()));
auto written = detail::dword();
if (detail::WriteConsoleW(reinterpret_cast<void*>(_get_osfhandle(fd)),
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %rax
movq %rdi, %rcx
movl $0x1, %esi
movq %rax, %rdi
callq 0xd340
cmpq %rbx, %rax
jb 0xba694
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x20, %edi
callq 0xc410
movq %rax, %rbx
callq 0xc090
movl (%rax), %esi
leaq 0x40f91(%rip), %rdx # 0xfb640
movl $0x14... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format-inl.h |
void fmt::v8::detail::vformat_to<char>(fmt::v8::detail::buffer<char>&, fmt::v8::basic_string_view<char>, fmt::v8::basic_format_args<fmt::v8::basic_format_context<std::conditional<std::is_same<fmt::v8::type_identity<char>::type, char>::value, fmt::v8::appender, std::back_insert_iterator<fmt::v8::detail::buffer<fmt::v8::... | void vformat_to(
buffer<Char>& buf, basic_string_view<Char> fmt,
basic_format_args<FMT_BUFFER_CONTEXT(type_identity_t<Char>)> args,
locale_ref loc) {
// workaround for msvc bug regarding name-lookup in module
// link names into function scope
using detail::arg_formatter;
using detail::buffer_appende... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
cmpq $0x2, %rdx
jne 0xbad4d
cmpw $0x7d7b, (%r14) # imm = 0x7D7B
je 0xbae8e
movq %r14, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
movl $0x0, 0x58(%rsp)
movq %rdi, 0x60(%rsp)
movq %rcx, 0x68(%rsp)
movq %r8, 0x70(%rsp)
movq %r... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format.h |
fmt::v8::detail::dragonbox::decimal_fp<float> fmt::v8::detail::dragonbox::to_decimal<float>(float) | FMT_CONSTEXPR fp normalize(fp value) {
// Handle subnormals.
const uint64_t implicit_bit = 1ULL << num_significand_bits<double>();
const auto shifted_implicit_bit = implicit_bit << SHIFT;
while ((value.f & shifted_implicit_bit) == 0) {
value.f <<= 1;
--value.e;
}
// Subtract 1 to account for hidden ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movd %xmm0, %ebx
movl %ebx, %esi
andl $0x7fffff, %esi # imm = 0x7FFFFF
andl $0x7f800000, %ebx # imm = 0x7F800000
je 0xbb121
shrl $0x17, %ebx
addl $0xffffff6a, %ebx # imm = 0xFFFFFF6A
testl %esi, %esi
je 0xbb1f3
orl $0... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format-inl.h |
fmt::v8::detail::dragonbox::cache_accessor<float>::compute_mul_parity(unsigned int, unsigned long const&, int) | static bool compute_mul_parity(carrier_uint two_f,
const cache_entry_type& cache,
int beta_minus_1) FMT_NOEXCEPT {
FMT_ASSERT(beta_minus_1 >= 1, "");
FMT_ASSERT(beta_minus_1 < 64, "");
return ((umul96_lower64(two_f, cache) >> (64 - beta_minu... | pushq %rax
testl %edx, %edx
jle 0xbb4ac
cmpl $0x40, %edx
jge 0xbb4c4
movl %edi, %eax
imulq (%rsi), %rax
movb $0x40, %cl
subb %dl, %cl
movzbl %cl, %ecx
btq %rcx, %rax
setb %al
popq %rcx
retq
leaq 0x400e1(%rip), %rdi # 0xfb594
leaq 0x2cb11(%rip), %rdx # 0xe7fcb
movl $0x449, %esi # imm = 0x449
callq 0xb... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format-inl.h |
bool fmt::v8::detail::dragonbox::is_center_integer<float>(fmt::v8::detail::dragonbox::float_info<float>::carrier_uint, int, int) | bool is_center_integer(typename float_info<T>::carrier_uint two_f, int exponent,
int minus_k) FMT_NOEXCEPT {
// Exponent for 5 is negative.
if (exponent > float_info<T>::divisibility_check_by_5_threshold) return false;
if (exponent > float_info<T>::case_fc_upper_threshold)
return divisi... | pushq %rax
cmpl $0x27, %esi
jle 0xbb4e6
xorl %eax, %eax
jmp 0xbb51e
cmpl $0x7, %esi
jl 0xbb507
cmpl $0xb, %edx
jge 0xbb520
movslq %edx, %rax
leaq 0x413c6(%rip), %rcx # 0xfc8c0
imull (%rcx,%rax,8), %edi
cmpl 0x4(%rcx,%rax,8), %edi
setbe %al
jmp 0xbb51e
movb $0x1, %al
cmpl $-0x3, %esi
jg 0xbb51e
subl %esi, %edx
js 0x... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format-inl.h |
fmt::v8::detail::dragonbox::decimal_fp<double> fmt::v8::detail::dragonbox::to_decimal<double>(double) | decimal_fp<T> to_decimal(T x) FMT_NOEXCEPT {
// Step 1: integer promotion & Schubfach multiplier calculation.
using carrier_uint = typename float_info<T>::carrier_uint;
using cache_entry_type = typename cache_accessor<T>::cache_entry_type;
auto br = bit_cast<carrier_uint>(x);
// Extract significand bits and... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movabsq $0xfffffffffffff, %rax # imm = 0xFFFFFFFFFFFFF
movq %xmm0, %rcx
movq %rcx, %r13
andq %rax, %r13
movabsq $0x7ff0000000000000, %r15 # imm = 0x7FF0000000000000
andq %rcx, %r15
je 0xbb5b6
shrq $0x34, %r15
addl $0xfffffbcd, %r15d ... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format-inl.h |
bool fmt::v8::detail::dragonbox::is_center_integer<double>(fmt::v8::detail::dragonbox::float_info<double>::carrier_uint, int, int) | bool is_center_integer(typename float_info<T>::carrier_uint two_f, int exponent,
int minus_k) FMT_NOEXCEPT {
// Exponent for 5 is negative.
if (exponent > float_info<T>::divisibility_check_by_5_threshold) return false;
if (exponent > float_info<T>::case_fc_upper_threshold)
return divisi... | pushq %rax
cmpl $0x56, %esi
jle 0xbbdef
xorl %eax, %eax
jmp 0xbbe2f
cmpl $0xa, %esi
jl 0xbbe16
cmpl $0x18, %edx
jge 0xbbe31
movslq %edx, %rax
shlq $0x4, %rax
leaq 0x40b19(%rip), %rcx # 0xfc920
imulq (%rax,%rcx), %rdi
cmpq 0x8(%rax,%rcx), %rdi
setbe %al
jmp 0xbbe2f
movb $0x1, %al
cmpl $-0x5, %esi
jg 0xbbe2f
subl %es... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format-inl.h |
fmt::v8::detail::thousands_sep_result<char> fmt::v8::detail::thousands_sep_impl<char>(fmt::v8::detail::locale_ref) | FMT_FUNC auto thousands_sep_impl(locale_ref loc) -> thousands_sep_result<Char> {
auto& facet = std::use_facet<std::numpunct<Char>>(loc.get<std::locale>());
auto grouping = facet.grouping();
auto thousands_sep = grouping.empty() ? Char() : facet.thousands_sep();
return {std::move(grouping), thousands_sep};
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
testq %rsi, %rsi
je 0xbbeb6
callq 0xc570
jmp 0xbbebb
callq 0xd3a0
movq %rsp, %rdi
callq 0xc3d0
movq %rax, %r14
movq %rsp, %rdi
callq 0xcd80
movq (%r14), %rax
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq *0x20(%rax)
cmpq $0x0, 0x8... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format-inl.h |
char fmt::v8::detail::decimal_point_impl<char>(fmt::v8::detail::locale_ref) | Locale locale_ref::get() const {
static_assert(std::is_same<Locale, std::locale>::value, "");
return locale_ ? *static_cast<const std::locale*>(locale_) : std::locale();
} | pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0xbbf89
movq %rdi, %rsi
leaq 0x8(%rsp), %rdi
callq 0xc570
jmp 0xbbf93
leaq 0x8(%rsp), %rdi
callq 0xd3a0
leaq 0x8(%rsp), %rdi
callq 0xc3d0
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0xcd80
movl %ebx, %eax
addq $0x10, %rsp... | /johnor[P]n_e_s_vis/build_O1/_deps/fmt-src/include/fmt/format-inl.h |
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.