name string | code string | asm string | file string |
|---|---|---|---|
wabt::(anonymous namespace)::BinaryReaderObjdump::OnFuncType(unsigned int, unsigned int, wabt::Type*, unsigned int, wabt::Type*) | Result BinaryReaderObjdump::OnFuncType(Index index,
Index param_count,
Type* param_types,
Index result_count,
Type* result_types) {
if (!ShouldPrintDetails()) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5dea0
testb $0x1, %al
jne 0x5b8eb
leaq -0x4(%rbp), %rdi
xorl %esi, %esi
callq 0x566a0
jmp 0x5ba28
movl -0x14... | /dcodeIO[P]wabt/src/binary-reader-objdump.cc |
wabt::(anonymous namespace)::BinaryReaderObjdump::OnStructType(unsigned int, unsigned int, wabt::TypeMut*) | Result BinaryReaderObjdump::OnStructType(Index index,
Index field_count,
TypeMut* fields) {
if (!ShouldPrintDetails()) {
return Result::Ok;
}
printf(" - type[%" PRIindex "] (struct", index);
for (Index i = 0; i < field_count; ... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5dea0
testb $0x1, %al
jne 0x5ba73
leaq -0x4(%rbp), %rdi
xorl %esi, %esi
callq 0x566a0
jmp 0x5bb15
movl -0x14(%rbp), %esi
leaq 0x36020(%rip), %rdi # 0... | /dcodeIO[P]wabt/src/binary-reader-objdump.cc |
wabt::(anonymous namespace)::BinaryReaderObjdump::OnTable(unsigned int, wabt::Type, wabt::Limits const*) | Result BinaryReaderObjdump::OnTable(Index index,
Type elem_type,
const Limits* elem_limits) {
PrintDetails(" - table[%" PRIindex "] type=%s initial=%" PRId64, index,
elem_type.GetName(), elem_limits->initial);
if (elem_limits->ha... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x63280
movq -0x40(%rbp), %rdi
movl -0x34(%rbp), %edx
movq %rax, ... | /dcodeIO[P]wabt/src/binary-reader-objdump.cc |
wabt::(anonymous namespace)::BinaryReaderObjdump::BeginGlobal(unsigned int, wabt::Type, bool) | Result BinaryReaderObjdump::BeginGlobal(Index index, Type type, bool mutable_) {
PrintDetails(" - global[%" PRIindex "] %s mutable=%d", index, type.GetName(),
mutable_);
string_view name = GetGlobalName(index);
if (!name.empty()) {
PrintDetails(" <" PRIstringview ">", WABT_PRINTF_STRING_VIEW_AR... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movl %edx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x63280
movl -0x34(%rbp), %edx
movq -... | /dcodeIO[P]wabt/src/binary-reader-objdump.cc |
wabt::(anonymous namespace)::BinaryReaderObjdump::OnDataSegmentData(unsigned int, void const*, unsigned long) | Result BinaryReaderObjdump::OnDataSegmentData(Index index,
const void* src_data,
Address size) {
if (!ShouldPrintDetails()) {
return Result::Ok;
}
PrintDetails(" - segment[%" PRIindex "]", index);
auto name = GetSeg... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x5dea0
testb $0x1, %al
jne 0x5cb3b
leaq -0x4(%rbp), %rdi
xorl %esi, %esi
callq 0x566a0
jmp 0x5cd70
movq -0x68(%rbp), %rdi
movl -0x1... | /dcodeIO[P]wabt/src/binary-reader-objdump.cc |
wabt::(anonymous namespace)::BinaryReaderObjdump::OnReloc(wabt::RelocType, unsigned long, unsigned int, unsigned int) | Result BinaryReaderObjdump::OnReloc(RelocType type,
Offset offset,
Index index,
uint32_t addend) {
Offset total_offset = GetSectionStart(reloc_section_) + offset;
PrintDetails(" - %-18s offset=%#08" PRIoffs... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movl 0x34(%rdi), %esi
callq 0x5b0d0
addq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x14(%rbp), %edi
callq 0x5b... | /dcodeIO[P]wabt/src/binary-reader-objdump.cc |
wabt::(anonymous namespace)::BinaryReaderObjdump::OnDataSymbol(unsigned int, unsigned int, wabt::string_view, unsigned int, unsigned int, unsigned int) | Result BinaryReaderObjdump::OnDataSymbol(Index index,
uint32_t flags,
string_view name,
Index segment,
uint32_t offset,
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rcx, -0x18(%rbp)
movq %r8, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movl %esi, -0x24(%rbp)
movl %edx, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x34(%rbp)
lea... | /dcodeIO[P]wabt/src/binary-reader-objdump.cc |
wabt::(anonymous namespace)::BinaryReaderObjdump::OnGlobalSymbol(unsigned int, unsigned int, wabt::string_view, unsigned int) | Result BinaryReaderObjdump::OnGlobalSymbol(Index index,
uint32_t flags,
string_view name,
Index global_index) {
if (name.empty()) {
name = GetGlobalName(global_index);
}
PrintDetail... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rcx, -0x18(%rbp)
movq %r8, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movl %esi, -0x24(%rbp)
movl %edx, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x63240
testb $0x1, %al
jne 0x5d4f5
jmp 0x5d519
movq -0x48(%rbp)... | /dcodeIO[P]wabt/src/binary-reader-objdump.cc |
wabt::(anonymous namespace)::BinaryReaderObjdump::OnSectionSymbol(unsigned int, unsigned int, unsigned int) | Result BinaryReaderObjdump::OnSectionSymbol(Index index,
uint32_t flags,
Index section_index) {
auto sym_name = GetSectionName(section_index);
assert(!sym_name.empty());
PrintDetails(" - %d: S <" PRIstringview "> section=%" ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl -0x1c(%rbp), %esi
callq 0x5a0d0
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x63240
xorb $-0x1, %al
te... | /dcodeIO[P]wabt/src/binary-reader-objdump.cc |
wabt::(anonymous namespace)::BinaryReaderObjdump::OnTableSymbol(unsigned int, unsigned int, wabt::string_view, unsigned int) | Result BinaryReaderObjdump::OnTableSymbol(Index index,
uint32_t flags,
string_view name,
Index table_index) {
if (name.empty()) {
name = GetTableName(table_index);
}
PrintDetails(" -... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rcx, -0x18(%rbp)
movq %r8, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movl %esi, -0x24(%rbp)
movl %edx, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x63240
testb $0x1, %al
jne 0x5d715
jmp 0x5d739
movq -0x48(%rbp)... | /dcodeIO[P]wabt/src/binary-reader-objdump.cc |
wabt::(anonymous namespace)::BinaryReaderObjdump::OnComdatEntry(wabt::ComdatType, unsigned int) | Result BinaryReaderObjdump::OnComdatEntry(ComdatType kind, Index index) {
switch (kind) {
case ComdatType::Data: {
PrintDetails(" - segment[%" PRIindex "]", index);
auto name = GetSegmentName(index);
if (!name.empty()) {
PrintDetails(" <" PRIstringview ">", WABT_PRINTF_STRING_VIEW_ARG... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x3c(%rbp)
testl %eax, %eax
je 0x5d9b3
jmp 0x5d9a6
movl -0x3c(%rbp), %eax
subl $0x1, %eax
je 0x5da18
jmp 0x5da7d
movq -0x48(%r... | /dcodeIO[P]wabt/src/binary-reader-objdump.cc |
wabt::(anonymous namespace)::BinaryReaderObjdump::PrintDetails(char const*, ...) | BinaryReaderObjdump::PrintDetails(const char* fmt,
...) {
if (!ShouldPrintDetails()) {
return;
}
va_list args;
va_start(args, fmt);
vprintf(fmt, args);
va_end(args);
} | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
testb %al, %al
je 0x5de28
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %r9, -0xb8(%rbp)
movq %r8, -0xc0(%rbp... | /dcodeIO[P]wabt/src/binary-reader-objdump.cc |
wabt::(anonymous namespace)::BinaryReaderObjdump::PrintInitExpr(wabt::(anonymous namespace)::InitExpr const&) | void BinaryReaderObjdump::PrintInitExpr(const InitExpr& expr) {
switch (expr.type) {
case InitExprType::I32:
PrintDetails(" - init i32=%d\n", expr.value.i32);
break;
case InitExprType::I64:
PrintDetails(" - init i64=%" PRId64 "\n", expr.value.i64);
break;
case InitExprType::F64: {
... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x88(%rbp)
subq $0x7, %rax
ja 0x5e257
movq -0x88(%rbp), %rax
leaq 0x333b1(%rip), %rcx # 0x91394
movslq (%rcx,%rax,4), %rax
addq %... | /dcodeIO[P]wabt/src/binary-reader-objdump.cc |
wabt::(anonymous namespace)::BinaryReaderObjdump::HandleInitExpr(wabt::(anonymous namespace)::InitExpr const&) | Result BinaryReaderObjdump::HandleInitExpr(const InitExpr& expr) {
if (in_data_section_) {
data_init_expr_ = expr;
return InitExprToConstOffset(expr, &data_offset_);
} else if (in_elem_section_) {
elem_init_expr_ = expr;
return InitExprToConstOffset(expr, &elem_offset_);
} else {
PrintInitExpr... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0x104(%rax)
je 0x5e491
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, 0x108(%rdi)
movq 0x8(%rax), %rcx
movq %rcx, 0x110(%rdi)
movq 0x10(%rax), %... | /dcodeIO[P]wabt/src/binary-reader-objdump.cc |
wabt::(anonymous namespace)::BinaryReaderObjdump::InitExprToConstOffset(wabt::(anonymous namespace)::InitExpr const&, unsigned int*) | Result BinaryReaderObjdump::InitExprToConstOffset(const InitExpr& expr,
uint32_t* out_offset) {
switch (expr.type) {
case InitExprType::I32:
*out_offset = expr.value.i32;
break;
case InitExprType::Global:
*out_offset = 0;
break;
cas... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0x5e55e
jmp 0x5e53b
movl -0x24(%rbp), %eax
decl %eax
subl $0x4, %eax
jb 0x5e5... | /dcodeIO[P]wabt/src/binary-reader-objdump.cc |
wabt::Features::EnableAll() | void EnableAll() {
#define WABT_FEATURE(variable, flag, default_, help) enable_##variable();
#include "src/feature.def"
#undef WABT_FEATURE
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x5e930
movq -0x10(%rbp), %rdi
callq 0x5e950
movq -0x10(%rbp), %rdi
callq 0x5e970
movq -0x10(%rbp), %rdi
callq 0x5e990
movq -0x10(%rbp), %rdi
callq 0x5e9b0
movq -0x10(%rbp), %rdi
callq 0x5e9d0
movq -0x10... | /dcodeIO[P]wabt/src/feature.h |
wabt::Type::GetName() const | const char* GetName() const {
switch (enum_) {
case Type::I32: return "i32";
case Type::I64: return "i64";
case Type::F32: return "f32";
case Type::F64: return "f64";
case Type::V128: return "v128";
case Type::I8: return "i8";
case Type::... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
addl $0x40, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x40, %eax
ja 0x63369
movq -0x18(%rbp), %rax
leaq 0x2e1cd(%rip), %rcx # 0x91478
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x3620c(%rip), %rax ... | /dcodeIO[P]wabt/src/type.h |
wabt::Opcode::FromCode(unsigned char, unsigned int) | inline Opcode Opcode::FromCode(uint8_t prefix, uint32_t code) {
uint32_t prefix_code = PrefixCode(prefix, code);
if (WABT_LIKELY(prefix_code < WABT_ARRAY_SIZE(WabtOpcodeCodeTable))) {
uint32_t value = WabtOpcodeCodeTable[prefix_code];
// The default value in the table is 0. That's a valid value, but only i... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movl %esi, -0xc(%rbp)
movb -0x5(%rbp), %al
movl -0xc(%rbp), %esi
movzbl %al, %edi
callq 0x634c0
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpq $0x10000, %rax # imm = 0x10000
setb %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, ... | /dcodeIO[P]wabt/src/opcode.h |
wabt::Type::GetRefKindName() const | const char* GetRefKindName() const {
switch (enum_) {
case Type::FuncRef: return "func";
case Type::ExternRef: return "extern";
case Type::ExnRef: return "exn";
case Type::Struct: return "struct";
case Type::Array: return "array";
default: return "<invali... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
addl $0x22, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x12, %eax
ja 0x640c1
movq -0x18(%rbp), %rax
leaq 0x2d505(%rip), %rcx # 0x9157c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x35604(%rip), %rax ... | /dcodeIO[P]wabt/src/type.h |
wabt::GetSectionOrder(wabt::BinarySection) | BinarySectionOrder GetSectionOrder(BinarySection sec) {
switch (sec) {
#define V(Name, name, code) \
case BinarySection::Name: \
return BinarySectionOrder::Name;
WABT_FOREACH_BINARY_SECTION(V)
#undef V
default:
WABT_UNREACHABLE;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movq %rax, -0x10(%rbp)
subq $0xd, %rax
ja 0x6545e
movq -0x10(%rbp), %rax
leaq 0x2ce85(%rip), %rcx # 0x9225c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x0, -0x4(%rbp)
jmp 0x65463
movl $0x1, -0x4(%rbp)
jmp 0x6546... | /dcodeIO[P]wabt/src/binary.cc |
wabt::(anonymous namespace)::BinaryReader::BinaryReader(void const*, unsigned long, wabt::BinaryReaderDelegate*, wabt::ReadBinaryOptions const&) | BinaryReader::BinaryReader(const void* data,
size_t size,
BinaryReaderDelegate* delegate,
const ReadBinaryOptions& options)
: read_end_(size),
state_(static_cast<const uint8_t*>(data), size),
logging_delegate_(options.log_s... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x73f30
m... | /dcodeIO[P]wabt/src/binary-reader.cc |
wabt::(anonymous namespace)::BinaryReader::ReadSections() | Result BinaryReader::ReadSections() {
Result result = Result::Ok;
Index section_index = 0;
bool seen_section_code[static_cast<int>(BinarySection::Last) + 1] = {false};
for (; state_.offset < state_.size; ++section_index) {
uint8_t section_code;
Offset section_size;
CHECK_RESULT(ReadU8(§ion_code... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe8(%rbp)
leaq -0x14(%rbp), %rdi
xorl %esi, %esi
callq 0x566a0
movl $0x0, -0x18(%rbp)
leaq -0x26(%rbp), %rdi
xorl %esi, %esi
movl $0xe, %edx
callq 0x39110
movq -0xe8(%rbp), %rcx
movq 0x18(%rc... | /dcodeIO[P]wabt/src/binary-reader.cc |
wabt::Result wabt::(anonymous namespace)::BinaryReader::ReadT<unsigned int>(unsigned int*, char const*, char const*) | Result BinaryReader::ReadT(T* out_value,
const char* type_name,
const char* desc) {
if (state_.offset + sizeof(T) > read_end_) {
PrintError("unable to read %s: %s", type_name, desc);
return Result::Error;
}
#if WABT_BIG_ENDIAN
uint8_t tmp[sizeof(T)];
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq 0x18(%rcx), %rax
addq $0x4, %rax
cmpq (%rcx), %rax
jbe 0x66567
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
l... | /dcodeIO[P]wabt/src/binary-reader.cc |
wabt::GetErrorLevelName(wabt::ErrorLevel) | static WABT_INLINE const char* GetErrorLevelName(ErrorLevel error_level) {
switch (error_level) {
case ErrorLevel::Warning:
return "warning";
case ErrorLevel::Error:
return "error";
}
WABT_UNREACHABLE;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
testl %eax, %eax
je 0x665c1
jmp 0x665b7
movl -0x10(%rbp), %eax
subl $0x1, %eax
je 0x665ce
jmp 0x665db
leaq 0x2c6bc(%rip), %rax # 0x92c84
movq %rax, -0x8(%rbp)
jmp 0x665e0
leaq 0x2c6b7(%rip), %rax # 0x9... | /dcodeIO[P]wabt/src/error.h |
wabt::(anonymous namespace)::BinaryReader::ReadImportSection(unsigned long) | Result BinaryReader::ReadImportSection(Offset section_size) {
CALLBACK(BeginImportSection, section_size);
Index num_imports;
CHECK_RESULT(ReadCount(&num_imports, "import count"));
CALLBACK(OnImportCount, num_imports);
for (Index i = 0; i < num_imports; ++i) {
string_view module_name;
CHECK_RESULT(Read... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x1c0(%rbp)
movq -0x1c0(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x20(%rbp), %rsi
movq (%rdi), %rax
callq *0x78(%rax)
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), ... | /dcodeIO[P]wabt/src/binary-reader.cc |
wabt::(anonymous namespace)::BinaryReader::ReadMemorySection(unsigned long) | Result BinaryReader::ReadMemorySection(Offset section_size) {
CALLBACK(BeginMemorySection, section_size);
Index num_memories;
CHECK_RESULT(ReadCount(&num_memories, "memory count"));
CALLBACK(OnMemoryCount, num_memories);
for (Index i = 0; i < num_memories; ++i) {
Index memory_index = num_memory_imports_ +... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *0x100(%rax)
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
callq 0x742a0
xorb $-0x1, %al
tes... | /dcodeIO[P]wabt/src/binary-reader.cc |
wabt::Result wabt::(anonymous namespace)::BinaryReader::ReadT<unsigned char>(unsigned char*, char const*, char const*) | Result BinaryReader::ReadT(T* out_value,
const char* type_name,
const char* desc) {
if (state_.offset + sizeof(T) > read_end_) {
PrintError("unable to read %s: %s", type_name, desc);
return Result::Error;
}
#if WABT_BIG_ENDIAN
uint8_t tmp[sizeof(T)];
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq 0x18(%rcx), %rax
addq $0x1, %rax
cmpq (%rcx), %rax
jbe 0x6a257
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
l... | /dcodeIO[P]wabt/src/binary-reader.cc |
wabt::(anonymous namespace)::BinaryReader::ReadStr(wabt::string_view*, char const*) | Result BinaryReader::ReadStr(string_view* out_str, const char* desc) {
uint32_t str_len = 0;
CHECK_RESULT(ReadU32Leb128(&str_len, "string length"));
ERROR_UNLESS(state_.offset + str_len <= read_end_,
"unable to read string: %s", desc);
*out_str = string_view(
reinterpret_cast<const char*>... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x40(%rbp), %rdi
leaq -0x24(%rbp), %rsi
leaq 0x28aa2(%rip), %rdx # 0x92e04
callq 0x6a290
movl %eax, -0x28(%rbp)
movl -0x28(%rbp)... | /dcodeIO[P]wabt/src/binary-reader.cc |
wabt::(anonymous namespace)::BinaryReader::ReadDylinkSection(unsigned long) | Result BinaryReader::ReadDylinkSection(Offset section_size) {
CALLBACK(BeginDylinkSection, section_size);
uint32_t mem_size;
uint32_t mem_align;
uint32_t table_size;
uint32_t table_align;
CHECK_RESULT(ReadU32Leb128(&mem_size, "mem_size"));
CHECK_RESULT(ReadU32Leb128(&mem_align, "mem_align"));
CHECK_RES... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
movq 0x48(%rax), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *0x580(%rax)
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
callq 0x742a0
xorb $-0x1, %al
tes... | /dcodeIO[P]wabt/src/binary-reader.cc |
wabt::(anonymous namespace)::BinaryReader::ReadCount(unsigned int*, char const*) | Result BinaryReader::ReadCount(Index* count, const char* desc) {
CHECK_RESULT(ReadIndex(count, desc));
// This check assumes that each item follows in this section, and takes at
// least 1 byte. It's possible that this check passes but reading fails
// later. It is still useful to check here, though, because i... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x6d0b0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %edi
callq 0x56630
testb $0x1, %al
jn... | /dcodeIO[P]wabt/src/binary-reader.cc |
wabt::(anonymous namespace)::BinaryReader::ReadS32Leb128(unsigned int*, char const*) | Result BinaryReader::ReadS32Leb128(uint32_t* out_value, const char* desc) {
const uint8_t* p = state_.data + state_.offset;
const uint8_t* end = state_.data + read_end_;
size_t bytes_read = wabt::ReadS32Leb128(p, end, out_value);
ERROR_UNLESS(bytes_read > 0, "unable to read i32 leb128: %s", desc);
state_.offs... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movq 0x8(%rcx), %rax
addq 0x18(%rcx), %rax
movq %rax, -0x28(%rbp)
movq 0x8(%rcx), %rax
addq (%rcx), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30... | /dcodeIO[P]wabt/src/binary-reader.cc |
wabt::(anonymous namespace)::BinaryReader::ReadS64Leb128(unsigned long*, char const*) | Result BinaryReader::ReadS64Leb128(uint64_t* out_value, const char* desc) {
const uint8_t* p = state_.data + state_.offset;
const uint8_t* end = state_.data + read_end_;
size_t bytes_read = wabt::ReadS64Leb128(p, end, out_value);
ERROR_UNLESS(bytes_read > 0, "unable to read i64 leb128: %s", desc);
state_.offs... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movq 0x8(%rcx), %rax
addq 0x18(%rcx), %rax
movq %rax, -0x28(%rbp)
movq 0x8(%rcx), %rax
addq (%rcx), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30... | /dcodeIO[P]wabt/src/binary-reader.cc |
wabt::BinaryReaderLogging::OnImportMemory(unsigned int, wabt::string_view, wabt::string_view, unsigned int, wabt::Limits const*) | Result BinaryReaderLogging::OnImportMemory(Index import_index,
string_view module_name,
string_view field_name,
Index memory_index,
const Limits* pa... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq 0x18(%rbp), %rax
movl 0x10(%rbp), %eax
movq %rdx, -0x18(%rbp)
movq %rcx, -0x10(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x20(%rbp)
movq %rdi, -0x30(%rbp)
movl %esi, -0x34(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0xa0(%rbp), %rdi
movq 0x18(%rbp), %rdx
movl ... | /dcodeIO[P]wabt/src/binary-reader-logging.cc |
wabt::BinaryReaderLogging::OnImportGlobal(unsigned int, wabt::string_view, wabt::string_view, unsigned int, wabt::Type, bool) | Result BinaryReaderLogging::OnImportGlobal(Index import_index,
string_view module_name,
string_view field_name,
Index global_index,
Type type,
... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0xa8, %rsp
movq %rcx, -0x80(%rbp)
movq %rdx, %r10
movq -0x80(%rbp), %rdx
movb 0x20(%rbp), %al
movl 0x18(%rbp), %ecx
movl 0x10(%rbp), %r11d
movq %r10, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x28(%rbp)
movl %ecx, -0x34(%rbp)
movq %rdi, -0x40(%rbp)
m... | /dcodeIO[P]wabt/src/binary-reader-logging.cc |
wabt::BinaryReaderLogging::OnBrTableExpr(unsigned int, unsigned int*, unsigned int) | Result BinaryReaderLogging::OnBrTableExpr(Index num_targets,
Index* target_depths,
Index default_target_depth) {
LOGF("OnBrTableExpr(num_targets: %" PRIindex ", depths: [", num_targets);
for (Index i = 0; i < num_targets; ++i) {
... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x77440
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0x14(%rbp), %edx
leaq 0x1d5fb(%rip), %rsi # 0x... | /dcodeIO[P]wabt/src/binary-reader-logging.cc |
wabt::BinaryReaderLogging::OnInitExprF64ConstExpr(unsigned int, unsigned long) | Result BinaryReaderLogging::OnInitExprF64ConstExpr(Index index,
uint64_t value_bits) {
double value;
memcpy(&value, &value_bits, sizeof(value));
LOGF("OnInitExprF64ConstExpr(index: %" PRIindex " value: %g (0x08%" PRIx64
"))\n",
index, value, value_b... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rdi
callq 0x77440
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0x14(%rbp), %edx
movsd -0x2... | /dcodeIO[P]wabt/src/binary-reader-logging.cc |
wabt::OptionParser::OptionParser(char const*, char const*) | OptionParser::OptionParser(const char* program_name, const char* description)
: program_name_(program_name),
description_(description),
on_error_([this](const std::string& message) { DefaultError(message); }) {
// Add common options
AddOption("help", "Print this help message", [this]() {
PrintH... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x39410
movq -0x98(%rbp), %rsi
movq -0x80(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x393... | /dcodeIO[P]wabt/src/option-parser.cc |
wabt::OptionParser::HandleArgument(unsigned long*, char const*) | void OptionParser::HandleArgument(size_t* arg_index, const char* arg_value) {
if (*arg_index >= arguments_.size()) {
Errorf("unexpected argument '%s'", arg_value);
return;
}
Argument& argument = arguments_[*arg_index];
argument.callback(arg_value);
argument.handled_count++;
if (argument.count == Ar... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
addq $0x58, %rdi
callq 0x8b4c0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jb 0x89524
mo... | /dcodeIO[P]wabt/src/option-parser.cc |
wabt::OptionParser::Parse(int, char**) | void OptionParser::Parse(int argc, char* argv[]) {
size_t arg_index = 0;
bool processing_options = true;
for (int i = 1; i < argc; ++i) {
const char* arg = argv[i];
if (!processing_options || arg[0] != '-') {
// Non-option argument.
HandleArgument(&arg_index, arg);
continue;
}
... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq $0x0, -0x20(%rbp)
movb $0x1, -0x21(%rbp)
movl $0x1, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x89a34
movq -0x18(%rbp), %rax
movslq -0x28(%r... | /dcodeIO[P]wabt/src/option-parser.cc |
wabt::Stream::Truncate(unsigned long) | void Stream::Truncate(size_t size) {
if (Failed(result_)) {
return;
}
if (log_stream_) {
log_stream_->Writef("; truncate to %" PRIzd " (0x%" PRIzx ")\n", size,
size);
}
result_ = TruncateImpl(size);
if (Succeeded(result_) && offset_ > size) {
offset_ = size;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl 0x10(%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
callq 0x56630
testb $0x1, %al
jne 0x8d39c
jmp 0x8d39e
jmp 0x8d412
movq -0x28(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x8d... | /dcodeIO[P]wabt/src/stream.cc |
wabt::FileStream::FileStream(wabt::string_view, wabt::Stream*) | FileStream::FileStream(string_view filename, Stream* log_stream)
: Stream(log_stream), file_(nullptr), offset_(0), should_close_(false) {
std::string filename_str = filename.to_string();
file_ = fopen(filename_str.c_str(), "wb");
// TODO(binji): this is pretty cheesy, should come up with a better API.
if (... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq -0x20(%rbp), %rsi
callq 0x8cdc0
movq -0x48(%rbp), %rax
leaq 0x2d31c(%rip), %rcx # 0xbad30
addq $0x10, %rcx
movq %rcx, (%rax)
movq ... | /dcodeIO[P]wabt/src/stream.cc |
wabt::string_view::rfind(wabt::string_view, unsigned long) const | string_view::size_type string_view::rfind(string_view s, size_type pos) const
noexcept {
pos = std::min(std::min(pos, size_ - s.size_) + s.size_, size_);
reverse_iterator iter = std::search(reverse_iterator(begin() + pos), rend(),
s.rbegin(), s.rend());
return iter == ren... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
movq 0x8(%rax), %rax
subq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x58090
movq -0x70(%r... | /dcodeIO[P]wabt/src/string-view.cc |
wabt::string_view::find_first_of(wabt::string_view, unsigned long) const | string_view::size_type string_view::find_first_of(string_view s,
size_type pos) const
noexcept {
pos = std::min(pos, size_);
const_iterator iter =
std::find_first_of(begin() + pos, end(), s.begin(), s.end());
return iter == end() ? npos : iter - begin();... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rsi
movq %rsi, -0x38(%rbp)
addq $0x8, %rsi
leaq -0x20(%rbp), %rdi
callq 0x58090
movq -0x38(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x20(%rbp)
callq 0x8f890
movq -0x... | /dcodeIO[P]wabt/src/string-view.cc |
wabt::string_view::find_last_of(wabt::string_view, unsigned long) const | string_view::size_type string_view::find_last_of(string_view s,
size_type pos) const noexcept {
pos = std::min(pos, size_ - 1);
reverse_iterator iter = std::find_first_of(
reverse_iterator(begin() + (pos + 1)), rend(), s.begin(), s.end());
return iter == rend... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq 0x8(%rax), %rax
subq $0x1, %rax
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x58090
movq -0x58(%rbp), %... | /dcodeIO[P]wabt/src/string-view.cc |
ImGui::CalcTextSize(char const*, char const*, bool, float) | ImVec2 ImGui::CalcTextSize(const char* text, const char* text_end, bool hide_text_after_double_hash, float wrap_width)
{
ImGuiContext& g = *GImGui;
const char* text_display_end;
if (hide_text_after_double_hash)
text_display_end = FindRenderedTextEnd(text, text_end); // Hide anything after a '#... | subq $0x48, %rsp
movb %dl, %al
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movss %xmm0, 0x28(%rsp)
movq 0x101d45(%rip), %rax # 0x118c68
movq %rax, 0x20(%rsp)
testb $0x1, 0x2f(%rsp)
je 0x16f45
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x16570
movq %rax, 0x18(%rsp)
jmp 0x16f... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::RenderFrame(ImVec2, ImVec2, unsigned int, bool, float) | void ImGui::RenderFrame(ImVec2 p_min, ImVec2 p_max, ImU32 fill_col, bool border, float rounding)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
window->DrawList->AddRectFilled(p_min, p_max, fill_col, rounding);
const float border_size = g.Style.FrameBorderSize;
if (border && bor... | subq $0x88, %rsp
movb %sil, %al
movlpd %xmm0, 0x80(%rsp)
movlpd %xmm1, 0x78(%rsp)
movl %edi, 0x74(%rsp)
andb $0x1, %al
movb %al, 0x73(%rsp)
movss %xmm2, 0x6c(%rsp)
movq 0x101428(%rip), %rax # 0x118c68
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq 0x3ea8(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::RenderMouseCursor(ImVec2, float, int, unsigned int, unsigned int, unsigned int) | void ImGui::RenderMouseCursor(ImVec2 base_pos, float base_scale, ImGuiMouseCursor mouse_cursor, ImU32 col_fill, ImU32 col_border, ImU32 col_shadow)
{
ImGuiContext& g = *GImGui;
IM_ASSERT(mouse_cursor > ImGuiMouseCursor_None && mouse_cursor < ImGuiMouseCursor_COUNT);
for (int n = 0; n < g.Viewports.Size; n++... | subq $0x1d8, %rsp # imm = 0x1D8
movlpd %xmm0, 0x1d0(%rsp)
movss %xmm1, 0x1cc(%rsp)
movl %edi, 0x1c8(%rsp)
movl %esi, 0x1c4(%rsp)
movl %edx, 0x1c0(%rsp)
movl %ecx, 0x1bc(%rsp)
movq 0x100dcc(%rip), %rax # 0x118c68
movq %rax, 0x1b0(%rsp)
movl $0x0, 0x1ac(%rsp)
movl 0x1ac(%rsp), %eax
movq 0x1b0(%rsp), %rcx
cm... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::DebugHookIdInfo(unsigned int, int, void const*, void const*) | void ImGui::DebugHookIdInfo(ImGuiID id, ImGuiDataType data_type, const void* data_id, const void* data_id_end)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
ImGuiStackTool* tool = &g.DebugStackTool;
// Step 0: stack query
// This assume that the ID was computed with the curren... | subq $0xb8, %rsp
movl %edi, 0xb4(%rsp)
movl %esi, 0xb0(%rsp)
movq %rdx, 0xa8(%rsp)
movq %rcx, 0xa0(%rsp)
movq 0x1001ac(%rip), %rax # 0x118c68
movq %rax, 0x98(%rsp)
movq 0x98(%rsp), %rax
movq 0x3ea8(%rax), %rax
movq %rax, 0x90(%rsp)
movq 0x98(%rsp), %rax
addq $0x5438, %rax # imm = 0x5438
movq %rax, 0x88(%rs... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGuiWindow::GetIDNoKeepAlive(void const*) | ImGuiID ImGuiWindow::GetIDNoKeepAlive(const void* ptr)
{
ImGuiID seed = IDStack.back();
ImGuiID id = ImHashData(&ptr, sizeof(void*), seed);
ImGuiContext& g = *GImGui;
if (g.DebugHookIdInfo == id)
ImGui::DebugHookIdInfo(id, ImGuiDataType_Pointer, ptr, NULL);
return id;
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
addq $0xc8, %rdi
callq 0x3e8a0
movl (%rax), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %edx
leaq 0x18(%rsp), %rdi
movl $0x8, %esi
callq 0x12660
movl %eax, 0x10(%rsp)
movq 0xffce5(%rip), %rax # 0x118c68
movq %rax, 0x8(%rsp)
movq 0x8(... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::IsMouseHoveringRect(ImVec2 const&, ImVec2 const&, bool) | bool ImGui::IsMouseHoveringRect(const ImVec2& r_min, const ImVec2& r_max, bool clip)
{
ImGuiContext& g = *GImGui;
// Clip
ImRect rect_clipped(r_min, r_max);
if (clip)
rect_clipped.ClipWith(g.CurrentWindow->ClipRect);
// Expand for touch input
const ImRect rect_for_touch(rect_clipped.Mi... | subq $0x58, %rsp
movb %dl, %al
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
andb $0x1, %al
movb %al, 0x3f(%rsp)
movq 0xff29b(%rip), %rax # 0x118c68
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
leaq 0x20(%rsp), %rdi
callq 0x411d0
testb $0x1, 0x3f(%rsp)
je 0x19a0a
movq 0x30(%rsp), %rax
movq 0x3ea8... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::CreateContext(ImFontAtlas*) | ImGuiContext* ImGui::CreateContext(ImFontAtlas* shared_font_atlas)
{
ImGuiContext* ctx = IM_NEW(ImGuiContext)(shared_font_atlas);
if (GImGui == NULL)
SetCurrentContext(ctx);
Initialize(ctx);
return ctx;
} | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl $0x6260, %edi # imm = 0x6260
movq %rdi, 0x8(%rsp)
callq 0x11f10
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq %rsi, %rax
movq %rax, 0x10(%rsp)
callq 0x3ec90
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rsi
callq 0x3eca0
jmp 0x19e54
movq 0x18(%... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::RemoveContextHook(ImGuiContext*, unsigned int) | void ImGui::RemoveContextHook(ImGuiContext* ctx, ImGuiID hook_id)
{
ImGuiContext& g = *ctx;
IM_ASSERT(hook_id != 0);
for (int n = 0; n < g.Hooks.Size; n++)
if (g.Hooks[n].HookId == hook_id)
g.Hooks[n].Type = ImGuiContextHookType_PendingRemoval_;
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x53c0(%rcx), %eax
jge 0x1a458
movq 0x10(%rsp), %rdi
addq $0x53c0, %rdi # imm = 0x53C0
movl 0xc(%rsp), %esi
callq 0x40060
movl (%rax), %... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::StartMouseMovingWindow(ImGuiWindow*) | void ImGui::StartMouseMovingWindow(ImGuiWindow* window)
{
// Set ActiveId even if the _NoMove flag is set. Without it, dragging away from a window with _NoMove would activate hover on other windows.
// We _also_ call this when clicking in a window empty space when io.ConfigWindowsMoveFromTitleBarOnly is set, bu... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0xfe4b8(%rip), %rax # 0x118c68
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1a870
movq 0x20(%rsp), %rsi
movl 0x54(%rsi), %edi
callq 0x19210
movq 0x18(%rsp), %rax
movb $0x1, 0x40fa(%rax)
movq 0x18(%rsp), %rdi
addq $0x3660, %rdi # imm = 0x3660
movq 0x20(%rs... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::SetActiveIdUsingNavAndKeys() | void ImGui::SetActiveIdUsingNavAndKeys()
{
ImGuiContext& g = *GImGui;
IM_ASSERT(g.ActiveId != 0);
g.ActiveIdUsingNavDirMask = ~(ImU32)0;
g.ActiveIdUsingNavInputMask = ~(ImU32)0;
g.ActiveIdUsingKeyInputMask.SetAllBits();
NavMoveRequestCancel();
} | pushq %rax
movq 0xfe220(%rip), %rax # 0x118c68
movq %rax, (%rsp)
movq (%rsp), %rax
movl $0xffffffff, 0x3f08(%rax) # imm = 0xFFFFFFFF
movq (%rsp), %rax
movl $0xffffffff, 0x3f0c(%rax) # imm = 0xFFFFFFFF
movq (%rsp), %rdi
addq $0x3f10, %rdi # imm = 0x3F10
callq 0x41170
callq 0x251e0
popq %rax
retq
nop
| /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::UpdateMouseMovingWindowEndFrame() | void ImGui::UpdateMouseMovingWindowEndFrame()
{
ImGuiContext& g = *GImGui;
if (g.ActiveId != 0 || g.HoveredId != 0)
return;
// Unless we just made a window/popup appear
if (g.NavWindow && g.NavWindow->Appearing)
return;
// Click on empty space to focus window and start moving
/... | subq $0x58, %rsp
movq 0xfde7d(%rip), %rax # 0x118c68
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
cmpl $0x0, 0x3ef4(%rax)
jne 0x1ae0c
movq 0x50(%rsp), %rax
cmpl $0x0, 0x3ee0(%rax)
je 0x1ae11
jmp 0x1b04e
movq 0x50(%rsp), %rax
cmpq $0x0, 0x40b8(%rax)
je 0x1ae3a
movq 0x50(%rsp), %rax
movq 0x40b8(%rax), %rax
testb $0x1,... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::GetTopMostPopupModal() | ImGuiWindow* ImGui::GetTopMostPopupModal()
{
ImGuiContext& g = *GImGui;
for (int n = g.OpenPopupStack.Size - 1; n >= 0; n--)
if (ImGuiWindow* popup = g.OpenPopupStack.Data[n].Window)
if (popup->Flags & ImGuiWindowFlags_Modal)
return popup;
return NULL;
} | movq 0xfdad1(%rip), %rax # 0x118c68
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
movl 0x4080(%rax), %eax
subl $0x1, %eax
movl %eax, -0x14(%rsp)
cmpl $0x0, -0x14(%rsp)
jl 0x1b20d
movq -0x10(%rsp), %rax
movq 0x4088(%rax), %rax
movslq -0x14(%rsp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::ClosePopupsOverWindow(ImGuiWindow*, bool) | void ImGui::ClosePopupsOverWindow(ImGuiWindow* ref_window, bool restore_focus_to_window_under_popup)
{
ImGuiContext& g = *GImGui;
if (g.OpenPopupStack.Size == 0)
return;
// Don't close our own child popup windows.
int popup_count_to_keep = 0;
if (ref_window)
{
// Find the highes... | subq $0x38, %rsp
movb %sil, %al
movq %rdi, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movq 0xfd95f(%rip), %rax # 0x118c68
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpl $0x0, 0x4080(%rax)
jne 0x1b321
jmp 0x1b43d
movl $0x0, 0x1c(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x1b41a
jmp 0x1b337
movl 0x1c(%rsp), %eax
movq 0x20... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::UpdateHoveredWindowAndCaptureFlags() | void ImGui::UpdateHoveredWindowAndCaptureFlags()
{
ImGuiContext& g = *GImGui;
ImGuiIO& io = g.IO;
g.WindowsHoverPadding = ImMax(g.Style.TouchExtraPadding, ImVec2(WINDOWS_HOVER_PADDING, WINDOWS_HOVER_PADDING));
// Find the window hovered by mouse:
// - Child windows can extend beyond the limit of th... | subq $0x68, %rsp
movq 0xfd80d(%rip), %rax # 0x118c68
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rax
addq $0x385c, %rax # imm = 0x385C
movq %rax, 0x10(%rsp)
leaq 0x48(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movss 0xc1d58(%rip), %xmm1 # 0xdd1e8
movaps %x... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::IsWindowWithinBeginStackOf(ImGuiWindow*, ImGuiWindow*) | bool ImGui::IsWindowWithinBeginStackOf(ImGuiWindow* window, ImGuiWindow* potential_parent)
{
if (window->RootWindow == potential_parent)
return true;
while (window != NULL)
{
if (window == potential_parent)
return true;
window = window->ParentWindowInBeginStack;
}
... | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq 0x350(%rax), %rax
cmpq -0x18(%rsp), %rax
jne 0x1bcd4
movb $0x1, -0x1(%rsp)
jmp 0x1bd09
jmp 0x1bcd6
cmpq $0x0, -0x10(%rsp)
je 0x1bd04
movq -0x10(%rsp), %rax
cmpq -0x18(%rsp), %rax
jne 0x1bcf1
movb $0x1, -0x1(%rsp)
jmp 0x1bd09
movq -0x10(%rsp), %ra... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::GetMergedKeyModFlags() | ImGuiKeyModFlags ImGui::GetMergedKeyModFlags()
{
ImGuiContext& g = *GImGui;
ImGuiKeyModFlags key_mod_flags = ImGuiKeyModFlags_None;
if (g.IO.KeyCtrl) { key_mod_flags |= ImGuiKeyModFlags_Ctrl; }
if (g.IO.KeyShift) { key_mod_flags |= ImGuiKeyModFlags_Shift; }
if (g.IO.KeyAlt) { key_mod_flags |= ... | movq 0xfcf51(%rip), %rax # 0x118c68
movq %rax, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
movq -0x8(%rsp), %rax
testb $0x1, 0xdac(%rax)
je 0x1bd3d
movl -0xc(%rsp), %eax
orl $0x1, %eax
movl %eax, -0xc(%rsp)
movq -0x8(%rsp), %rax
testb $0x1, 0xdad(%rax)
je 0x1bd56
movl -0xc(%rsp), %eax
orl $0x2, %eax
movl %eax, -0xc(%rsp)
movq... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::ErrorCheckNewFrameSanityChecks() | static void ImGui::ErrorCheckNewFrameSanityChecks()
{
ImGuiContext& g = *GImGui;
// Check user IM_ASSERT macro
// (IF YOU GET A WARNING OR COMPILE ERROR HERE: it means your assert macro is incorrectly defined!
// If your macro uses multiple statements, it NEEDS to be surrounded by a 'do { ... } while ... | movq 0xfc0d1(%rip), %rax # 0x118c68
movq %rax, -0x8(%rsp)
movl $0x200, -0xc(%rsp) # imm = 0x200
cmpl $0x285, -0xc(%rsp) # imm = 0x285
jge 0x1cbbd
jmp 0x1cbb0
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x1cba4
movq -0x8(%rsp), %rax
movl 0x8(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
j... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::UpdateSettings() | void ImGui::UpdateSettings()
{
// Load settings on first frame (if not explicitly loaded manually before)
ImGuiContext& g = *GImGui;
if (!g.SettingsLoaded)
{
IM_ASSERT(g.SettingsWindows.empty());
if (g.IO.IniFilename)
LoadIniSettingsFromDisk(g.IO.IniFilename);
g.Setti... | pushq %rax
movq 0xfc050(%rip), %rax # 0x118c68
movq %rax, (%rsp)
movq (%rsp), %rax
testb $0x1, 0x5379(%rax)
jne 0x1cc4c
movq (%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x1cc41
movq (%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x329c0
movq (%rsp), %rax
movb $0x1, 0x5379(%rax)
movq (%rsp), %rax
movss 0x537c(%rax), %xmm0
xorps... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::SetCurrentFont(ImFont*) | void ImGui::SetCurrentFont(ImFont* font)
{
ImGuiContext& g = *GImGui;
IM_ASSERT(font && font->IsLoaded()); // Font Atlas not created. Did you call io.Fonts->GetTexDataAsRGBA32 / GetTexDataAsAlpha8 ?
IM_ASSERT(font->Scale > 0.0f);
g.Font = font;
g.FontBaseSize = ImMax(1.0f, g.IO.FontGlobalScale * ... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0xfbe58(%rip), %rax # 0x118c68
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x3c10(%rax)
movq 0x18(%rsp), %rax
movss 0x58(%rax), %xmm1
movq 0x18(%rsp), %rax
movq 0x3c10(%rax), %rax
mulss 0x14(%rax), %xmm1
movq 0x18(%rsp), %rax
movq 0x3c10(%... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::UpdateKeyboardInputs() | static void ImGui::UpdateKeyboardInputs()
{
ImGuiContext& g = *GImGui;
ImGuiIO& io = g.IO;
// Import legacy keys or verify they are not used
#ifndef IMGUI_DISABLE_OBSOLETE_KEYIO
if (io.BackendUsingLegacyKeyArrays == 0)
{
// Backend used new io.AddKeyEvent() API: Good! Verify that old arrays... | subq $0x48, %rsp
movq 0xfb5ad(%rip), %rax # 0x118c68
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movsbl 0x37b9(%rax), %eax
cmpl $0x0, %eax
jne 0x1d705
movl $0x0, 0x34(%rsp)
cmpl $0x200, 0x34(%rsp) # imm = 0x200
jge 0x1d700
jmp 0x1d6f3
movl 0x34(%rsp),... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::UpdateMouseWheel() | void ImGui::UpdateMouseWheel()
{
ImGuiContext& g = *GImGui;
// Reset the locked window if we move the mouse or after the timer elapses
if (g.WheelingWindow != NULL)
{
g.WheelingWindowTimer -= g.IO.DeltaTime;
if (IsMousePosValid() && ImLengthSqr(g.IO.MousePos - g.WheelingWindowRefMousePo... | subq $0xb8, %rsp
movq 0xf9bba(%rip), %rax # 0x118c68
movq %rax, 0xb0(%rsp)
movq 0xb0(%rsp), %rax
cmpq $0x0, 0x3ec8(%rax)
je 0x1f1be
movq 0xb0(%rsp), %rax
movss 0x18(%rax), %xmm1
movq 0xb0(%rsp), %rax
movss 0x3ed8(%rax), %xmm0
subss %xmm1, %xmm0
movss %xmm0, 0x3ed8(%rax)
xorl %eax, %eax
movl %eax, %edi
callq 0x1abe0... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::FocusTopMostWindowUnderOne(ImGuiWindow*, ImGuiWindow*) | void ImGui::FocusTopMostWindowUnderOne(ImGuiWindow* under_this_window, ImGuiWindow* ignore_window)
{
ImGuiContext& g = *GImGui;
int start_idx = g.WindowsFocusOrder.Size - 1;
if (under_this_window != NULL)
{
// Aim at root window behind us, if we are in a child window that's our own root (see #46... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0xf9383(%rip), %rax # 0x118c68
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movl 0x3e58(%rax), %eax
subl $0x1, %eax
movl %eax, 0x1c(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x1f94b
movl $0xffffffff, 0x18(%rsp) # imm = 0xFFFFFFFF
movq 0x30(%rsp), %rax
movl 0xc(%... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::UpdateDebugToolStackQueries() | void ImGui::UpdateDebugToolStackQueries()
{
ImGuiContext& g = *GImGui;
ImGuiStackTool* tool = &g.DebugStackTool;
// Clear hook when stack tool is not visible
g.DebugHookIdInfo = 0;
if (g.FrameCount != tool->LastActiveFrame + 1)
return;
// Update queries. The steps are: -1: query Stack,... | subq $0x28, %rsp
movq 0xf917d(%rip), %rax # 0x118c68
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x5438, %rax # imm = 0x5438
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movl $0x0, 0x3edc(%rax)
movq 0x20(%rsp), %rax
movl 0x3e28(%rax), %eax
movq 0x18(%rsp), %rcx
movl (%rcx), %ecx
addl $0x1, %ecx
cmpl ... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
WindowSettingsHandler_ReadOpen(ImGuiContext*, ImGuiSettingsHandler*, char const*) | static void* WindowSettingsHandler_ReadOpen(ImGuiContext*, ImGuiSettingsHandler*, const char* name)
{
ImGuiWindowSettings* settings = ImGui::FindOrCreateWindowSettings(name);
ImGuiID id = settings->ID;
*settings = ImGuiWindowSettings(); // Clear existing if recycling previous entry
settings->ID = id;
... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x32810
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x14(%rsp)
leaq 0x4(%rsp), %rdi
callq 0x41fe0
movq 0x18(%rsp), %rax
movq 0x4(%rsp), %rcx
movq %rcx, (%rax)
movl 0xc(%rsp), %ecx
... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
WindowSettingsHandler_ApplyAll(ImGuiContext*, ImGuiSettingsHandler*) | static void WindowSettingsHandler_ApplyAll(ImGuiContext* ctx, ImGuiSettingsHandler*)
{
ImGuiContext& g = *ctx;
for (ImGuiWindowSettings* settings = g.SettingsWindows.begin(); settings != NULL; settings = g.SettingsWindows.next_chunk(settings))
if (settings->WantApply)
{
if (ImGuiWind... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
addq $0x53a0, %rdi # imm = 0x53A0
callq 0x42030
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x2347e
movq 0x8(%rsp), %rax
testb $0x1, 0xd(%rax)
je 0x2345f
movq 0x8(%rsp), %rax
movl (%... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::SaveIniSettingsToDisk(char const*) | void ImGui::SaveIniSettingsToDisk(const char* ini_filename)
{
ImGuiContext& g = *GImGui;
g.SettingsDirtyTimer = 0.0f;
if (!ini_filename)
return;
size_t ini_data_size = 0;
const char* ini_data = SaveIniSettingsToMemory(&ini_data_size);
ImFileHandle f = ImFileOpen(ini_filename, "wt");
... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0xf5538(%rip), %rax # 0x118c68
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x537c(%rax)
cmpq $0x0, 0x20(%rsp)
jne 0x2374f
jmp 0x237a6
movq $0x0, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x32ef0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
leaq ... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::ErrorCheckEndFrameSanityChecks() | static void ImGui::ErrorCheckEndFrameSanityChecks()
{
ImGuiContext& g = *GImGui;
// Verify that io.KeyXXX fields haven't been tampered with. Key mods should not be modified between NewFrame() and EndFrame()
// One possible reason leading to this assert is that your backends update inputs _AFTER_ NewFrame()... | subq $0x18, %rsp
movq 0xf4d7d(%rip), %rax # 0x118c68
movq %rax, 0x10(%rsp)
callq 0x1bd10
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x1, 0x3e78(%rax)
je 0x23f32
movq 0x10(%rsp), %rax
cmpl $0x1, 0x3e78(%rax)
jle 0x23f2e
jmp 0x23f17
movq 0x10(%rsp), %rax
cmpl $0x1, 0x3e78(%rax)
jle 0x23f2c
callq 0x23f70
jmp 0x2... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::ClearDragDrop() | void ImGui::ClearDragDrop()
{
ImGuiContext& g = *GImGui;
g.DragDropActive = false;
g.DragDropPayload.Clear();
g.DragDropAcceptFlags = ImGuiDragDropFlags_None;
g.DragDropAcceptIdCurr = g.DragDropAcceptIdPrev = 0;
g.DragDropAcceptIdCurrRectSurface = FLT_MAX;
g.DragDropAcceptFrameCount = -1;
... | pushq %rax
movq 0xf4ad0(%rip), %rax # 0x118c68
movq %rax, (%rsp)
movq (%rsp), %rax
movb $0x0, 0x424c(%rax)
movq (%rsp), %rdi
addq $0x4260, %rdi # imm = 0x4260
callq 0x41da0
movq (%rsp), %rax
movl $0x0, 0x42b4(%rax)
movq (%rsp), %rax
movl $0x0, 0x42c0(%rax)
movq (%rsp), %rax
movl $0x0, 0x42bc(%rax)
movq (%... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::RenderDimmedBackgrounds() | static void ImGui::RenderDimmedBackgrounds()
{
ImGuiContext& g = *GImGui;
ImGuiWindow* modal_window = GetTopMostAndVisiblePopupModal();
if (g.DimBgRatio <= 0.0f && g.NavWindowingHighlightAlpha <= 0.0f)
return;
const bool dim_bg_for_modal = (modal_window != NULL);
const bool dim_bg_for_window... | subq $0x98, %rsp
movq 0xf43da(%rip), %rax # 0x118c68
movq %rax, 0x90(%rsp)
callq 0x2eda0
movq %rax, 0x88(%rsp)
movq 0x90(%rsp), %rax
xorps %xmm0, %xmm0
ucomiss 0x4244(%rax), %xmm0
jb 0x248d0
movq 0x90(%rsp), %rax
xorps %xmm0, %xmm0
ucomiss 0x423c(%rax), %xmm0
jb 0x248d0
jmp 0x24b6f
cmpq $0x0, 0x88(%rsp)
setne %al
a... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::FindBestWindowPosForPopup(ImGuiWindow*) | ImVec2 ImGui::FindBestWindowPosForPopup(ImGuiWindow* window)
{
ImGuiContext& g = *GImGui;
ImRect r_outer = GetPopupAllowedExtentRect(window);
if (window->Flags & ImGuiWindowFlags_ChildMenu)
{
// Child menus typically request _any_ position within the parent menu item, and then we move the new m... | subq $0xd8, %rsp
movq %rdi, 0xc8(%rsp)
movq 0xf1892(%rip), %rax # 0x118c68
movq %rax, 0xc0(%rsp)
movq 0xc8(%rsp), %rdi
callq 0x30570
movlpd %xmm0, 0xb0(%rsp)
movlpd %xmm1, 0xb8(%rsp)
movq 0xc8(%rsp), %rax
movl 0xc(%rax), %eax
andl $0x10000000, %eax # imm = 0x10000000
cmpl $0x0, %eax
je 0x2759c
movq 0xc0(%rsp)... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::LogFinish() | void ImGui::LogFinish()
{
ImGuiContext& g = *GImGui;
if (!g.LogEnabled)
return;
LogText(IM_NEWLINE);
switch (g.LogType)
{
case ImGuiLogType_TTY:
#ifndef IMGUI_DISABLE_TTY_FUNCTIONS
fflush(g.LogFile);
#endif
break;
case ImGuiLogType_File:
ImFileClose(g.LogFile... | subq $0x18, %rsp
movq 0xeeebd(%rip), %rax # 0x118c68
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, 0x53d4(%rax)
jne 0x29dc3
jmp 0x29e92
leaq 0xcd7dd(%rip), %rdi # 0xf75a7
xorl %eax, %eax
callq 0x32090
movq 0x10(%rsp), %rax
movl 0x53d8(%rax), %eax
movq %rax, 0x8(%rsp)
subq $0x4, %rax
ja 0x29e56
movq 0x... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::BringWindowToDisplayBack(ImGuiWindow*) | void ImGui::BringWindowToDisplayBack(ImGuiWindow* window)
{
ImGuiContext& g = *GImGui;
if (g.Windows[0] == window)
return;
for (int i = 0; i < g.Windows.Size; i++)
if (g.Windows[i] == window)
{
memmove(&g.Windows[1], &g.Windows[0], (size_t)i * sizeof(ImGuiWindow*));
... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0xeeb28(%rip), %rax # 0x118c68
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
addq $0x3e48, %rdi # imm = 0x3E48
xorl %esi, %esi
callq 0x40440
movq (%rax), %rax
cmpq 0x20(%rsp), %rax
jne 0x2a167
jmp 0x2a21e
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x18(%rsp)... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::IsWindowFocused(int) | bool ImGui::IsWindowFocused(ImGuiFocusedFlags flags)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* ref_window = g.NavWindow;
ImGuiWindow* cur_window = g.CurrentWindow;
if (ref_window == NULL)
return false;
if (flags & ImGuiFocusedFlags_AnyWindow)
return true;
IM_ASSERT(cur_window);... | subq $0x28, %rsp
movl %edi, 0x20(%rsp)
movq 0xee279(%rip), %rax # 0x118c68
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x40b8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x3ea8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x2aa28
movb $0x0, 0x27(%rsp)
jmp 0x2aab1
movl 0x20(%rsp),... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::ErrorCheckEndFrameRecover(void (*)(void*, char const*, ...), void*) | void ImGui::ErrorCheckEndFrameRecover(ImGuiErrorLogCallback log_callback, void* user_data)
{
// PVS-Studio V1044 is "Loop break conditions do not depend on the number of iterations"
ImGuiContext& g = *GImGui;
while (g.CurrentWindowStack.Size > 0) //-V1044
{
ErrorCheckEndWindowRecover(log_call... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0xec113(%rip), %rax # 0x118c68
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, 0x3e78(%rax)
jle 0x2cc09
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2cc10
movq 0x10(%rsp), %rax
movq 0x3ea8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::NavCalcPreferredRefPos() | static ImVec2 ImGui::NavCalcPreferredRefPos()
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.NavWindow;
if (g.NavDisableHighlight || !g.NavDisableMouseHover || !window)
{
// Mouse (we need a fallback in case the mouse becomes invalid after being used)
// The +1.0f offset when store... | subq $0x98, %rsp
movq 0xe9bba(%rip), %rax # 0x118c68
movq %rax, 0x88(%rsp)
movq 0x88(%rsp), %rax
movq 0x40b8(%rax), %rax
movq %rax, 0x80(%rsp)
movq 0x88(%rsp), %rax
testb $0x1, 0x40fa(%rax)
jne 0x2f0fa
movq 0x88(%rsp), %rax
testb $0x1, 0x40fb(%rax)
je 0x2f0fa
cmpq $0x0, 0x80(%rsp)
jne 0x2f177
movq 0x88(%rsp), %rdi
... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::CloseCurrentPopup() | void ImGui::CloseCurrentPopup()
{
ImGuiContext& g = *GImGui;
int popup_idx = g.BeginPopupStack.Size - 1;
if (popup_idx < 0 || popup_idx >= g.OpenPopupStack.Size || g.BeginPopupStack[popup_idx].PopupId != g.OpenPopupStack[popup_idx].PopupId)
return;
// Closing a menu closes its top-most parent p... | subq $0x38, %rsp
movq 0xe976d(%rip), %rax # 0x118c68
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movl 0x4090(%rax), %eax
subl $0x1, %eax
movl %eax, 0x2c(%rsp)
cmpl $0x0, 0x2c(%rsp)
jl 0x2f565
movl 0x2c(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl 0x4080(%rcx), %eax
jge 0x2f565
movq 0x30(%rsp), %rdi
addq $0x4090, %rdi ... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::BeginPopup(char const*, int) | bool ImGui::BeginPopup(const char* str_id, ImGuiWindowFlags flags)
{
ImGuiContext& g = *GImGui;
if (g.OpenPopupStack.Size <= g.BeginPopupStack.Size) // Early out for performance
{
g.NextWindowData.ClearFlags(); // We behave like Begin() and need to consume those values
return false;
}
... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0xe94a4(%rip), %rax # 0x118c68
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl 0x4080(%rax), %eax
movq 0x8(%rsp), %rcx
cmpl 0x4090(%rcx), %eax
jg 0x2f7f9
movq 0x8(%rsp), %rdi
addq $0x3fb0, %rdi # imm = 0x3FB0
callq 0x416c0
movb $0x0, 0x27(%r... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::FindBestWindowPosForPopupEx(ImVec2 const&, ImVec2 const&, int*, ImRect const&, ImRect const&, ImGuiPopupPositionPolicy) | ImVec2 ImGui::FindBestWindowPosForPopupEx(const ImVec2& ref_pos, const ImVec2& size, ImGuiDir* last_dir, const ImRect& r_outer, const ImRect& r_avoid, ImGuiPopupPositionPolicy policy)
{
ImVec2 base_pos_clamped = ImClamp(ref_pos, r_outer.Min, r_outer.Max - size);
//GetForegroundDrawList()->AddRect(r_avoid.Min, r... | subq $0x128, %rsp # imm = 0x128
movq %rdi, 0x118(%rsp)
movq %rsi, 0x110(%rsp)
movq %rdx, 0x108(%rsp)
movq %rcx, 0x100(%rsp)
movq %r8, 0xf8(%rsp)
movl %r9d, 0xf4(%rsp)
movq 0x118(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x100(%rsp), %rdi
movq %rdi, 0x60(%rsp)
addq $0x8, %rdi
movq 0x110(%rsp), %rsi
callq 0x111c0... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::GetNavInputAmount(int, ImGuiInputReadMode) | float ImGui::GetNavInputAmount(ImGuiNavInput n, ImGuiInputReadMode mode)
{
ImGuiContext& g = *GImGui;
if (mode == ImGuiInputReadMode_Down)
return g.IO.NavInputs[n]; // Instant, read analog input (0.0f..1.0f, as provided by user)
const float t = g.IO.NavInputsDownDuration[n];... | subq $0x28, %rsp
movl %edi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0xe81e5(%rip), %rax # 0x118c68
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x1c(%rsp)
jne 0x30aad
movq 0x10(%rsp), %rax
movslq 0x20(%rsp), %rcx
movss 0xdb0(%rax,%rcx,4), %xmm0
movss %xmm0, 0x24(%rsp)
jmp 0x30c62
movq 0x10(%rsp), %rax
movslq 0x20(%rsp), %rcx
mov... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::GetNavInputAmount2d(int, ImGuiInputReadMode, float, float) | ImVec2 ImGui::GetNavInputAmount2d(ImGuiNavDirSourceFlags dir_sources, ImGuiInputReadMode mode, float slow_factor, float fast_factor)
{
ImVec2 delta(0.0f, 0.0f);
if (dir_sources & ImGuiNavDirSourceFlags_RawKeyboard)
delta += ImVec2((float)IsKeyDown(ImGuiKey_RightArrow) - (float)IsKeyDown(ImGuiKey_LeftArr... | subq $0x68, %rsp
movl %edi, 0x5c(%rsp)
movl %esi, 0x58(%rsp)
movss %xmm0, 0x54(%rsp)
movss %xmm1, 0x50(%rsp)
leaq 0x60(%rsp), %rdi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0xdd40
movl 0x5c(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x30d31
movl $0x202, %edi # imm = 0x202
callq 0x2c320
movzbl %al, %ea... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::BeginDragDropSource(int) | bool ImGui::BeginDragDropSource(ImGuiDragDropFlags flags)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
// FIXME-DRAGDROP: While in the common-most "drag from non-zero active id" case we can tell the mouse button,
// in both SourceExtern and id==0 cases we may requires something e... | subq $0x48, %rsp
movl %edi, 0x40(%rsp)
movq 0xe77d9(%rip), %rax # 0x118c68
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq 0x3ea8(%rax), %rax
movq %rax, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movb $0x0, 0x2b(%rsp)
movl $0x0, 0x24(%rsp)
movl $0x0, 0x20(%rsp)
movl 0x40(%rsp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
jne 0x31... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::EndDragDropSource() | void ImGui::EndDragDropSource()
{
ImGuiContext& g = *GImGui;
IM_ASSERT(g.DragDropActive);
IM_ASSERT(g.DragDropWithinSource && "Not after a BeginDragDropSource()?");
if (!(g.DragDropSourceFlags & ImGuiDragDropFlags_SourceNoPreviewTooltip))
EndTooltip();
// Discard the drag if have not calle... | pushq %rax
movq 0xe73f0(%rip), %rax # 0x118c68
movq %rax, (%rsp)
movq (%rsp), %rax
movl 0x4250(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x31893
callq 0x2ecd0
movq (%rsp), %rax
cmpl $-0x1, 0x4274(%rax)
jne 0x318a5
callq 0x24190
movq (%rsp), %rax
movb $0x0, 0x424d(%rax)
popq %rax
retq
nopw %cs:(%rax,%rax)
| /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::BeginDragDropTarget() | bool ImGui::BeginDragDropTarget()
{
ImGuiContext& g = *GImGui;
if (!g.DragDropActive)
return false;
ImGuiWindow* window = g.CurrentWindow;
if (!(g.LastItemData.StatusFlags & ImGuiItemStatusFlags_HoveredRect))
return false;
ImGuiWindow* hovered_window = g.HoveredWindowUnderMovingWind... | subq $0x38, %rsp
movq 0xe70dd(%rip), %rax # 0x118c68
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
testb $0x1, 0x424c(%rax)
jne 0x31ba8
movb $0x0, 0x37(%rsp)
jmp 0x31ce5
movq 0x28(%rsp), %rax
movq 0x3ea8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
movl 0x3f78(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jn... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
LogTextV(ImGuiContext&, char const*, __va_list_tag*) | static inline void LogTextV(ImGuiContext& g, const char* fmt, va_list args)
{
if (g.LogFile)
{
g.LogBuffer.Buf.resize(0);
g.LogBuffer.appendfv(fmt, args);
ImFileWrite(g.LogBuffer.c_str(), sizeof(char), (ImU64)g.LogBuffer.size(), g.LogFile);
}
else
{
g.LogBuffer.append... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
cmpq $0x0, 0x53e0(%rax)
je 0x32207
movq 0x20(%rsp), %rdi
addq $0x53e8, %rdi # imm = 0x53E8
xorl %esi, %esi
callq 0x3dab0
movq 0x20(%rsp), %rdi
addq $0x53e8, %rdi # imm = 0x53E8
movq 0x18(%rsp), %... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::LogBegin(ImGuiLogType, int) | void ImGui::LogBegin(ImGuiLogType type, int auto_open_depth)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
IM_ASSERT(g.LogEnabled == false);
IM_ASSERT(g.LogFile == NULL);
IM_ASSERT(g.LogBuffer.empty());
g.LogEnabled = true;
g.LogType = type;
g.LogNextPrefix = g.LogN... | movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movq 0xe69e9(%rip), %rax # 0x118c68
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq 0x3ea8(%rax), %rax
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rax
movb $0x1, 0x53d4(%rax)
movl -0x4(%rsp), %ecx
movq -0x10(%rsp), %rax
movl %ecx, 0x53d8(%rax)
movq -0x10(%rsp), %rax
movq... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::FindWindowSettings(unsigned int) | ImGuiWindowSettings* ImGui::FindWindowSettings(ImGuiID id)
{
ImGuiContext& g = *GImGui;
for (ImGuiWindowSettings* settings = g.SettingsWindows.begin(); settings != NULL; settings = g.SettingsWindows.next_chunk(settings))
if (settings->ID == id)
return settings;
return NULL;
} | subq $0x28, %rsp
movl %edi, 0x1c(%rsp)
movq 0xe64c9(%rip), %rax # 0x118c68
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
addq $0x53a0, %rdi # imm = 0x53A0
callq 0x42030
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x327fa
movq 0x8(%rsp), %rax
movl (%rax), %eax
cmpl 0x1c(%rsp), %eax
jne 0x327db
movq 0x8(%rsp... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::FindSettingsHandler(char const*) | ImGuiSettingsHandler* ImGui::FindSettingsHandler(const char* type_name)
{
ImGuiContext& g = *GImGui;
const ImGuiID type_hash = ImHashStr(type_name);
for (int handler_n = 0; handler_n < g.SettingsHandlers.Size; handler_n++)
if (g.SettingsHandlers[handler_n].TypeHash == type_hash)
return &... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0xe63f8(%rip), %rax # 0x118c68
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x126f0
movl %eax, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x5390(%rcx), %eax
jge 0x328eb
movq 0x10(%rsp... | /ggerganov[P]imgui-ws/third-party/imgui/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]);
} | subq $0x28, %rsp
movq 0xe635d(%rip), %rax # 0x118c68
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
addq $0x5380, %rdi # imm = 0x5380
callq 0x40e80
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x5390(%rcx), %eax
jge 0x329b4
movq 0x20(%rsp), %rdi
addq $0x5390, %rdi # imm = ... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::SaveIniSettingsToMemory(unsigned long*) | const char* ImGui::SaveIniSettingsToMemory(size_t* out_size)
{
ImGuiContext& g = *GImGui;
g.SettingsDirtyTimer = 0.0f;
g.SettingsIniData.Buf.resize(0);
g.SettingsIniData.Buf.push_back(0);
for (int handler_n = 0; handler_n < g.SettingsHandlers.Size; handler_n++)
{
ImGuiSettingsHandler* ha... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0xe5d68(%rip), %rax # 0x118c68
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
xorps %xmm0, %xmm0
movss %xmm0, 0x537c(%rax)
movq 0x18(%rsp), %rdi
addq $0x5380, %rdi # imm = 0x5380
xorl %esi, %esi
callq 0x3dab0
movq 0x18(%rsp), %rdi
addq $0x5380, %rdi # imm... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::DebugRenderViewportThumbnail(ImDrawList*, ImGuiViewportP*, ImRect const&) | void ImGui::DebugRenderViewportThumbnail(ImDrawList* draw_list, ImGuiViewportP* viewport, const ImRect& bb)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
ImVec2 scale = bb.GetSize() / viewport->Size;
ImVec2 off = bb.Min - viewport->Pos * scale;
float alpha_mul = 1.0f;
wind... | subq $0x208, %rsp # imm = 0x208
movq %rdi, 0x200(%rsp)
movq %rsi, 0x1f8(%rsp)
movq %rdx, 0x1f0(%rsp)
movq 0xe5c62(%rip), %rax # 0x118c68
movq %rax, 0x1e8(%rsp)
movq 0x1e8(%rsp), %rax
movq 0x3ea8(%rax), %rax
movq %rax, 0x1e0(%rsp)
movq 0x1f0(%rsp), %rdi
callq 0x41190
movlpd %xmm0, 0x1d0(%rsp)
movq 0x1f8(%... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::ShowMetricsWindow(bool*)::Funcs::GetWindowRect(ImGuiWindow*, int) | static ImRect GetWindowRect(ImGuiWindow* window, int rect_type)
{
if (rect_type == WRT_OuterRect) { return window->Rect(); }
else if (rect_type == WRT_OuterRectClipped) { return window->OuterRectClipped; }
else if (rect_type == WRT_InnerRect) { ... | subq $0x58, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
cmpl $0x0, 0x3c(%rsp)
jne 0x3602f
movq 0x40(%rsp), %rdi
callq 0x41580
movlpd %xmm0, 0x48(%rsp)
movlpd %xmm1, 0x50(%rsp)
jmp 0x361ee
cmpl $0x1, 0x3c(%rsp)
jne 0x36058
movq 0x40(%rsp), %rax
movq 0x1c0(%rax), %rcx
movq %rcx, 0x48(%rsp)
movq 0x1c8(%rax), %rax
mov... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::DebugNodeWindowsList(ImVector<ImGuiWindow*>*, char const*) | void ImGui::DebugNodeWindowsList(ImVector<ImGuiWindow*>* windows, const char* label)
{
if (!TreeNode(label, "%s (%d)", label, windows->Size))
return;
for (int i = windows->Size - 1; i >= 0; i--) // Iterate front to back
{
PushID((*windows)[i]);
DebugNodeWindow((*windows)[i], "Window"... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
movl (%rax), %ecx
leaq 0xb12b6(%rip), %rsi # 0xe78bc
movb $0x0, %al
callq 0xb0940
testb $0x1, %al
jne 0x36613
jmp 0x36672
movq 0x10(%rsp), %rax
movl (%rax), %eax
subl $0x1, %eax
movl %eax, 0x4... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
RenderViewportsThumbnails() | static void RenderViewportsThumbnails()
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
// We don't display full monitor bounds (we could, but it often looks awkward), instead we display just enough to cover all of our viewports.
float SCALE = 1.0f / 8.0f;
ImRect bb_full(FLT_MAX... | subq $0xb8, %rsp
movq 0xe19ea(%rip), %rax # 0x118c68
movq %rax, 0xb0(%rsp)
movq 0xb0(%rsp), %rax
movq 0x3ea8(%rax), %rax
movq %rax, 0xa8(%rsp)
movss 0xa5ff3(%rip), %xmm0 # 0xdd298
movss %xmm0, 0xa4(%rsp)
leaq 0x94(%rsp), %rdi
movss 0xa5f52(%rip), %xmm1 # 0xdd210
movss 0xa5f56(%rip), %xmm3 # 0xdd21c
movaps ... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::DebugNodeTabBar(ImGuiTabBar*, char const*) | void ImGui::DebugNodeTabBar(ImGuiTabBar* tab_bar, const char* label)
{
// Standalone tab bars (not associated to docking/windows functionality) currently hold no discernible strings.
char buf[256];
char* p = buf;
const char* buf_end = buf + IM_ARRAYSIZE(buf);
const bool is_active = (tab_bar->PrevFra... | subq $0x1d8, %rsp # imm = 0x1D8
movq %rdi, 0x1d0(%rsp)
movq %rsi, 0x1c8(%rsp)
leaq 0xc0(%rsp), %rax
movq %rax, 0xb8(%rsp)
leaq 0xc0(%rsp), %rax
addq $0x100, %rax # imm = 0x100
movq %rax, 0xb0(%rsp)
movq 0x1d0(%rsp), %rax
movl 0x28(%rax), %eax
movl %eax, 0x5c(%rsp)
callq 0x1a5a0
movl %eax, %ecx
mov... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::ShowFontAtlas(ImFontAtlas*) | void ImGui::ShowFontAtlas(ImFontAtlas* atlas)
{
for (int i = 0; i < atlas->Fonts.Size; i++)
{
ImFont* font = atlas->Fonts[i];
PushID(font);
DebugNodeFont(font);
PopID();
}
if (TreeNode("Atlas texture", "Atlas texture (%dx%d pixels)", atlas->TexWidth, atlas->TexHeight))
... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl $0x0, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
movq 0x50(%rsp), %rcx
cmpl 0x48(%rcx), %eax
jge 0x37d1f
movq 0x50(%rsp), %rdi
addq $0x48, %rdi
movl 0x4c(%rsp), %esi
callq 0x424d0
movq (%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x2be90
movq 0x40(%rsp), %rdi
callq 0x... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
ImGui::DebugNodeStorage(ImGuiStorage*, char const*) | void ImGui::DebugNodeStorage(ImGuiStorage* storage, const char* label)
{
if (!TreeNode(label, "%s: %d entries, %d bytes", label, storage->Data.Size, storage->Data.size_in_bytes()))
return;
for (int n = 0; n < storage->Data.Size; n++)
{
const ImGuiStorage::ImGuiStoragePair& p = storage->Data[... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x30(%rsp), %rdi
callq 0x426a0
movq (%rsp), %rdi
movq 0x8(%rsp), %rdx
movl 0x14(%rsp), %ecx
movl %eax, %r8d
l... | /ggerganov[P]imgui-ws/third-party/imgui/imgui/imgui.cpp |
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.