name string | code string | asm string | file string |
|---|---|---|---|
embree::destroyThread(embree::opaque_thread_t*) | void destroyThread(thread_t tid) {
#if defined(__ANDROID__)
FATAL("Can't destroy threads on Android."); // pthread_cancel not implemented.
#else
pthread_cancel(*(pthread_t*)tid);
delete (pthread_t*)tid;
#endif
} | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x6aac0
movq %rbx, %rdi
popq %rbx
jmp 0x6a4f0
| /embree[P]embree/common/sys/thread.cpp |
embree::createTls() | tls_t createTls()
{
pthread_key_t* key = new pthread_key_t;
if (pthread_key_create(key,nullptr) != 0) {
delete key;
FATAL("pthread_key_create failed");
}
return tls_t(key);
} | pushq %r14
pushq %rbx
pushq %rax
movl $0x4, %edi
callq 0x6a170
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
callq 0x6a890
testl %eax, %eax
jne 0x1ee713d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x6a4f0
movl $0x10, %edi
callq 0x6a3b0
movq %rax, %rbx
leaq 0x7dd64(%rip), %rsi #... | /embree[P]embree/common/sys/thread.cpp |
embree::toLowerCase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string toLowerCase(const std::string& s) { std::string dst(s); std::transform(dst.begin(), dst.end(), dst.begin(), to_lower); return dst; } | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x8d7100
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x1ee7391
movq (%rbx), %r15
xorl %r12d, %r12d
movsbl (%r15,%r12), %edi
callq 0x6a8... | /embree[P]embree/common/sys/estring.cpp |
embree::toUpperCase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string toUpperCase(const std::string& s) { std::string dst(s); std::transform(dst.begin(), dst.end(), dst.begin(), to_upper); return dst; } | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x8d7100
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x1ee73e9
movq (%rbx), %r15
xorl %r12d, %r12d
movsbl (%r15,%r12), %edi
callq 0x6a1... | /embree[P]embree/common/sys/estring.cpp |
embree::string_to_Vec2f(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | Vec2f string_to_Vec2f ( std::string str )
{
size_t next = 0;
const float x = std::stof(str,&next); str = str.substr(next+1);
const float y = std::stof(str,&next);
return Vec2f(x,y);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %r12
callq 0x6aa60
movq %rax, %rbx
movl (%rax), %ebp
movl $0x0, (%rax)
leaq 0x8(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x6a200
movq (%r13), %rdx
subq %r12, %rdx
je 0x1ee74e8
movl (%... | /embree[P]embree/common/sys/estring.cpp |
embree::string_to_Vec3f(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | Vec3f string_to_Vec3f ( std::string str )
{
size_t next = 0;
const float x = std::stof(str,&next); str = str.substr(next+1);
const float y = std::stof(str,&next); str = str.substr(next+1);
const float z = std::stof(str,&next);
return Vec3f(x,y,z);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %r12
callq 0x6aa60
movq %rax, %rbx
movl (%rax), %ebp
movl $0x0, (%rax)
leaq 0x18(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x6a200
movq (%r13), %rdx
subq %r12, %rdx
je 0x1ee7693
movl (... | /embree[P]embree/common/sys/estring.cpp |
embree::getRegressionTest(unsigned long) | RegressionTest* getRegressionTest(size_t index)
{
if (index >= get_regression_tests().size())
return nullptr;
return get_regression_tests()[index];
} | pushq %rbx
movq %rdi, %rbx
callq 0x1ee7950
movq 0x268526(%rip), %rax # 0x214fee0
subq 0x268517(%rip), %rax # 0x214fed8
sarq $0x3, %rax
cmpq %rbx, %rax
jbe 0x1ee79dc
callq 0x1ee7950
movq 0x268502(%rip), %rax # 0x214fed8
movq (%rax,%rbx,8), %rax
jmp 0x1ee79de
xorl %eax, %eax
popq %rbx
retq
| /embree[P]embree/common/sys/regression.cpp |
embree::BarrierSys::BarrierSys(unsigned long) | BarrierSys::BarrierSys (size_t N) {
opaque = new BarrierSysImplementation(N);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movl $0x20, %edi
callq 0x6a170
movq %rax, %rbx
movq %rax, %rdi
callq 0x1ee7b24
movq %rbx, %rdi
addq $0x8, %rdi
callq 0x1ee8124
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movq %rax, 0x10(%rbx)
movq %r15, 0x18(%rbx)
movq %rbx, (%r14)
popq %... | /embree[P]embree/common/sys/barrier.cpp |
embree::BarrierSys::wait() | void BarrierSys::wait() {
((BarrierSysImplementation*) opaque)->wait();
} | pushq %rbx
movq (%rdi), %rbx
movq %rbx, %rdi
callq 0x1ee7bb6
incq 0x10(%rbx)
movq 0x10(%rbx), %rax
cmpq 0x18(%rbx), %rax
jne 0x1ee7d4f
movq $0x0, 0x10(%rbx)
leaq 0x8(%rbx), %rdi
callq 0x1ee821e
jmp 0x1ee7d5b
leaq 0x8(%rbx), %rdi
movq %rbx, %rsi
callq 0x1ee81be
movq %rbx, %rdi
popq %rbx
jmp 0x1ee7c24
| /embree[P]embree/common/sys/barrier.cpp |
embree::LinearBarrierActive::init(unsigned long) | void LinearBarrierActive::init(size_t N)
{
if (threadCount != N) {
threadCount = N;
if (count0) delete[] count0; count0 = new unsigned char[N];
if (count1) delete[] count1; count1 = new unsigned char[N];
}
mode = 0;
flag0 = 0;
flag1 = 0;
for (size_t i=0; i<N; i+... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rax
cmpq %rsi, %rax
je 0x1ee7ddf
movq %rbx, 0x20(%r14)
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1ee7dba
callq 0x6a370
movq %rbx, %rdi
callq 0x6a450
movq %rax, (%r14)
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x1ee7dd3
callq 0x6a370
movq %r... | /embree[P]embree/common/sys/barrier.cpp |
embree::barrier_sys_regression_test::barrier_sys_regression_test() | barrier_sys_regression_test()
: RegressionTest("barrier_sys_regression_test"), threadID(0), numFailed(0)
{
registerRegressionTest(this);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x7d101(%rip), %rsi # 0x1f64f61
leaq 0x7d115(%rip), %rdx # 0x1f64f7c
movq %rsp, %r14
movq %r14, %rdi
callq 0x8d7230
leaq 0x21ac3f(%rip), %r12 # 0x2102ab8
movq %r12, (%rbx)... | /embree[P]embree/common/sys/barrier.cpp |
embree::barrier_sys_regression_test::thread_alloc(embree::barrier_sys_regression_test*) | static void thread_alloc(barrier_sys_regression_test* This)
{
size_t tid = This->threadID++;
for (size_t j=0; j<1000; j++)
{
This->barrier.wait();
This->threadResults[tid] = tid;
This->barrier.wait();
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %r15d
lock
xaddq %r15, 0x30(%rdi)
leaq 0x28(%rdi), %r14
movl $0x3e8, %r12d # imm = 0x3E8
movq %r14, %rdi
callq 0x1ee7d22
movq 0x40(%rbx), %rax
movq %r15, (%rax,%r15,8)
movq %r14, %rdi
callq 0x1ee7d22
decq %r12
jne 0x1ee80f9
addq... | /embree[P]embree/common/sys/barrier.cpp |
embree::ConditionSys::ConditionSys() | ConditionSys::ConditionSys () {
cond = new ConditionImplementation;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movl $0x30, %edi
callq 0x6a170
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
callq 0x6a400
testl %eax, %eax
jne 0x1ee8150
movq %rbx, (%r14)
popq %rbx
popq %r14
popq %r15
retq
movl $0x10, %edi
callq 0x6a3b0
movq %rax, %r14
leaq 0x7ce40(%rip), %rsi # 0x1f64fa4
movq %... | /embree[P]embree/common/sys/condition.cpp |
embree::TokenStream::TokenStream(embree::Ref<embree::Stream<int>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std... | TokenStream::TokenStream(const Ref<Stream<int> >& cin, //< stream to read from
const std::string& alpha, //< valid characters for identifiers
const std::string& seps, //< characters that act as separators
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r13
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbp
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x8(%rdi)
leaq 0x23b1d5(%rip), %rcx # 0x2123478
movq %rcx, (%rdi)
leaq 0x28(%rdi), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
mo... | /embree[P]embree/common/lexers/tokenstream.cpp |
embree::TokenStream::decDigits(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | bool TokenStream::decDigits(std::string& str_o)
{
bool ok = false;
std::string str;
if (cin->peek() == '+' || cin->peek() == '-') str += (char)cin->get();
while (isDigit(cin->peek())) { ok = true; str += (char)cin->get(); }
if (ok) str_o += str;
else cin->unget(str.size());
return ok;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq 0x40(%rdi), %rdi
callq 0x8e81a8
cmpl $0x2b, (%rax)
je 0x1ee8422
movq 0x40(%r14), %rdi
callq 0x8e81a8
cmpl $0x2d, (%rax)
jne 0x... | /embree[P]embree/common/lexers/tokenstream.cpp |
embree::TokenStream::decDigits1(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | bool TokenStream::decDigits1(std::string& str_o)
{
bool ok = false;
std::string str;
while (isDigit(cin->peek())) { ok = true; str += (char)cin->get(); }
if (ok) str_o += str; else cin->unget(str.size());
return ok;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
xorl %ebx, %ebx
movq %rsp, %r12
movq 0x40(%r15), %rdi
callq 0x8e81a8
movl (%rax), %eax
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0x1ee85... | /embree[P]embree/common/lexers/tokenstream.cpp |
embree::TokenStream::trySymbol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool TokenStream::trySymbol(const std::string& symbol)
{
size_t pos = 0;
while (pos < symbol.size()) {
if (symbol[pos] != cin->peek()) { cin->unget(pos); return false; }
cin->drop(); pos++;
}
return true;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpq $0x0, 0x8(%rsi)
sete %bl
je 0x1ee85f1
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %rax
movsbl (%rax), %ebp
movq 0x40(%rdi), %rdi
callq 0x8e81a8
cmpl %ebp, (%rax)
jne 0x1ee85e2
movl $0x1, %r12d
movq 0x40(%r14), %rdi
callq 0x1ee947a
cmpq 0x8(%r15), %r12
setae %... | /embree[P]embree/common/lexers/tokenstream.cpp |
embree::TokenStream::trySymbols(embree::Token&, embree::ParseLocation const&) | bool TokenStream::trySymbols(Token& token, const ParseLocation& loc)
{
for (size_t i=0; i<symbols.size(); i++) {
if (!trySymbol(symbols[i])) continue;
token = Token(symbols[i],Token::TY_SYMBOL,loc);
return true;
}
return false;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq 0x348(%rdi), %rsi
cmpq %rsi, 0x350(%rdi)
setne %bl
je 0x1ee872b
movq %rdx, %r15
movq %rdi, %r12
callq 0x1ee8582
testb %al, %al
je 0x1ee8637
xorl %ebp, %ebp
jmp 0x1ee8678
movl $0x20, %r13d
xorl %ebp, %ebp
incq %rbp
mo... | /embree[P]embree/common/lexers/tokenstream.cpp |
embree::TokenStream::tryFloat(embree::Token&, embree::ParseLocation const&) | bool TokenStream::tryFloat(Token& token, const ParseLocation& loc)
{
bool ok = false;
std::string str;
if (trySymbol("nan")) {
token = Token(float(nan));
return true;
}
if (trySymbol("+inf")) {
token = Token(float(pos_inf));
return true;
}
if (trySymbol("-inf")) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x7c9ae(%rip), %rsi # 0x1f65143
leaq 0x7c9aa(%rip)... | /embree[P]embree/common/lexers/tokenstream.cpp |
embree::TokenStream::tryInt(embree::Token&, embree::ParseLocation const&) | bool TokenStream::tryInt(Token& token, const ParseLocation& loc) {
std::string str;
if (decDigits(str)) {
token = Token(atoi(str.c_str()),loc);
return true;
}
return false;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r15
movq %rsi, %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq %rsp, %rsi
callq 0x1ee83dc
movl %eax, %ebx
testb %al, %al
je 0x1ee8c42
movq (%rsp), %rdi
callq 0x6a2e0
leaq 0x28(%r... | /embree[P]embree/common/lexers/tokenstream.cpp |
embree::TokenStream::tryIdentifier(embree::Token&, embree::ParseLocation const&) | bool TokenStream::tryIdentifier(Token& token, const ParseLocation& loc)
{
std::string str;
if (!isAlpha(cin->peek())) return false;
str += (char)cin->get();
while (isAlphaNum(cin->peek())) str += (char)cin->get();
token = Token(str,Token::TY_IDENTIFIER,loc);
return true;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
leaq 0x10(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq $0x0, -0x8(%rbp)
movb $0x0, (%rbp)
movq 0x40(%rdi), %rdi
callq 0x8e81a8
movl (%rax), %eax
cmpq $0xff, %rax
ja 0x1ee9010
movb 0x148(%r12,%ra... | /embree[P]embree/common/lexers/tokenstream.cpp |
embree::TokenStream::skipSeparators() | void TokenStream::skipSeparators()
{
/* skip separators */
while (cin->peek() != EOF && isSeparator(cin->peek()))
cin->drop();
} | pushq %rbx
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
callq 0x8e81a8
cmpl $-0x1, (%rax)
je 0x1ee91b3
movq 0x40(%rbx), %rdi
callq 0x8e81a8
movl (%rax), %eax
cmpq $0xff, %rax
ja 0x1ee91b3
cmpb $0x1, 0x48(%rbx,%rax)
jne 0x1ee91b3
movq 0x40(%rbx), %rdi
callq 0x1ee947a
movq 0x40(%rbx), %rdi
jmp 0x1ee9180
popq %rbx
retq
nop
| /embree[P]embree/common/lexers/tokenstream.cpp |
embree::TokenStream::next() | Token TokenStream::next()
{
Token token;
skipSeparators();
ParseLocation loc = cin->loc();
if (trySymbols (token,loc)) return token; /**< try to parse a symbol */
if (tryFloat (token,loc)) return token; /**< try to parse float */
if (tryInt (token,loc)) return token; ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
pcmpeqd %xmm0, %xmm0
leaq 0x18(%rsp), %r15
movdqu %xmm0, 0x20(%r15)
movl $0x0, -0x18(%r15)
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
pxor %xmm0, %xmm0
movdqu %xmm0, 0x10(%r15)
movq %rsi, %rdi
callq 0x1ee917... | /embree[P]embree/common/lexers/tokenstream.cpp |
embree::Stream<int>::drop() | void drop() {
if (future == 0) push_back(nextHelper());
past++; future--;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
jne 0x1ee9581
movq (%rbx), %rax
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq *0x28(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
movl %eax, 0x28(%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x30(%rsp)
movq %... | /embree[P]embree/common/lexers/stream.h |
embree::TokenStream::location() | ParseLocation location() { return cin->loc(); } | pushq %rbx
movq %rdi, %rbx
movq 0x40(%rsi), %rdi
callq 0x8e857c
movq (%rax), %rcx
movq %rcx, (%rbx)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rbx)
testq %rcx, %rcx
je 0x1ee97e3
movq 0x23b273(%rip), %rdx # 0x2124a48
cmpb $0x0, (%rdx)
je 0x1ee97df
incl 0x8(%rcx)
jmp 0x1ee97e3
lock
incl 0x8(%rcx)
movups 0x10(%rax), %xmm0
mo... | /embree[P]embree/common/lexers/tokenstream.h |
embree::TaskScheduler::create(unsigned long, bool, bool) | void TaskScheduler::create(size_t numThreads, bool set_affinity, bool start_threads)
{
assert(numThreads);
/* first terminate threads in case we configured them */
if (g_tbb_threads_initialized) {
#if TBB_INTERFACE_VERSION >= 11005
delete g_tbb_thread_control;
g_tbb_thread_control = nullptr;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xb8, %rsp
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %rbx
cmpb $0x1, 0x266761(%rip) # 0x2150169
jne 0x1ee9a38
movq 0x26675f(%rip), %r15 # 0x2150170
testq %r15, %r15
je 0x1ee9a26
movq %r15, %rdi
callq 0x6ab50
movq %r15, %rdi
callq 0x6a4f0
movq $0x0, 0x26673f(%rip... | /embree[P]embree/common/tasking/taskschedulertbb.cpp |
sqlite3_result_text64 | SQLITE_API void sqlite3_result_text64(
sqlite3_context *pCtx,
const char *z,
sqlite3_uint64 n,
void (*xDel)(void *),
unsigned char enc
){
assert( sqlite3_mutex_held(pCtx->pOut->db->mutex) );
assert( xDel!=SQLITE_DYNAMIC );
if( enc==SQLITE_UTF16 ) enc = SQLITE_UTF16NATIVE;
if( n>0x7fffffff ){
(vo... | movq %rcx, %r9
movq %rdi, %rax
movq %rdx, %rcx
shrq $0x1f, %rcx
je 0xf904
movq %rsi, %rdi
movq %r9, %rsi
movq %rax, %rdx
jmp 0xf4b0
cmpb $0x4, %r8b
movzbl %r8b, %ecx
movl $0x2, %edi
cmovnel %ecx, %edi
movzbl %dil, %ecx
movq %rax, %rdi
movq %r9, %r8
jmp 0xf458
| /xujihui1985[P]learingcpp/thirdparty/sqlite3.c |
sqlite3VdbeMemCopy | SQLITE_PRIVATE int sqlite3VdbeMemCopy(Mem *pTo, const Mem *pFrom){
int rc = SQLITE_OK;
assert( !sqlite3VdbeMemIsRowSet(pFrom) );
if( VdbeMemDynamic(pTo) ) vdbeMemClearExternAndSetNull(pTo);
memcpy(pTo, pFrom, MEMCELLSIZE);
pTo->flags &= ~MEM_Dyn;
if( pTo->flags&(MEM_Str|MEM_Blob) ){
if( 0==(pFrom->flag... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testb $0x24, 0x9(%rdi)
je 0xf967
movq %rbx, %rdi
callq 0x29630
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movzwl 0x8(%rbx), %ecx
movl %ecx, %eax
andl $0xfbff, %eax # imm = 0xFBFF
movw %ax, 0x8(%rbx)
tes... | /xujihui1985[P]learingcpp/thirdparty/sqlite3.c |
sqlite3_result_zeroblob64 | SQLITE_API int sqlite3_result_zeroblob64(sqlite3_context *pCtx, u64 n){
Mem *pOut = pCtx->pOut;
assert( sqlite3_mutex_held(pOut->db->mutex) );
if( n>(u64)pOut->db->aLimit[SQLITE_LIMIT_LENGTH] ){
return SQLITE_TOOBIG;
}
sqlite3VdbeMemSetZeroBlob(pCtx->pOut, (int)n);
return SQLITE_OK;
} | movq (%rdi), %rdi
movq 0x28(%rdi), %rax
movslq 0x7c(%rax), %rcx
movl $0x12, %eax
cmpq %rsi, %rcx
jb 0xfa1a
pushq %rax
callq 0xf9b8
xorl %eax, %eax
addq $0x8, %rsp
retq
| /xujihui1985[P]learingcpp/thirdparty/sqlite3.c |
sqlite3_result_error_code | SQLITE_API void sqlite3_result_error_code(sqlite3_context *pCtx, int errCode){
pCtx->isError = errCode ? errCode : -1;
#ifdef SQLITE_DEBUG
if( pCtx->pVdbe ) pCtx->pVdbe->rcApp = errCode;
#endif
if( pCtx->pOut->flags & MEM_Null ){
sqlite3VdbeMemSetStr(pCtx->pOut, sqlite3ErrStr(errCode), -1,
... | xorl %eax, %eax
cmpl $0x1, %esi
sbbl %eax, %eax
orl %esi, %eax
movl %eax, 0x24(%rdi)
movq (%rdi), %rdi
testb $0x1, 0x8(%rdi)
jne 0xfa31
retq
cmpl $0x204, %esi # imm = 0x204
je 0xfa55
cmpl $0x65, %esi
je 0xfa4c
cmpl $0x64, %esi
jne 0xfa5e
leaq 0x7c256(%rip), %rsi # 0x8bca0
jmp 0xfa86
leaq 0x7c263(%rip), %... | /xujihui1985[P]learingcpp/thirdparty/sqlite3.c |
columnMallocFailure | static void columnMallocFailure(sqlite3_stmt *pStmt)
{
/* If malloc() failed during an encoding conversion within an
** sqlite3_column_XXX API, then set the return code of the statement to
** SQLITE_NOMEM. The next call to _step() (if any) will return SQLITE_ERROR
** and _finalize() will return NOMEM.
*/
Vd... | pushq %rbx
testq %rdi, %rdi
je 0x10c08
movq %rdi, %rbx
movq (%rdi), %rdi
movl 0x38(%rbx), %eax
cmpl $0xc0a, %eax # imm = 0xC0A
je 0x10be8
cmpb $0x0, 0x61(%rdi)
jne 0x10be8
andl 0x54(%rdi), %eax
jmp 0x10bf2
callq 0x27c19
movl $0x7, %eax
movl %eax, 0x38(%rbx)
movq (%rbx), %rax
movq 0x18(%rax), %rdi
testq %rdi,... | /xujihui1985[P]learingcpp/thirdparty/sqlite3.c |
createModule | static int createModule(
sqlite3 *db, /* Database in which module is registered */
const char *zName, /* Name assigned to this module */
const sqlite3_module *pModule, /* The definition of the module */
void *pAux, /* Context pointer for xCreate/xConnect */
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x15096
callq *0x8e20a(%rip) # 0xa32a0
leaq 0x1c0(%r14), %rdi
xorl %r12d, %r12d
movq %rbp, %rsi
xorl %edx, %edx
c... | /xujihui1985[P]learingcpp/thirdparty/sqlite3.c |
pthreadMutexEnter | static void pthreadMutexEnter(sqlite3_mutex *p){
assert( p->id==SQLITE_MUTEX_RECURSIVE || pthreadMutexNotheld(p) );
#ifdef SQLITE_HOMEGROWN_RECURSIVE_MUTEX
/* If recursive mutexes are not available, then we have to grow
** our own. This implementation assumes that pthread_equal()
** is atomic - that it cannot... | jmp 0x82d0
| /xujihui1985[P]learingcpp/thirdparty/sqlite3.c |
sqlite3PagerUnrefNotNull | SQLITE_PRIVATE void sqlite3PagerUnrefNotNull(DbPage *pPg){
TESTONLY( Pager *pPager = pPg->pPager; )
assert( pPg!=0 );
if( pPg->flags & PGHDR_MMAP ){
assert( pPg->pgno!=1 ); /* Page1 is never memory mapped */
pagerReleaseMapPage(pPg);
}else{
sqlite3PcacheRelease(pPg);
}
/* Do not use this routin... | testb $0x20, 0x34(%rdi)
je 0x22c6a
movq 0x28(%rdi), %rcx
decl 0x98(%rcx)
movq 0xa8(%rcx), %rax
movq %rax, 0x20(%rdi)
movq %rdi, 0xa8(%rcx)
movq 0x48(%rcx), %rax
movl 0x30(%rdi), %edx
decl %edx
movslq 0xbc(%rcx), %rsi
imulq %rdx, %rsi
movq 0x8(%rdi), %rdx
movq (%rax), %rcx
movq 0x90(%rcx), %rcx
movq %rax, %rdi
jmpq *%rc... | /xujihui1985[P]learingcpp/thirdparty/sqlite3.c |
decodeFlags | static int decodeFlags(MemPage *pPage, int flagByte){
BtShared *pBt; /* A copy of pPage->pBt */
assert( pPage->hdrOffset==(pPage->pgno==1 ? 100 : 0) );
assert( sqlite3_mutex_held(pPage->pBt->mutex) );
pPage->leaf = (u8)(flagByte>>3); assert( PTF_LEAF == 1<<3 );
flagByte &= ~PTF_LEAF;
pPage->childPtrSi... | pushq %rbx
movl %esi, %ecx
shrl $0x3, %ecx
movb %cl, 0x8(%rdi)
andl $-0x9, %esi
movl %ecx, %eax
shll $0x2, %eax
movb $0x4, %dl
subb %al, %dl
movb %dl, 0xa(%rdi)
leaq 0xb4(%rip), %rax # 0x23450
movq %rax, 0x78(%rdi)
movq 0x48(%rdi), %rax
cmpl $0x2, %esi
je 0x233c3
cmpl $0x5, %esi
jne 0x233e2
movb $0x1, 0x2(%rdi)
... | /xujihui1985[P]learingcpp/thirdparty/sqlite3.c |
double calcCC<stSampleMulti<short, 4>>(stWaveformView<stSampleMulti<short, 4>> const&, stWaveformView<stSampleMulti<short, 4>> const&, long, long) | TValueCC calcCC(
const TWaveformViewT<TSampleMI16> & waveform0,
const TWaveformViewT<TSampleMI16> & waveform1,
int64_t sum0, int64_t sum02) {
TValueCC cc = -1.0f;
int64_t sum1 = 0;
int64_t sum12 = 0;
int64_t sum01 = 0;
auto samples0 = waveform0.samples;
auto n0 = waveform0.n;... | pushq %rax
movq 0x8(%rdi), %rax
movq 0x8(%rsi), %r8
cmpq %rax, %r8
cmovlq %r8, %rax
testq %rax, %rax
jle 0x290fe
movq (%rdi), %rdi
movq (%rsi), %rsi
xorl %r9d, %r9d
pxor %xmm0, %xmm0
xorl %r10d, %r10d
xorl %r11d, %r11d
xorl %r8d, %r8d
movq %r9, %xmm3
movq %r10, %xmm2
movq %r11, %xmm1
xorl %r9d, %r9d
movd (%rdi,%r9,2), ... | /ggerganov[P]kbd-audio/common.cpp |
bool calculateSimilartyMap<stSampleMulti<short, 4>>(int, int, int, stKeyPressCollection<stSampleMulti<short, 4>>&, std::vector<std::vector<stMatch, std::allocator<stMatch>>, std::allocator<std::vector<stMatch, std::allocator<stMatch>>>>&) | bool calculateSimilartyMap(
const int32_t keyPressWidth_samples,
const int32_t alignWindow_samples,
const int32_t offsetFromPeak_samples,
TKeyPressCollectionT<TSampleMI16> & keyPresses,
TSimilarityMap & res) {
int nPresses = keyPresses.size();
int w = keyPressWidth_sampl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %rbx
movq %rcx, %r14
movl %edx, 0x24(%rsp)
movq 0x8(%rcx), %rax
subq (%rcx), %rax
shrq $0x4, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
movl %eax, 0xc(%rsp)
movl %edi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq (%r8), %rs... | /ggerganov[P]kbd-audio/common.cpp |
bool readFromFile<float, float>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<float, std::allocator<float>>&) | bool readFromFile(const std::string & fname, TWaveformT<TSample> & res) {
std::ifstream fin(fname, std::ios::binary | std::ios::ate);
if (fin.good() == false) {
return false;
}
{
std::streamsize size = fin.tellg();
fin.seekg(0, std::ios::beg);
static_assert(std::is_same... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x210, %rsp # imm = 0x210
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x6, %edx
callq 0x22870
movq (%r14), %rax
movq -0x18(%rax), %rax
movl 0x28(%rsp,%rax), %ebp
testl %ebp, %ebp
jne 0x2a84e
leaq 0x8(%rsp), %rdi
callq 0x22120
movq %rax, %r... | /ggerganov[P]kbd-audio/common.cpp |
std::tuple<double, long> findBestCC<short>(stWaveformView<short> const&, stWaveformView<short> const&, long) | std::tuple<TValueCC, TOffset> findBestCC(
const TWaveformViewT<T> & waveform0,
const TWaveformViewT<T> & waveform1,
int64_t alignWindow) {
TValueCC bestcc = -1.0;
TOffset besto = -1;
//auto samples0 = waveform0.samples;
auto n0 = waveform0.n;
auto samples1 = waveform1.samples;
#... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r12
movq %rsi, %r8
movq %rdi, 0x8(%rsp)
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
jle 0x2abc9
movq (%r8), %rax
xorl %r11d, %r11d
xorl %r14d, %r14d
xorl %r13d, %r13d
movswq (%rax,%r11,2), %rsi
addq %rsi, %r13
imull %esi, %esi
addq... | /ggerganov[P]kbd-audio/common.cpp |
bool dumpKeyPresses<short>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, stKeyPressCollection<short> const&) | bool dumpKeyPresses(const std::string & fname, const TKeyPressCollectionT<T> & data) {
std::ofstream fout(fname);
for (auto & k : data) {
fout << k.pos << " 1" << std::endl;
}
fout.close();
return true;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x200, %rsp # imm = 0x200
movq %rsi, %rbx
movq %rdi, %rsi
movq %rsp, %rdi
movl $0x10, %edx
callq 0x22140
movq (%rbx), %r12
movq 0x8(%rbx), %r13
cmpq %r13, %r12
je 0x2be13
movq %rsp, %rbx
leaq 0x61f94(%rip), %r14 # 0x8dd57
movq 0x10(%r12), %rsi
... | /ggerganov[P]kbd-audio/common.cpp |
Gui::render(Gui::Objects const&) | bool render(const Objects & objects) {
ImGui::Render();
SDL_GL_MakeCurrent(objects.window, objects.gl_context);
glViewport(0, 0, (int) ImGui::GetIO().DisplaySize.x, (int) ImGui::GetIO().DisplaySize.y);
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT);
ImGui_ImplOpenGL3_RenderDr... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x3f263
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x225e0
leaq 0x796f4(%rip), %rax # 0xa8e10
movq (%rax), %r14
callq 0x35fb5
cvttss2si 0x8(%rax), %ebp
callq 0x35fb5
cvttss2si 0xc(%rax), %ecx
xorl %edi, %edi
xorl %esi, %esi
movl %ebp, %edx
callq *%r14
leaq 0x... | /ggerganov[P]kbd-audio/common-gui.cpp |
ImGuiStyle::ImGuiStyle() | ImGuiStyle::ImGuiStyle()
{
Alpha = 1.0f; // Global alpha applies to everything in ImGui
WindowPadding = ImVec2(8,8); // Padding within a window
WindowRounding = 7.0f; // Radius of window corners rounding. Set to 0.0f to have rectangular windo... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0xb8, %rdi
xorl %ebp, %ebp
movl $0x300, %edx # imm = 0x300
xorl %esi, %esi
callq 0x222a0
xorps %xmm0, %xmm0
movq $0x0, 0x58(%rbx)
movups %xmm0, 0x88(%rbx)
movups %xmm0, 0x98(%rbx)
movaps 0x4f375(%rip), %xmm1 # 0x7eb60
movups %xmm1, (%rbx)
movabsq $0x4... | /ggerganov[P]kbd-audio/imgui/imgui.cpp |
ImLineClosestPoint(ImVec2 const&, ImVec2 const&, ImVec2 const&) | static inline ImVec2 operator+(const ImVec2& lhs, const ImVec2& rhs) { return ImVec2(lhs.x+rhs.x, lhs.y+rhs.y); } | movss (%rdx), %xmm1
movss 0x4(%rdx), %xmm4
movsd (%rdi), %xmm0
movaps %xmm0, %xmm2
shufps $0x55, %xmm0, %xmm2 # xmm2 = xmm2[1,1],xmm0[1,1]
subss %xmm0, %xmm1
subss %xmm2, %xmm4
movsd (%rsi), %xmm2
subps %xmm0, %xmm2
movaps %xmm2, %xmm3
shufps $0x55, %xmm2, %xmm3 # xmm3 = xmm3[1,1],xmm2[1,1]
mulss %xmm3, %xmm4
m... | /ggerganov[P]kbd-audio/imgui/imgui_internal.h |
ImFormatString(char*, unsigned long, char const*, ...) | int ImFormatString(char* buf, size_t buf_size, const char* fmt, ...)
{
va_list args;
va_start(args, fmt);
#ifdef IMGUI_USE_STB_SPRINTF
int w = stbsp_vsnprintf(buf, (int)buf_size, fmt, args);
#else
int w = vsnprintf(buf, buf_size, fmt, args);
#endif
va_end(args);
if (buf == NULL)
return w... | pushq %r14
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %rsi
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x31352
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5... | /ggerganov[P]kbd-audio/imgui/imgui.cpp |
ImFileOpen(char const*, char const*) | ImFileHandle ImFileOpen(const char* filename, const char* mode)
{
#if defined(_WIN32) && !defined(IMGUI_DISABLE_WIN32_FUNCTIONS) && !defined(__CYGWIN__) && !defined(__GNUC__)
// We need a fopen() wrapper because MSVC/Windows fopen doesn't handle UTF-8 filenames.
// Previously we used ImTextCountCharsFromUtf8/Im... | jmp 0x22910
| /ggerganov[P]kbd-audio/imgui/imgui.cpp |
ImTextCountCharsFromUtf8(char const*, char const*) | int ImTextCountCharsFromUtf8(const char* in_text, const char* in_text_end)
{
int char_count = 0;
while ((!in_text_end || in_text < in_text_end) && *in_text)
{
unsigned int c;
in_text += ImTextCharFromUtf8(&c, in_text, in_text_end);
if (c == 0)
break;
char_count++;... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
leaq 0x4(%rsp), %r12
testq %r14, %r14
je 0x31710
cmpq %r14, %r15
jae 0x3173b
cmpb $0x0, (%r15)
je 0x3173b
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3039b
movl %eax, %eax
a... | /ggerganov[P]kbd-audio/imgui/imgui.cpp |
ImGuiTextFilter::PassFilter(char const*, char const*) const | bool ImGuiTextFilter::PassFilter(const char* text, const char* text_end) const
{
if (Filters.empty())
return true;
if (text == NULL)
text = "";
for (int i = 0; i != Filters.Size; i++)
{
const ImGuiTextRange& f = Filters[i];
if (f.empty())
continue;
i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x8(%rsp)
movl 0x100(%rdi), %r12d
testq %r12, %r12
je 0x325ec
testq %rsi, %rsi
leaq 0x4c62a(%rip), %r15 # 0x7eb55
cmovneq %rsi, %r15
xorl %r13d, %r13d
testl %r12d, %r12d
movl $0x0, %ebx
cmovgl %r12d, %ebx
movq %rdi, 0x10(%... | /ggerganov[P]kbd-audio/imgui/imgui.cpp |
ImGuiListClipper::Begin(int, float) | void ImGuiListClipper::Begin(int count, float items_height)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
StartPosY = window->DC.CursorPos.y;
ItemsHeight = items_height;
ItemsCount = count;
StepNo = 0;
DisplayEnd = DisplayStart = -1;
if (ItemsHeight > 0.0f)
{
... | movq 0x71b45(%rip), %rax # 0xa46a0
movq 0x1a80(%rax), %rax
movss 0xd4(%rax), %xmm1
movss %xmm1, 0x14(%rdi)
movss %xmm0, 0x10(%rdi)
movl %esi, 0x8(%rdi)
movl $0x0, 0xc(%rdi)
movq $-0x1, (%rdi)
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x32c30
pushq %rbx
movq %rdi, %rbx
leaq 0x4(%rdi), %rdx
movl %esi, %edi
movq %rb... | /ggerganov[P]kbd-audio/imgui/imgui.cpp |
ImGui::PopStyleColor(int) | void ImGui::PopStyleColor(int count)
{
ImGuiContext& g = *GImGui;
while (count > 0)
{
ImGuiColorMod& backup = g.ColorModifiers.back();
g.Style.Colors[backup.Col] = backup.BackupValue;
g.ColorModifiers.pop_back();
count--;
}
} | pushq %rax
testl %edi, %edi
jle 0x331d4
movq 0x71518(%rip), %rax # 0xa46a0
leaq 0x1620(%rax), %rcx
incl %edi
movslq 0x1ba8(%rax), %rdx
testq %rdx, %rdx
jle 0x331f5
movq 0x1bb0(%rax), %rsi
leaq (%rdx,%rdx,4), %rdx
movslq -0x14(%rsi,%rdx,4), %r8
shlq $0x4, %r8
movups -0x10(%rsi,%rdx,4), %xmm0
movups %xmm0, (%rcx,%r8)... | /ggerganov[P]kbd-audio/imgui/imgui.cpp |
ImGui::RenderTextClipped(ImVec2 const&, ImVec2 const&, char const*, char const*, ImVec2 const*, ImVec2 const&, ImRect const*) | void ImGui::RenderTextClipped(const ImVec2& pos_min, const ImVec2& pos_max, const char* text, const char* text_end, const ImVec2* text_size_if_known, const ImVec2& align, const ImRect* clip_rect)
{
// Hide anything after a '##' string
const char* text_display_end = FindRenderedTextEnd(text, text_end);
const... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rax
movq %r8, %r9
movq %rdx, %rbx
movq %rsi, %rdx
xorl %esi, %esi
cmpq $0x1, %rcx
sbbq %rsi, %rsi
movq %rdi, %r14
orq %rcx, %rsi
movq %rbx, %r15
cmpq %rbx, %rsi
jbe 0x33d6c
movq %rbx, %r15
movzbl (%r15), %ecx
cmpl $0x23, %ecx
je 0x33d5a
testl %ecx, %ecx
... | /ggerganov[P]kbd-audio/imgui/imgui.cpp |
ImGui::CalcWrapWidthForPos(ImVec2 const&, float) | float ImGui::CalcWrapWidthForPos(const ImVec2& pos, float wrap_pos_x)
{
if (wrap_pos_x < 0.0f)
return 0.0f;
ImGuiWindow* window = GImGui->CurrentWindow;
if (wrap_pos_x == 0.0f)
wrap_pos_x = window->WorkRect.Max.x;
else if (wrap_pos_x > 0.0f)
wrap_pos_x += window->Pos.x - window-... | xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
ja 0x35834
movq 0x6eea3(%rip), %rax # 0xa46a0
movq 0x1a80(%rax), %rax
ucomiss %xmm1, %xmm0
jne 0x35815
jp 0x35815
movss 0x250(%rax), %xmm0
jmp 0x35825
jbe 0x35825
movss 0x10(%rax), %xmm1
subss 0x54(%rax), %xmm1
addss %xmm1, %xmm0
subss (%rdi), %xmm0
maxss 0x487df(%rip), %xmm0... | /ggerganov[P]kbd-audio/imgui/imgui.cpp |
ImGui::Initialize(ImGuiContext*) | void ImGui::Initialize(ImGuiContext* context)
{
ImGuiContext& g = *context;
IM_ASSERT(!g.Initialized && !g.SettingsLoaded);
// Add .ini handle for ImGuiWindow type
{
ImGuiSettingsHandler ini_handler;
ini_handler.TypeName = "Window";
ini_handler.TypeHash = ImHashStr("Window");
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpb $0x0, (%rdi)
jne 0x35a81
movq %rdi, %rbx
cmpb $0x1, 0x2fa0(%rdi)
je 0x35a81
leaq 0x4d127(%rip), %r14 # 0x82a56
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3140c
movl %eax, %ebp
movl 0x2fb8(%rbx), %r12d
movl 0x2fbc(%rbx), %eax
cmpl %eax, %r12d
j... | /ggerganov[P]kbd-audio/imgui/imgui.cpp |
ImGui::Shutdown(ImGuiContext*) | void ImGui::Shutdown(ImGuiContext* context)
{
// The fonts atlas can be used prior to calling NewFrame(), so we clear it even if g.Initialized is FALSE (which would happen if we never called NewFrame)
ImGuiContext& g = *context;
if (g.IO.Fonts && g.FontAtlasOwnedByContext)
{
g.IO.Fonts->Locked =... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xa8(%rdi), %rdi
testq %rdi, %rdi
je 0x35af6
cmpb $0x1, 0x1(%rbx)
jne 0x35af6
movb $0x0, (%rdi)
callq 0x4a15b
movq $0x0, 0xa8(%rbx)
cmpb $0x1, (%rbx)
jne 0x35fad
cmpb $0x1, 0x2fa0(%rbx)
jne 0x35b36
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x35b36
movq 0x6eb7d(%rip)... | /ggerganov[P]kbd-audio/imgui/imgui.cpp |
ImGui::FocusWindow(ImGuiWindow*) | void ImGui::FocusWindow(ImGuiWindow* window)
{
ImGuiContext& g = *GImGui;
if (g.NavWindow != window)
{
g.NavWindow = window;
if (window && g.NavDisableMouseHover)
g.NavMousePosDirty = true;
g.NavInitRequest = false;
g.NavId = window ? window->NavLastIds[0] : 0; /... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x6e5ec(%rip), %r12 # 0xa46a0
cmpq %rdi, 0x1bf8(%r12)
je 0x3611e
movq %rbx, 0x1bf8(%r12)
testq %rbx, %rbx
je 0x360f0
cmpb $0x1, 0x1c4f(%r12)
jne 0x360df
movb $0x1, 0x1c4d(%r12)
movb $0x0, 0x1c51(%r12)
movl 0x388(%rbx), %eax
jmp 0x360fb
movb... | /ggerganov[P]kbd-audio/imgui/imgui.cpp |
ImGui::UpdateMouseMovingWindowNewFrame() | void ImGui::UpdateMouseMovingWindowNewFrame()
{
ImGuiContext& g = *GImGui;
if (g.MovingWindow != NULL)
{
// We actually want to move the root window. g.MovingWindow == window we clicked on (could be a child window).
// We track it to preserve Focus and so that generally ActiveIdWindow == Mov... | pushq %r14
pushq %rbx
pushq %rax
movq 0x6e4b7(%rip), %r14 # 0xa46a0
movq 0x1a98(%r14), %rax
testq %rax, %rax
je 0x362d2
movl 0x1ac8(%r14), %ecx
movl 0x1b08(%r14), %edx
movl %ecx, 0x1acc(%r14)
cmpl %ecx, %edx
jne 0x3621a
movb $0x1, 0x1b0c(%r14)
movq 0x368(%rax), %rbx
testq %rbx, %rbx
je 0x36320
cmpb $0x1, 0x138(%r14... | /ggerganov[P]kbd-audio/imgui/imgui.cpp |
ImGui::UpdateHoveredWindowAndCaptureFlags() | void ImGui::UpdateHoveredWindowAndCaptureFlags()
{
ImGuiContext& g = *GImGui;
// Find the window hovered by mouse:
// - Child windows can extend beyond the limit of their parent so we need to derive HoveredRootWindow from HoveredWindow.
// - When moving a window we can skip the search, which also conve... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x6dfca(%rip), %rbx # 0xa46a0
movq 0x1a98(%rbx), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x366ec
testb $0x2, 0xd(%rcx)
cmoveq %rcx, %rax
movl 0x15c0(%rbx), %ecx
movl 0x15c4(%rbx), %edx
cmpb $0x1, 0xcb(%rbx)
jne 0x36717
movsd 0x15c0(%rbx), %xmm0
maxps 0x48... | /ggerganov[P]kbd-audio/imgui/imgui.cpp |
ImGui::SetWindowSize(ImGuiWindow*, ImVec2 const&, int) | void ImGui::SetWindowSize(ImGuiWindow* window, const ImVec2& size, ImGuiCond cond)
{
// Test condition (NB: bit 0 is always true) and clear flags for next time
if (cond && (window->SetWindowSizeAllowFlags & cond) == 0)
return;
IM_ASSERT(cond == 0 || ImIsPowerOfTwo(cond)); // Make sure the user does... | testl %edx, %edx
je 0x40fd3
testl %edx, 0xa8(%rdi)
je 0x41035
leal -0x1(%rdx), %eax
testl %eax, %edx
jne 0x41036
andb $-0xf, 0xa8(%rdi)
movss (%rsi), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x40ffb
movb $0x0, 0x94(%rdi)
cvttps2dq %xmm0, %xmm0
cvtdq2ps %xmm0, %xmm0
movss %xmm0, 0x20(%rdi)
jmp 0x41009
movb $0x2... | /ggerganov[P]kbd-audio/imgui/imgui.cpp |
CalcNextScrollFromScrollTargetAndClamp(ImGuiWindow*, bool) | static ImVec2 CalcNextScrollFromScrollTargetAndClamp(ImGuiWindow* window, bool snap_on_edges)
{
ImGuiContext& g = *GImGui;
ImVec2 scroll = window->Scroll;
if (window->ScrollTarget.x < FLT_MAX)
{
float cr_x = window->ScrollTargetCenterRatio.x;
float target_x = window->ScrollTarget.x;
... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq 0x632f4(%rip), %r14 # 0xa46a0
movsd 0x54(%rdi), %xmm6
movss 0x64(%rdi), %xmm2
movss 0x3da92(%rip), %xmm0 # 0x7ee50
ucomiss %xmm2, %xmm0
jbe 0x41435
movss 0x6c(%rbx), %xmm1
testb %bpl, %bpl
je 0x413df
xorps %xmm3, %xmm3
ucomiss... | /ggerganov[P]kbd-audio/imgui/imgui.cpp |
ImGui::PopTextWrapPos() | void ImGui::PopTextWrapPos()
{
ImGuiWindow* window = GetCurrentWindow();
window->DC.TextWrapPosStack.pop_back();
window->DC.TextWrapPos = window->DC.TextWrapPosStack.empty() ? -1.0f : window->DC.TextWrapPosStack.back();
} | pushq %rax
movq 0x62950(%rip), %rax # 0xa46a0
movq 0x1a80(%rax), %rax
movb $0x1, 0x80(%rax)
movl 0x1e8(%rax), %ecx
testl %ecx, %ecx
jle 0x41d9c
movl %ecx, %edx
decl %edx
movl %edx, 0x1e8(%rax)
je 0x41d8a
cmpl $0x1, %ecx
je 0x41dbb
movq 0x1f0(%rax), %rcx
movl %edx, %edx
movss -0x4(%rcx,%rdx,4), %xmm0
jmp 0x41d92
mov... | /ggerganov[P]kbd-audio/imgui/imgui.cpp |
ImGui::SetWindowFontScale(float) | void ImGui::SetWindowFontScale(float scale)
{
IM_ASSERT(scale > 0.0f);
ImGuiContext& g = *GImGui;
ImGuiWindow* window = GetCurrentWindow();
window->FontWindowScale = scale;
g.FontSize = g.DrawListSharedData.FontSize = window->CalcFontSize();
} | xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0x423a5
movq 0x6233e(%rip), %rax # 0xa46a0
movq 0x1a80(%rax), %rcx
movb $0x1, 0x80(%rcx)
movss %xmm0, 0x2a8(%rcx)
mulss 0x192c(%rax), %xmm0
movq 0x360(%rcx), %rcx
testq %rcx, %rcx
je 0x42394
mulss 0x2a8(%rcx), %xmm0
movss %xmm0, 0x1940(%rax)
movss %xmm0, 0x1928(%rax)
retq... | /ggerganov[P]kbd-audio/imgui/imgui.cpp |
ImGui::PushID(char const*, char const*) | void ImGui::PushID(const char* str_id_begin, const char* str_id_end)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
ImGuiID id = window->GetIDNoKeepAlive(str_id_begin, str_id_end);
window->IDStack.push_back(id);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %rsi
movq 0x61e5f(%rip), %rax # 0xa46a0
movq 0x1a80(%rax), %rbx
movq %rbx, %rdi
callq 0x34d28
movl %eax, %ebp
movl 0xc0(%rbx), %r15d
movl 0xc4(%rbx), %eax
cmpl %eax, %r15d
jne 0x42912
incl %r15d
testl %eax, %eax
je 0x4287c
movl %eax, ... | /ggerganov[P]kbd-audio/imgui/imgui.cpp |
ImGui::IsRectVisible(ImVec2 const&) | bool ImGui::IsRectVisible(const ImVec2& size)
{
ImGuiWindow* window = GImGui->CurrentWindow;
return window->ClipRect.Overlaps(ImRect(window->DC.CursorPos, window->DC.CursorPos + size));
} | movq 0x619eb(%rip), %rax # 0xa46a0
movq 0x1a80(%rax), %rax
movss 0x264(%rax), %xmm0
ucomiss 0xd4(%rax), %xmm0
jbe 0x42d07
movss 0xd4(%rax), %xmm0
addss 0x4(%rdi), %xmm0
ucomiss 0x25c(%rax), %xmm0
jbe 0x42d07
movss 0xd0(%rax), %xmm0
movss 0x260(%rax), %xmm1
ucomiss %xmm0, %xmm1
jbe 0x42d07
addss (%rdi), %xmm0
ucomis... | /ggerganov[P]kbd-audio/imgui/imgui.cpp |
ImGui::PushItemWidth(float) | void ImGui::PushItemWidth(float item_width)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
window->DC.ItemWidth = (item_width == 0.0f ? window->ItemWidthDefault : item_width);
window->DC.ItemWidthStack.push_back(window->DC.ItemWidth);
g.NextItemData.Flags &= ~ImGuiNextItemDataFl... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x614ce(%rip), %r14 # 0xa46a0
movq 0x1a80(%r14), %r15
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x431ec
jp 0x431ec
movss 0x280(%r15), %xmm0
movss %xmm0, 0x1bc(%r15)
movl 0x1d8(%r15), %ebp
movl 0x1dc(%r15), %eax
cmpl %eax, %ebp
jne 0x432a7
incl %ebp
testl... | /ggerganov[P]kbd-audio/imgui/imgui.cpp |
ImGui::CalcItemSize(ImVec2, float, float) | ImVec2 ImGui::CalcItemSize(ImVec2 size, float default_w, float default_h)
{
ImGuiWindow* window = GImGui->CurrentWindow;
ImVec2 region_max;
if (size.x < 0.0f || size.y < 0.0f)
region_max = GetContentRegionMaxAbs();
if (size.x == 0.0f)
size.x = default_w;
else if (size.x < 0.0f)
... | movq 0x60fcf(%rip), %rax # 0xa46a0
movq 0x1a80(%rax), %rax
xorps %xmm4, %xmm4
ucomiss %xmm0, %xmm4
ja 0x436ef
movaps %xmm0, %xmm5
shufps $0x55, %xmm0, %xmm5 # xmm5 = xmm5[1,1],xmm0[1,1]
xorps %xmm3, %xmm3
ucomiss %xmm5, %xmm4
jbe 0x4370d
movsd 0x270(%rax), %xmm3
cmpq $0x0, 0x1a0(%rax)
je 0x4370d
movss 0x250(%ra... | /ggerganov[P]kbd-audio/imgui/imgui.cpp |
ImGui::GetContentRegionMax() | ImVec2 ImGui::GetContentRegionMax()
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
ImVec2 mx = window->ContentRegionRect.Max - window->Pos;
if (window->DC.CurrentColumns)
mx.x = window->WorkRect.Max.x - window->Pos.x;
return mx;
} | movq 0x60eb5(%rip), %rax # 0xa46a0
movq 0x1a80(%rax), %rax
movsd 0x270(%rax), %xmm0
movsd 0x10(%rax), %xmm1
subps %xmm1, %xmm0
cmpq $0x0, 0x1a0(%rax)
je 0x4381c
movss 0x250(%rax), %xmm2
subss %xmm1, %xmm2
movss %xmm2, %xmm0 # xmm0 = xmm2[0],xmm0[1,2,3]
retq
| /ggerganov[P]kbd-audio/imgui/imgui.cpp |
ImGui::BeginDragDropTarget() | bool ImGui::BeginDragDropTarget()
{
ImGuiContext& g = *GImGui;
if (!g.DragDropActive)
return false;
ImGuiWindow* window = g.CurrentWindow;
if (!(window->DC.LastItemStatusFlags & ImGuiItemStatusFlags_HoveredRect))
return false;
if (g.HoveredWindow == NULL || window->RootWindow != g.H... | pushq %r14
pushq %rbx
pushq %rax
movq 0x5e913(%rip), %r14 # 0xa46a0
cmpb $0x1, 0x1f2c(%r14)
jne 0x45dc4
movq 0x1a80(%r14), %rdi
movl 0x118(%rdi), %eax
testb $0x1, %al
je 0x45dc4
movq 0x1a88(%r14), %rcx
testq %rcx, %rcx
je 0x45dc4
movq 0x368(%rdi), %rdx
cmpq 0x368(%rcx), %rdx
je 0x45dce
xorl %eax, %eax
addq $0x8, %r... | /ggerganov[P]kbd-audio/imgui/imgui.cpp |
ImGui::LogToFile(int, char const*) | void ImGui::LogToFile(int auto_open_depth, const char* filename)
{
ImGuiContext& g = *GImGui;
if (g.LogEnabled)
return;
// FIXME: We could probably open the file in text mode "at", however note that clipboard/buffer logging will still
// be subject to outputting OS-incompatible carriage return ... | pushq %r15
pushq %r14
pushq %rbx
movq 0x5e24c(%rip), %r15 # 0xa46a0
cmpb $0x0, 0x2fd8(%r15)
jne 0x464a0
movl %edi, %ebx
testq %rsi, %rsi
jne 0x46469
movq 0x28(%r15), %rsi
testq %rsi, %rsi
je 0x464a0
cmpb $0x0, (%rsi)
je 0x464a0
leaq 0x39776(%rip), %rax # 0x7fbf0
movq %rsi, %rdi
movq %rax, %rsi
callq 0x22910
tes... | /ggerganov[P]kbd-audio/imgui/imgui.cpp |
ImGui::CreateNewWindowSettings(char const*) | ImGuiWindowSettings* ImGui::CreateNewWindowSettings(const char* name)
{
ImGuiContext& g = *GImGui;
#if !IMGUI_DEBUG_INI_SETTINGS
// Skip to the "###" marker if any. We don't skip past to match the behavior of GetID()
// Preserve the full string when IMGUI_DEBUG_INI_SETTINGS is set to make .ini inspection e... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x2fc8, %r14d # imm = 0x2FC8
addq 0x5df15(%rip), %r14 # 0xa46a0
leaq 0x3adf4(%rip), %rsi # 0x81586
callq 0x223d0
testq %rax, %rax
cmovneq %rax, %rbx
movq %rbx, %rdi
callq 0x22340
movq %rax, %r15
leaq 0x11(%rax), %rsi
movq %r14, %rdi
callq 0x4a64c
m... | /ggerganov[P]kbd-audio/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 &... | pushq %r14
pushq %rbx
pushq %rax
movq 0x5de41(%rip), %r14 # 0xa46a0
xorl %ebx, %ebx
xorl %esi, %esi
xorl %edx, %edx
callq 0x3140c
movslq 0x2fb8(%r14), %rcx
testq %rcx, %rcx
jle 0x4688d
movq 0x2fc0(%r14), %rbx
cmpl %eax, 0x8(%rbx)
je 0x4688d
addq $0x48, %rbx
decq %rcx
jne 0x4687d
xorl %ebx, %ebx
movq %rbx, %rax
addq... | /ggerganov[P]kbd-audio/imgui/imgui.cpp |
ImGui::LoadIniSettingsFromDisk(char const*) | void ImGui::LoadIniSettingsFromDisk(const char* ini_filename)
{
size_t file_data_size = 0;
char* file_data = (char*)ImFileLoadToMemory(ini_filename, "rb", &file_data_size);
if (!file_data)
return;
LoadIniSettingsFromMemory(file_data, (size_t)file_data_size);
IM_FREE(file_data);
} | pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rdx
movq $0x0, (%rdx)
leaq 0x3ac81(%rip), %rsi # 0x8158a
xorl %ecx, %ecx
callq 0x3152d
testq %rax, %rax
je 0x46947
movq %rax, %rbx
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x4694d
movq 0x5dd74(%rip), %rax # 0xa46a0
testq %rax, %rax
je 0x46937
decl 0x3bc(%rax)
movq ... | /ggerganov[P]kbd-audio/imgui/imgui.cpp |
ChildWindowComparer(void const*, void const*) | static int IMGUI_CDECL ChildWindowComparer(const void* lhs, const void* rhs)
{
const ImGuiWindow* const a = *(const ImGuiWindow* const *)lhs;
const ImGuiWindow* const b = *(const ImGuiWindow* const *)rhs;
if (int d = (a->Flags & ImGuiWindowFlags_Popup) - (b->Flags & ImGuiWindowFlags_Popup))
return d... | movq (%rdi), %rcx
movq (%rsi), %rdx
movl 0xc(%rcx), %esi
movl $0x4000000, %r8d # imm = 0x4000000
movl %esi, %eax
andl %r8d, %eax
movl 0xc(%rdx), %edi
andl %edi, %r8d
subl %r8d, %eax
je 0x483c5
retq
movl $0x2000000, %r8d # imm = 0x2000000
andl %r8d, %esi
andl %r8d, %edi
subl %edi, %esi
cmovnel %esi, %eax
j... | /ggerganov[P]kbd-audio/imgui/imgui.cpp |
GetResizeBorderRect(ImGuiWindow*, int, float, float) | static ImRect GetResizeBorderRect(ImGuiWindow* window, int border_n, float perp_padding, float thickness)
{
ImRect rect = window->Rect();
if (thickness == 0.0f) rect.Max -= ImVec2(1,1);
if (border_n == 0) return ImRect(rect.Min.x + perp_padding, rect.Min.y - thickness, rect.Max.x - perp_padding, rect.Min... | movaps %xmm1, %xmm2
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm2
movsd 0x10(%rdi), %xmm4
movsd 0x18(%rdi), %xmm1
addps %xmm4, %xmm1
jne 0x48523
jp 0x48523
addps 0x3676d(%rip), %xmm1 # 0x7ec90
cmpl $0x3, %esi
ja 0x485c1
movl %esi, %eax
leaq 0x36aa3(%rip), %rcx # 0x7efd8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq ... | /ggerganov[P]kbd-audio/imgui/imgui.cpp |
NavRestoreLayer(ImGuiNavLayer) | static void NavRestoreLayer(ImGuiNavLayer layer)
{
ImGuiContext& g = *GImGui;
g.NavLayer = layer;
if (layer == 0)
g.NavWindow = ImGui::NavRestoreLastChildNavWindow(g.NavWindow);
ImGuiWindow* window = g.NavWindow;
if (layer == 0 && window->NavLastIds[0] != 0)
ImGui::SetNavIDWithRectRe... | movl %edi, %eax
movq 0x5bc3a(%rip), %rcx # 0xa46a0
movl %edi, 0x1c44(%rcx)
testl %edi, %edi
jne 0x48a8c
movq 0x1bf8(%rcx), %rdx
movq 0x380(%rdx), %rsi
testq %rsi, %rsi
cmoveq %rdx, %rsi
movq %rsi, 0x1bf8(%rcx)
movq 0x1bf8(%rcx), %rdi
testl %eax, %eax
je 0x48aa1
movl $0x1, %esi
jmp 0x4015c
movl 0x388(%rdi), %eax
tes... | /ggerganov[P]kbd-audio/imgui/imgui.cpp |
ImGui::ShowMetricsWindow(bool*)::Funcs::NodeDrawCmdShowMeshAndBoundingBox(ImGuiWindow*, ImDrawList const*, ImDrawCmd const*, int, bool, bool) | static void NodeDrawCmdShowMeshAndBoundingBox(ImGuiWindow* window, const ImDrawList* draw_list, const ImDrawCmd* draw_cmd, int elem_offset, bool show_mesh, bool show_aabb)
{
IM_ASSERT(show_mesh || show_aabb);
ImDrawList* fg_draw_list = GetForegroundDrawList(window); // Render additional ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %ecx, %r14d
movl %r14d, %eax
orb %r8b, %al
je 0x493b4
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r13
movl %r8d, 0x4(%rsp)
movq 0x5b507(%rip), %rbx # 0xa46a0
cmpl $0x0, 0x10(%rdi)
jle 0x491a5
movq 0x18(%r13), %rbp
jmp 0x491a7
x... | /ggerganov[P]kbd-audio/imgui/imgui.cpp |
ImGuiWindowTempData::~ImGuiWindowTempData() | struct IMGUI_API ImGuiWindowTempData
{
// Layout
ImVec2 CursorPos; // Current emitting position, in absolute coordinates.
ImVec2 CursorPosPrevLine;
ImVec2 CursorStartPos; // Initial position after Begin(), generally ~ window positio... | pushq %rbx
movq %rdi, %rbx
movq 0x130(%rdi), %rdi
testq %rdi, %rdi
je 0x498dd
movq 0x5addb(%rip), %rax # 0xa46a0
testq %rax, %rax
je 0x498d0
decl 0x3bc(%rax)
movq 0x5add9(%rip), %rsi # 0xa46b0
callq *0x5ac2b(%rip) # 0xa4508
movq 0x120(%rbx), %rdi
testq %rdi, %rdi
je 0x49908
movq 0x5adb0(%rip), %rax ... | /ggerganov[P]kbd-audio/imgui/imgui_internal.h |
ImGuiWindow::TitleBarRect() const | ImRect TitleBarRect() const { return ImRect(Pos, ImVec2(Pos.x + SizeFull.x, Pos.y + TitleBarHeight())); } | movups 0x20(%rdi), %xmm0
movsd 0x10(%rdi), %xmm1
xorps %xmm3, %xmm3
testb $0x1, 0xc(%rdi)
jne 0x4a14b
movq 0x5a589(%rip), %rax # 0xa46a0
movss 0x192c(%rax), %xmm2
mulss 0x2a8(%rdi), %xmm2
movq 0x360(%rdi), %rcx
testq %rcx, %rcx
je 0x4a13b
mulss 0x2a8(%rcx), %xmm2
movss 0x15a4(%rax), %xmm3
addss %xmm3, %xmm3
addss %... | /ggerganov[P]kbd-audio/imgui/imgui_internal.h |
ImPool<ImGuiTabBar>::Clear() | void Clear() { for (int n = 0; n < Map.Data.Size; n++) { int idx = Map.Data[n].val_i; if (idx != -1) Buf[idx].~T(); } Map.Clear(); Buf.clear(); FreeIdx = 0; } | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x10(%rdi)
jle 0x4a300
movl $0x8, %r14d
xorl %r15d, %r15d
movq 0x18(%rbx), %rax
movslq (%rax,%r14), %r12
cmpq $-0x1, %r12
je 0x4a2ec
cmpl %r12d, (%rbx)
jle 0x4a351
movq 0x8(%rbx), %r13
shlq $0x7, %r12
movq 0x78(%r13,%r12), %rdi
testq %rdi... | /ggerganov[P]kbd-audio/imgui/imgui_internal.h |
ImGuiTextBuffer::clear() | void clear() { Buf.clear(); } | pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x4a4a1
movq $0x0, (%rbx)
movq 0x5a21f(%rip), %rax # 0xa46a0
testq %rax, %rax
je 0x4a48c
decl 0x3bc(%rax)
movq 0x5a21d(%rip), %rsi # 0xa46b0
callq *0x5a06f(%rip) # 0xa4508
movq $0x0, 0x8(%rbx)
popq %rbx
retq
nop
| /ggerganov[P]kbd-audio/imgui/imgui.h |
ImChunkStream<ImGuiWindowSettings>::alloc_chunk(unsigned long) | T* alloc_chunk(size_t sz) { size_t HDR_SZ = 4; sz = ((HDR_SZ + sz) + 3u) & ~3u; 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 0x4a706
testl %eax, %eax
je 0x4a68b
movl %eax, %r13d
shrl $0x1f, %r13d
addl %eax, %r13d
sarl %... | /ggerganov[P]kbd-audio/imgui/imgui_internal.h |
ImGuiInputTextState::~ImGuiInputTextState() | struct IMGUI_API ImGuiInputTextState
{
ImGuiID ID; // widget id owning the text state
int CurLenW, CurLenA; // we need to maintain our buffer length in both UTF-8 and wchar format. UTF-8 length is valid even if TextA is not.
ImVector<ImWchar> ... | pushq %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x4a9fe
movq 0x59cba(%rip), %rax # 0xa46a0
testq %rax, %rax
je 0x4a9f1
decl 0x3bc(%rax)
movq 0x59cb8(%rip), %rsi # 0xa46b0
callq *0x59b0a(%rip) # 0xa4508
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x4aa26
movq 0x59c92(%rip), %rax #... | /ggerganov[P]kbd-audio/imgui/imgui_internal.h |
ImGui::StyleColorsLight(ImGuiStyle*) | void ImGui::StyleColorsLight(ImGuiStyle* dst)
{
ImGuiStyle* style = dst ? dst : &ImGui::GetStyle();
ImVec4* colors = style->Colors;
colors[ImGuiCol_Text] = ImVec4(0.00f, 0.00f, 0.00f, 1.00f);
colors[ImGuiCol_TextDisabled] = ImVec4(0.60f, 0.60f, 0.60f, 1.00f);
colors[ImGu... | pushq %rax
testq %rdi, %rdi
jne 0x4b910
callq 0x32dce
movq %rax, %rdi
movaps 0x38649(%rip), %xmm0 # 0x83f60
movups %xmm0, 0xb8(%rdi)
movaps 0x3841b(%rip), %xmm0 # 0x83d40
movups %xmm0, 0xc8(%rdi)
movaps 0x3863d(%rip), %xmm0 # 0x83f70
movups %xmm0, 0xd8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0xe8(%rdi)
movaps 0... | /ggerganov[P]kbd-audio/imgui/imgui_draw.cpp |
ImDrawList::ClearFreeMemory() | void ImDrawList::ClearFreeMemory()
{
CmdBuffer.clear();
IdxBuffer.clear();
VtxBuffer.clear();
_VtxCurrentIdx = 0;
_VtxWritePtr = NULL;
_IdxWritePtr = NULL;
_ClipRectStack.clear();
_TextureIdStack.clear();
_Path.clear();
_Splitter.ClearFreeMemory();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x4bf6f
xorl %r14d, %r14d
movq %r14, (%rbx)
callq 0x3112f
movq %r14, 0x8(%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x4bf88
xorl %r14d, %r14d
movq %r14, 0x10(%rbx)
callq 0x3112f
movq %r14, 0x18(%rbx)
movq 0x28(%rbx), %rdi
tes... | /ggerganov[P]kbd-audio/imgui/imgui_draw.cpp |
ImDrawList::AddCallback(void (*)(ImDrawList const*, ImDrawCmd const*), void*) | void ImDrawList::AddCallback(ImDrawCallback callback, void* callback_data)
{
ImDrawCmd* current_cmd = CmdBuffer.Size ? &CmdBuffer.back() : NULL;
if (!current_cmd || current_cmd->ElemCount != 0 || current_cmd->UserCallback != NULL)
{
AddDrawCmd();
current_cmd = &CmdBuffer.back();
}
cu... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl (%rdi), %eax
testq %rax, %rax
je 0x4c49c
testl %eax, %eax
jle 0x4c4e3
movq 0x8(%r14), %rcx
imulq $0x38, %rax, %rax
addq %rcx, %rax
addq $-0x38, %rax
jmp 0x4c49e
xorl %eax, %eax
testq %rax, %rax
je 0x4c4af
cmpl $0x0, (%rax)
jne 0x4c4af... | /ggerganov[P]kbd-audio/imgui/imgui_draw.cpp |
ImDrawList::UpdateTextureID() | void ImDrawList::UpdateTextureID()
{
// If current command is used with different settings we need to add a new command
const ImTextureID curr_texture_id = GetCurrentTextureId();
ImDrawCmd* curr_cmd = CmdBuffer.Size ? &CmdBuffer.back() : NULL;
if (!curr_cmd || (curr_cmd->ElemCount != 0 && curr_cmd->Text... | movslq 0x70(%rdi), %rax
testq %rax, %rax
je 0x4c624
movq 0x78(%rdi), %rcx
movq -0x8(%rcx,%rax,8), %rax
jmp 0x4c626
xorl %eax, %eax
movl (%rdi), %ecx
testq %rcx, %rcx
je 0x4c646
testl %ecx, %ecx
jle 0x4c6d8
movq 0x8(%rdi), %rdx
imulq $0x38, %rcx, %rsi
addq %rsi, %rdx
addq $-0x38, %rdx
jmp 0x4c648
xorl %edx, %edx
testq %... | /ggerganov[P]kbd-audio/imgui/imgui_draw.cpp |
ImDrawList::PrimRectUV(ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, unsigned int) | void ImDrawList::PrimRectUV(const ImVec2& a, const ImVec2& c, const ImVec2& uv_a, const ImVec2& uv_c, ImU32 col)
{
ImVec2 b(c.x, a.y), d(a.x, c.y), uv_b(uv_c.x, uv_a.y), uv_d(uv_a.x, uv_c.y);
ImDrawIdx idx = (ImDrawIdx)_VtxCurrentIdx;
_IdxWritePtr[0] = idx; _IdxWritePtr[1] = (ImDrawIdx)(idx+1); _IdxWritePtr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl (%rsi), %eax
movl %eax, -0x4(%rsp)
movl 0x4(%rsi), %ebp
movl (%rdx), %r14d
movl 0x4(%rdx), %r11d
movl (%rcx), %eax
movl %eax, -0x8(%rsp)
movl 0x4(%rcx), %r15d
movl (%r8), %r12d
movl 0x4(%r8), %ebx
movl 0x4c(%rdi), %r13d
movq 0x58(%rdi), %rax
movl %r... | /ggerganov[P]kbd-audio/imgui/imgui_draw.cpp |
ImDrawList::AddPolyline(ImVec2 const*, int, unsigned int, bool, float) | void ImDrawList::AddPolyline(const ImVec2* points, const int points_count, ImU32 col, bool closed, float thickness)
{
if (points_count < 2)
return;
const ImVec2 opaque_uv = _Data->TexUvWhitePixel;
int count = points_count;
if (!closed)
count = points_count-1;
const bool thick_line ... | cmpl $0x2, %edx
jl 0x4d5cb
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %r14
movl %ecx, -0x2c(%rbp)
movq 0x38(%rdi), %rax
movq (%rax), %rax
movq %rax, -0x68(%rbp)
leal -0x1(%r12), %eax
testb %r8b, %r8b
movl %eax, %edi
cmov... | /ggerganov[P]kbd-audio/imgui/imgui_draw.cpp |
ImDrawList::PathArcToFast(ImVec2 const&, float, int, int) | void ImDrawList::PathArcToFast(const ImVec2& center, float radius, int a_min_of_12, int a_max_of_12)
{
if (radius == 0.0f || a_min_of_12 > a_max_of_12)
{
_Path.push_back(center);
return;
}
// For legacy reason the PathArcToFast() always takes angles where 2*PI is represented by 12,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
setp %al
setne %cl
orb %al, %cl
movl %ebp, %eax
subl %edx, %eax
setge %dl
movl 0x80(%rdi), %r12d
testb %dl, %cl
jne 0x4d941
movl 0x8... | /ggerganov[P]kbd-audio/imgui/imgui_draw.cpp |
ImDrawList::AddQuadFilled(ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, unsigned int) | void ImDrawList::AddQuadFilled(const ImVec2& p1, const ImVec2& p2, const ImVec2& p3, const ImVec2& p4, ImU32 col)
{
if ((col & IM_COL32_A_MASK) == 0)
return;
PathLineTo(p1);
PathLineTo(p2);
PathLineTo(p3);
PathLineTo(p4);
PathFillConvex(col);
} | cmpl $0x1000000, %r9d # imm = 0x1000000
jb 0x4f271
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %ebx
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
movl 0x80(%rdi), %r12d
movl 0x84(%rdi), %eax
cmpl %eax, %r12d
jne 0x4f022
incl %r12d
testl %eax, %eax
je 0x4efb5
mo... | /ggerganov[P]kbd-audio/imgui/imgui_draw.cpp |
ImGui::ShadeVertsLinearUV(ImDrawList*, int, int, ImVec2 const&, ImVec2 const&, ImVec2 const&, ImVec2 const&, bool) | void ImGui::ShadeVertsLinearUV(ImDrawList* draw_list, int vert_start_idx, int vert_end_idx, const ImVec2& a, const ImVec2& b, const ImVec2& uv_a, const ImVec2& uv_b, bool clamp)
{
const ImVec2 size = b - a;
const ImVec2 uv_size = uv_b - uv_a;
const ImVec2 scale = ImVec2(
size.x != 0.0f ? (uv_size.x ... | movq 0x8(%rsp), %rax
movsd (%r8), %xmm1
movsd (%rcx), %xmm0
subps %xmm0, %xmm1
movsd (%rax), %xmm4
movsd (%r9), %xmm3
movaps %xmm4, %xmm0
subps %xmm3, %xmm0
xorps %xmm2, %xmm2
cmpneqps %xmm1, %xmm2
divps %xmm1, %xmm0
andps %xmm2, %xmm0
movq 0x28(%rdi), %rdi
movslq %esi, %rax
leaq (%rax,%rax,4), %rax
leaq (%rdi,%rax,4),... | /ggerganov[P]kbd-audio/imgui/imgui_draw.cpp |
ImFontAtlas::ClearTexData() | void ImFontAtlas::ClearTexData()
{
IM_ASSERT(!Locked && "Cannot modify a locked ImFontAtlas between NewFrame() and EndFrame/Render()!");
if (TexPixelsAlpha8)
IM_FREE(TexPixelsAlpha8);
if (TexPixelsRGBA32)
IM_FREE(TexPixelsRGBA32);
TexPixelsAlpha8 = NULL;
TexPixelsRGBA32 = NULL;
} | pushq %rbx
cmpb $0x1, (%rdi)
je 0x51723
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x51709
callq 0x3112f
movq 0x20(%rbx), %rdi
addq $0x18, %rbx
testq %rdi, %rdi
je 0x5171b
callq 0x3112f
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
popq %rbx
retq
leaq 0x382b2(%rip), %rdi # 0x899dc
leaq 0x38005(%rip), %rsi ... | /ggerganov[P]kbd-audio/imgui/imgui_draw.cpp |
ImFontAtlas::GetTexDataAsRGBA32(unsigned char**, int*, int*, int*) | void ImFontAtlas::GetTexDataAsRGBA32(unsigned char** out_pixels, int* out_width, int* out_height, int* out_bytes_per_pixel)
{
// Convert to RGBA32 format on demand
// Although it is likely to be the most commonly used format, our font rendering is 1 channel / 8 bpp
if (!TexPixelsRGBA32)
{
uns... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
cmpq $0x0, 0x20(%rdi)
je 0x519da
movq 0x20(%r15), %rax
movq %rax, (%r13)
testq %r12, %r12
je 0x519b4
movl 0x28(%r15), %eax
movl %eax, (%r12)
testq %r14, %r14
je 0x5... | /ggerganov[P]kbd-audio/imgui/imgui_draw.cpp |
ImFontAtlas::AddCustomRectRegular(int, int) | int ImFontAtlas::AddCustomRectRegular(int width, int height)
{
IM_ASSERT(width > 0 && width <= 0xFFFF);
IM_ASSERT(height > 0 && height <= 0xFFFF);
ImFontAtlasCustomRect r;
r.Width = (unsigned short)width;
r.Height = (unsigned short)height;
CustomRects.push_back(r);
return CustomRects.Size - ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %r15d
leal -0x1(%r15), %eax
cmpl $0xffff, %eax # imm = 0xFFFF
jae 0x525e4
movl %edx, %r14d
leal -0x1(%r14), %eax
cmpl $0xffff, %eax # imm = 0xFFFF
jae 0x52603
movq %rdi, %rbx
movl 0x50(%rdi), %ebp
movl 0x54(%rdi), %eax
cmpl %eax, %ebp... | /ggerganov[P]kbd-audio/imgui/imgui_draw.cpp |
ImFontAtlasBuildPackCustomRects(ImFontAtlas*, void*) | void ImFontAtlasBuildPackCustomRects(ImFontAtlas* atlas, void* stbrp_context_opaque)
{
stbrp_context* pack_context = (stbrp_context*)stbrp_context_opaque;
IM_ASSERT(pack_context != NULL);
ImVector<ImFontAtlasCustomRect>& user_rects = atlas->CustomRects;
IM_ASSERT(user_rects.Size >= 1); // We expect at ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rsi, %rsi
je 0x56c24
movq %rdi, %rbx
movl 0x50(%rdi), %r15d
testl %r15d, %r15d
jle 0x56c43
movq %rsi, %r14
pxor %xmm0, %xmm0
movdqa %xmm0, (%rsp)
movl 0x4(%rsp), %eax
cmpl %r15d, %eax
jge 0x56acb
testl %eax, %eax
je 0x56a80
movl %eax, %ebp
s... | /ggerganov[P]kbd-audio/imgui/imgui_draw.cpp |
ImFontAtlasBuildFinish(ImFontAtlas*) | static void ImFontAtlasBuildRenderDefaultTexData(ImFontAtlas* atlas)
{
IM_ASSERT(atlas->CustomRectIds[0] >= 0);
IM_ASSERT(atlas->TexPixelsAlpha8 != NULL);
ImFontAtlasCustomRect& r = atlas->CustomRects[atlas->CustomRectIds[0]];
IM_ASSERT(r.IsPacked());
const int w = atlas->TexWidth;
if (!(atlas-... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movslq 0x70(%rdi), %rcx
testq %rcx, %rcx
js 0x5768a
movq %rdi, %rbx
movq 0x18(%rdi), %rdx
testq %rdx, %rdx
je 0x576a9
cmpl %ecx, 0x50(%rbx)
jle 0x576c8
movq 0x58(%rbx), %rax
shlq $0x5, %rcx
movzwl 0x4(%rax,%rcx), %esi
cmpl $0xffff, %esi ... | /ggerganov[P]kbd-audio/imgui/imgui_draw.cpp |
ImFontAtlas::GetGlyphRangesChineseFull() | const ImWchar* ImFontAtlas::GetGlyphRangesChineseFull()
{
static const ImWchar ranges[] =
{
0x0020, 0x00FF, // Basic Latin + Latin Supplement
0x2000, 0x206F, // General Punctuation
0x3000, 0x30FF, // CJK Symbols and Punctuations, Hiragana, Katakana
0x31F0, 0x31FF, // Katakana Ph... | leaq 0x2c8b5(%rip), %rax # 0x844b0
retq
| /ggerganov[P]kbd-audio/imgui/imgui_draw.cpp |
ImFont::ImFont() | inline ImVector() { Size = Capacity = 0; Data = NULL; } | xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
xorl %eax, %eax
movq %rax, 0x30(%rdi)
movw $0xffff, 0x5c(%rdi) # imm = 0xFFFF
movb $0x0, 0x5e(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
movl $0x3f0000, 0x58(%rdi) # imm = 0x3F0000
movl $0x3f800000, 0x60(%rdi) #... | /ggerganov[P]kbd-audio/imgui/imgui.h |
ImFont::AddRemapChar(unsigned short, unsigned short, bool) | void ImFont::AddRemapChar(ImWchar dst, ImWchar src, bool overwrite_dst)
{
IM_ASSERT(IndexLookup.Size > 0); // Currently this can only be called AFTER the font has been built, aka after calling ImFontAtlas::GetTexDataAs*() function.
unsigned int index_size = (unsigned int)IndexLookup.Size;
if (dst < inde... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl 0x18(%rdi), %ebp
testl %ebp, %ebp
jle 0x58329
movq %rdi, %rbx
movzwl %si, %r14d
cmpl %r14d, %ebp
jbe 0x582b0
movq 0x20(%rbx), %rax
cmpw $-0x1, (%rax,%r14,2)
sete %al
xorb $0x1, %cl
testb %cl, %al
jne 0x5831e
cmpl %r14d, %ebp
setbe %al
movzwl %dx, %r15d
cmpl %r... | /ggerganov[P]kbd-audio/imgui/imgui_draw.cpp |
ImGui::RenderColorRectWithAlphaCheckerboard(ImDrawList*, ImVec2, ImVec2, unsigned int, float, ImVec2, float, int) | void ImGui::RenderColorRectWithAlphaCheckerboard(ImDrawList* draw_list, ImVec2 p_min, ImVec2 p_max, ImU32 col, float grid_step, ImVec2 grid_off, float rounding, int rounding_corners_flags)
{
if (((col & IM_COL32_A_MASK) >> IM_COL32_A_SHIFT) < 0xFF)
{
ImU32 col_bg1 = ImGui::GetColorU32(ImAlphaBlendColors... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
movlps %xmm0, 0x18(%rsp)
movlps %xmm1, 0x10(%rsp)
cmpl $0xfeffffff, %esi # imm = 0xFEFFFFFF
jbe 0x59938
leaq 0x18(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
movl %ebp, %ecx
mov... | /ggerganov[P]kbd-audio/imgui/imgui_draw.cpp |
stbtt__cff_get_index(stbtt__buf*) | static stbtt__buf stbtt__cff_get_index(stbtt__buf *b)
{
int count, start, offsize;
start = b->cursor;
count = stbtt__buf_get16(b);
if (count) {
offsize = stbtt__buf_get8(b);
STBTT_assert(offsize >= 1 && offsize <= 4);
stbtt__buf_skip(b, offsize * count);
stbtt__buf_skip(b, stbtt__buf... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %r14d
movl 0xc(%rdi), %eax
xorl %esi, %esi
movl $0x2, %ecx
movl %r14d, %edx
cmpl %eax, %edx
jge 0x59c66
movq (%rbx), %rdi
movslq %edx, %r8
incl %edx
movl %edx, 0x8(%rbx)
movzbl (%rdi,%r8), %edi
jmp 0x59c68
xorl %edi, %edi
shll $0x8, ... | /ggerganov[P]kbd-audio/imgui/imstb_truetype.h |
rect_height_compare(void const*, void const*) | static int STBRP__CDECL rect_height_compare(const void *a, const void *b)
{
const stbrp_rect *p = (const stbrp_rect *) a;
const stbrp_rect *q = (const stbrp_rect *) b;
if (p->h > q->h)
return -1;
if (p->h < q->h)
return 1;
return (p->w > q->w) ? -1 : (p->w < q->w);
} | movzwl 0x6(%rsi), %ecx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpw %cx, 0x6(%rdi)
ja 0x5b29b
movl $0x1, %eax
jb 0x5b29b
movzwl 0x4(%rdi), %eax
xorl %ecx, %ecx
cmpw 0x4(%rsi), %ax
setb %cl
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmovbel %ecx, %eax
retq
| /ggerganov[P]kbd-audio/imgui/imstb_rectpack.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.