name string | code string | asm string | file string |
|---|---|---|---|
VP8LCollectColorBlueTransforms_C | void VP8LCollectColorBlueTransforms_C(const uint32_t* argb, int stride,
int tile_width, int tile_height,
int green_to_blue, int red_to_blue,
int histo[]) {
while (tile_height-- > 0) {
int x;
for (... | testl %ecx, %ecx
jle 0x45721
pushq %rbp
pushq %r14
pushq %rbx
movq 0x20(%rsp), %rax
movsbl %r8b, %r8d
movsbl %r9b, %r9d
movslq %esi, %rsi
movl %edx, %r10d
shlq $0x2, %rsi
testl %edx, %edx
jle 0x4570e
xorl %r11d, %r11d
movl (%rdi,%r11,4), %ebx
movl %ebx, %ebp
shrl $0x8, %ebp
movsbl %bpl, %ebp
imull %r8d, %ebp
shrl $0x5,... | /PKRoma[P]libwebp/src/dsp/lossless_enc.c |
VP8LHistogramAdd | void VP8LHistogramAdd(const VP8LHistogram* const a,
const VP8LHistogram* const b, VP8LHistogram* const out) {
int i;
const int literal_size = VP8LHistogramNumCodes(a->palette_code_bits_);
assert(a->palette_code_bits_ == b->palette_code_bits_);
if (b != out) {
ADD(0, literal_, literal_... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movl 0xca8(%rdi), %ecx
movl $0x1, %eax
shll %cl, %eax
movl $0x118, %edx # imm = 0x118
addl %edx, %eax
testl %ecx, %ecx
cmovlel %edx, %eax
movb 0xcd0(%rdi), %cl
cmpq %rbx, %rsi
je 0x4580b
movq %rsi, %r15
movb 0xcd0(%rsi), %dl
testb %cl, %cl
je 0... | /PKRoma[P]libwebp/src/dsp/lossless_enc.c |
FastLog2Slow_C | static float FastLog2Slow_C(uint32_t v) {
assert(v >= LOG_LOOKUP_IDX_MAX);
if (v < APPROX_LOG_WITH_CORRECTION_MAX) {
#if !defined(WEBP_HAVE_SLOW_CLZ_CTZ)
// use clz if available
const int log_cnt = BitsLog2Floor(v) - 7;
const uint32_t y = 1 << log_cnt;
const uint32_t orig_v = v;
double log_2;
... | cmpl $0xffff, %edi # imm = 0xFFFF
ja 0x45eb1
bsrl %edi, %ecx
xorl $-0x20, %ecx
addl $0x19, %ecx
movl %edi, %eax
shrl %cl, %eax
cvtsi2ss %ecx, %xmm0
leaq 0x13a6e(%rip), %rdx # 0x598e0
addss (%rdx,%rax,4), %xmm0
cmpl $0x1000, %edi # imm = 0x1000
jb 0x45ece
movl $0xffffffff, %eax # imm = 0xFF... | /PKRoma[P]libwebp/src/dsp/lossless_enc.c |
ExtraCostCombined_C | static double ExtraCostCombined_C(const uint32_t* X, const uint32_t* Y,
int length) {
int i;
double cost = 0.;
for (i = 2; i < length - 2; ++i) {
const int xy = X[i + 2] + Y[i + 2];
cost += (i >> 1) * xy;
}
return cost;
} | xorpd %xmm0, %xmm0
cmpl $0x5, %edx
jl 0x45faa
addl $-0x2, %edx
movl $0x2, %eax
movl 0x8(%rsi,%rax,4), %ecx
addl 0x8(%rdi,%rax,4), %ecx
movl %eax, %r8d
shrl %r8d
imull %ecx, %r8d
xorps %xmm1, %xmm1
cvtsi2sd %r8d, %xmm1
addsd %xmm1, %xmm0
incq %rax
cmpq %rax, %rdx
jne 0x45f84
retq
| /PKRoma[P]libwebp/src/dsp/lossless_enc.c |
GetEntropyUnrefined_C | static void GetEntropyUnrefined_C(const uint32_t X[], int length,
VP8LBitEntropy* const bit_entropy,
VP8LStreaks* const stats) {
int i;
int i_prev = 0;
uint32_t x_prev = X[0];
memset(stats, 0, sizeof(*stats));
VP8LBitEntropyInit(bit_entropy)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movl (%rdi), %r14d
xorps %xmm0, %xmm0
movups %xmm0, (%rcx)
movq $0x0, 0x10(%rcx)
movups %xmm0, (%rdx)
movabsq $-0x100000000, %rax # imm = 0xFFFFFFFF00000000
movq %rax, 0x10(%rdx)
cmpl $0x2, %esi
jl 0x46283
leaq 0x8(%r... | /PKRoma[P]libwebp/src/dsp/lossless_enc.c |
VP8LEncDspInitSSE2 | WEBP_TSAN_IGNORE_FUNCTION void VP8LEncDspInitSSE2(void) {
VP8LSubtractGreenFromBlueAndRed = SubtractGreenFromBlueAndRed_SSE2;
VP8LTransformColor = TransformColor_SSE2;
VP8LCollectColorBlueTransforms = CollectColorBlueTransforms_SSE2;
VP8LCollectColorRedTransforms = CollectColorRedTransforms_SSE2;
VP8LAddVecto... | leaq 0x13b(%rip), %rax # 0x46e2a
leaq 0x24602(%rip), %rcx # 0x6b2f8
movq %rax, (%rcx)
leaq 0x172(%rip), %rax # 0x46e72
leaq 0x245f9(%rip), %rcx # 0x6b300
movq %rax, (%rcx)
leaq 0x22f(%rip), %rax # 0x46f40
leaq 0x245f0(%rip), %rcx # 0x6b308
movq %rax, (%rcx)
leaq 0x378(%rip), %rax # 0... | /PKRoma[P]libwebp/src/dsp/lossless_enc_sse2.c |
PopulationCost | static double PopulationCost(const uint32_t* const population, int length,
uint32_t* const trivial_sym,
uint8_t* const is_used) {
VP8LBitEntropy bit_entropy;
VP8LStreaks stats;
VP8LGetEntropyUnrefined(population, length, &bit_entropy, &stats);
if (trivia... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rcx, %rbx
movq %rdx, %r14
leaq 0x206a0(%rip), %rax # 0x6b340
movq %rsp, %r15
leaq 0x18(%rsp), %rcx
movq %r15, %rdx
callq *(%rax)
movl 0xc(%r15), %edx
testq %r14, %r14
je 0x4acc7
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmpl $0x1, %edx
jne 0x4acc4
movl 0... | /PKRoma[P]libwebp/src/enc/histogram_enc.c |
process_midi | void process_midi(PtTimestamp timestamp, void *userData)
{
PmError result;
PmEvent buffer; /* just one message at a time */
current_timestamp++; /* update every millisecond */
/* if (current_timestamp % 1000 == 0)
printf("time %d\n", current_timestamp); */
/* do nothing until ini... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl 0x7de7(%rip), %eax # 0xa3dc
addl $0x1, %eax
movl %eax, 0x7dde(%rip) # 0xa3dc
cmpl $0x0, 0x7dd3(%rip) # 0xa3d8
jne 0x2616
movl $0x1, 0x7ddb(%rip) # 0xa3ec
jmp 0x28ea
cmpl $0x0, 0x7dc7(%rip) # 0xa3e4
jne... | /jwinarske[P]portmidi/pm_test/midithru.c |
initialize | void initialize()
/* set up midi processing thread and open midi streams */
{
/* note that it is safe to call PortMidi from the main thread for
initialization and opening devices. You should not make any
calls to PortMidi from this thread once the midi thread begins.
to make PortMidi call... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x400, %edi # imm = 0x400
movl $0x8, %esi
callq 0x3340
movq %rax, 0x7ab2(%rip) # 0xa400
cmpq $0x0, 0x7aaa(%rip) # 0xa400
je 0x295a
jmp 0x2979
leaq 0x4749(%rip), %rdi # 0x70aa
leaq 0x46a6(%rip), %rsi # 0x700e
movl $0xfd, %edx
leaq 0x4747(%r... | /jwinarske[P]portmidi/pm_test/midithru.c |
finalize | void finalize()
{
/* the timer thread could be in the middle of accessing PortMidi stuff */
/* to detect that it is done, we first clear process_midi_exit_flag and
then wait for the timer thread to set it
*/
process_midi_exit_flag = FALSE;
active = FALSE;
/* busy wait for flag fr... | pushq %rbp
movq %rsp, %rbp
movl $0x0, 0x78ee(%rip) # 0xa3ec
movl $0x0, 0x78d0(%rip) # 0xa3d8
cmpl $0x0, 0x78dd(%rip) # 0xa3ec
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x2b1a
jmp 0x2b1c
jmp 0x2b08
movb $0x0, %al
callq 0x3270
movq 0x78d6(%rip), %rdi # 0xa400
callq 0x34b0
movq 0x78d2(%rip), %rdi ... | /jwinarske[P]portmidi/pm_test/midithru.c |
main | int main(int argc, char *argv[])
{
PmTimestamp last_time = 0;
PmEvent buffer;
/* determine what type of test to run */
printf("begin PortMidi midithru program...\n");
initialize(); /* set up and start midi processing */
printf("%s\n%s\n",
"This program will run for 60 s... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
leaq 0x45e9(%rip), %rdi # 0x716d
movb $0x0, %al
callq 0x2070
callq 0x2930
leaq 0x45fa(%rip), %rdi # 0x7191
leaq 0x45fa(%rip), %rsi # 0x7198
leaq 0x4635(%rip), %rdx # ... | /jwinarske[P]portmidi/pm_test/midithru.c |
pm_init | void pm_init()
{
/* Note: it is not an error for PMALSA to fail to initialize.
* It may be a design error that the client cannot query what subsystems
* are working properly other than by looking at the list of available
* devices.
*/
#ifdef PMALSA
pm_linuxalsa_init();
#endif
... | pushq %rbp
movq %rsp, %rbp
callq 0x6480
leaq 0x77e0(%rip), %rax # 0xa440
movl $0x1, (%rax)
leaq 0x760b(%rip), %rax # 0xa278
movl (%rax), %edx
leaq 0x45b1(%rip), %rdi # 0x7227
movl $0x1, %esi
callq 0x2e20
movl %eax, %ecx
leaq 0x75ef(%rip), %rax # 0xa278
movl %ecx, (%rax)
leaq 0x75ea(%rip), %rax ... | /jwinarske[P]portmidi/pm_linux/pmlinux.c |
find_default_device | PmDeviceID find_default_device(char *path, int input, PmDeviceID id)
/* path -- the name of the preference we are searching for
input -- true iff this is an input device
id -- current default device id
returns matching device id if found, otherwise id
*/
{
static char *pref_2 = "/.java/.userPrefs/";
st... | pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
leaq 0x4455(%rip), %rdi # 0x7291
callq 0x2340
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x2e51
jmp 0x30a4
movq -0x18(%rbp), %rdi
callq 0x2220
movq %rax, -0x158(%rbp)
movq... | /jwinarske[P]portmidi/pm_linux/finddefault.c |
Pt_CallbackProc | static void *Pt_CallbackProc(void *p)
{
pt_callback_parameters *parameters = (pt_callback_parameters *) p;
int mytime = 1;
/* to kill a process, just increment the pt_callback_proc_id */
/* printf("pt_callback_proc_id %d, id %d\n", pt_callback_proc_id,
parameters->id); */
if (geteu... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
callq 0x21d0
cmpl $0x0, %eax
jne 0x31c3
xorl %esi, %esi
movl $0xffffffec, %edx # imm = 0xFFFFFFEC
movl %esi, %edi
callq 0x2280
jmp 0x31c5
movl 0x725d(%rip), %eax # 0xa428
movq... | /jwinarske[P]portmidi/porttime/ptlinux.c |
Pt_Stop | PtError Pt_Stop()
{
/* printf("Pt_Stop called\n"); */
pt_callback_proc_id++;
if (pt_thread_created) {
pthread_join(pt_thread_pid, NULL);
pt_thread_created = FALSE;
}
time_started_flag = FALSE;
return ptNoError;
} | pushq %rbp
movq %rsp, %rbp
movl 0x71ae(%rip), %eax # 0xa428
addl $0x1, %eax
movl %eax, 0x71a5(%rip) # 0xa428
cmpl $0x0, 0x71ae(%rip) # 0xa438
je 0x32a6
movq 0x719d(%rip), %rdi # 0xa430
xorl %eax, %eax
movl %eax, %esi
callq 0x2060
movl $0x0, 0x7192(%rip) # 0xa438
movl $0x0, 0x7160(%rip) # 0... | /jwinarske[P]portmidi/porttime/ptlinux.c |
Pt_Time | PtTimestamp Pt_Time()
{
long seconds, milliseconds;
struct timeb now;
ftime(&now);
seconds = now.time - time_offset.time;
milliseconds = now.millitm - time_offset.millitm;
return seconds * 1000 + milliseconds;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq -0x20(%rbp), %rdi
callq 0x2290
movq -0x20(%rbp), %rax
subq 0x712c(%rip), %rax # 0xa418
movq %rax, -0x8(%rbp)
movzwl -0x18(%rbp), %eax
movzwl 0x7125(%rip), %ecx # 0xa420
subl %ecx, %eax
cltq
movq %rax, -0x10(%rbp)
imulq $0x3e8, -0x8(%rbp), %rax # imm = 0x3E8
add... | /jwinarske[P]portmidi/porttime/ptlinux.c |
curlx_sitouz | size_t curlx_sitouz(int sinum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(sinum >= 0);
return (size_t) sinum;
#ifdef __INTEL_COMPILER
# pragma warning(pop)
#endif
} | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
jmp 0x2b39
movslq -0x4(%rbp), %rax
popq %rbp
retq
| /DarovskikhAndrei[P]curl/lib/warnless.c |
cimg_library::CImgDisplay::_init_fullscreen() | void _init_fullscreen() {
if (!_is_fullscreen || _is_closed) return;
Display *const dpy = cimg::X11_attr().display;
_background_window = 0;
#ifdef cimg_use_xrandr
int foo;
if (XRRQueryExtension(dpy,&foo,&foo)) {
XRRRotations(dpy,DefaultScreen(dpy),&cimg::X11_attr().curr_rotation);... | cmpb $0x1, 0x30(%rdi)
jne 0x90994
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
movq %rdi, %rbx
cmpb $0x0, 0x74(%rdi)
jne 0x90987
callq 0x8f140
movq 0x70(%rax), %r14
andq $0x0, 0xe8(%rbx)
callq 0x80aca
movl %eax, %ebp
callq 0x80b6e
movl %eax, %r15d
cmpl 0x18(%rbx), %ebp
jne 0x90... | /abel0b[P]shadow/external/cimg/CImg.h |
cimg_library::cimg::sleep(unsigned int) | inline void sleep(const unsigned int milliseconds) {
#if cimg_OS==1
struct timespec tv;
tv.tv_sec = milliseconds/1000;
tv.tv_nsec = (milliseconds%1000)*1000000;
nanosleep(&tv,0);
#elif cimg_OS==2
Sleep(milliseconds);
#else
cimg::unused(milliseconds);
#endif
} | subq $0x18, %rsp
movl %edi, %eax
movl $0x3e8, %ecx # imm = 0x3E8
xorl %edx, %edx
divl %ecx
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
imull $0xf4240, %edx, %eax # imm = 0xF4240
movq %rax, 0x8(%rdi)
xorl %esi, %esi
callq 0x79280
addq $0x18, %rsp
retq
| /abel0b[P]shadow/external/cimg/CImg.h |
cimg_library::CImgDisplay::set_key(unsigned int, bool) | CImgDisplay& set_key(const unsigned int keycode, const bool is_pressed=true) {
#define _cimg_set_key(k) if (keycode==cimg::key##k) _is_key##k = is_pressed;
_cimg_set_key(ESC); _cimg_set_key(F1); _cimg_set_key(F2); _cimg_set_key(F3);
_cimg_set_key(F4); _cimg_set_key(F5); _cimg_set_key(F6); _cimg_set_key(F7);... | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
leal -0x20(%r14), %eax
cmpl $0x5a, %eax
jbe 0x91224
leal -0xffaa(%r14), %eax
cmpl $0x55, %eax
ja 0x9123f
leaq 0xa9204(%rip), %rcx # 0x13a414
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb %dl, 0xce(%rbx)
jmp 0x91601
leaq 0xa901d(%rip), %r... | /abel0b[P]shadow/external/cimg/CImg.h |
void cimg_library::CImgDisplay::_render_resize<unsigned short, unsigned short>(unsigned short const*, unsigned int, unsigned int, unsigned short*, unsigned int, unsigned int) | static void _render_resize(const T *ptrs, const unsigned int ws, const unsigned int hs,
t *ptrd, const unsigned int wd, const unsigned int hd) {
typedef typename cimg::last<T,cimg_ulong>::type ulongT;
const ulongT one = (ulongT)1;
CImg<ulongT> off_x(wd), off_y(hd + 1);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %r9d, %ebx
movl %r8d, %r13d
movq %rcx, %r14
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, (%rsp)
leaq 0x38(%rsp), %rdi
pushq $0x1
popq %rbp
movl %r8d, %esi
movl %ebp, %edx
movl %ebp, %ecx
movl %ebp, %r8d
callq 0x8ca82
movq %rbx, 0x8(... | /abel0b[P]shadow/external/cimg/CImg.h |
void cimg_library::CImgDisplay::_render_resize<unsigned int, unsigned int>(unsigned int const*, unsigned int, unsigned int, unsigned int*, unsigned int, unsigned int) | static void _render_resize(const T *ptrs, const unsigned int ws, const unsigned int hs,
t *ptrd, const unsigned int wd, const unsigned int hd) {
typedef typename cimg::last<T,cimg_ulong>::type ulongT;
const ulongT one = (ulongT)1;
CImg<ulongT> off_x(wd), off_y(hd + 1);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %r9d, %ebx
movl %r8d, %r13d
movq %rcx, %r14
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, (%rsp)
leaq 0x38(%rsp), %rdi
pushq $0x1
popq %rbp
movl %r8d, %esi
movl %ebp, %edx
movl %ebp, %ecx
movl %ebp, %r8d
callq 0x8ca82
movq %rbx, 0x8(... | /abel0b[P]shadow/external/cimg/CImg.h |
cimg_library::cimg::wget_path(char const*, bool) | inline const char *wget_path(const char *const user_path, const bool reinit_path) {
static CImg<char> s_path;
cimg::mutex(7);
if (reinit_path) s_path.assign();
if (user_path) {
if (!s_path) s_path.assign(1024);
std::strncpy(s_path,user_path,1023);
} else if (!s_path) {
... | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movb 0x14ea7a(%rip), %al # 0x1ef0d8
testb %al, %al
je 0xa073f
pushq $0x7
popq %rdi
pushq $0x1
popq %rsi
callq 0x7e968
testb %bpl, %bpl
je 0xa0682
leaq 0x14ea3b(%rip), %rdi # 0x1ef0b8
callq 0x835d6
movq 0x14ea47(%rip), %rdi # 0x1ef0d0
testq %rbx,... | /abel0b[P]shadow/external/cimg/CImg.h |
cimg_library::cimg::gunzip_path(char const*, bool) | inline const char *gunzip_path(const char *const user_path, const bool reinit_path) {
static CImg<char> s_path;
cimg::mutex(7);
if (reinit_path) s_path.assign();
if (user_path) {
if (!s_path) s_path.assign(1024);
std::strncpy(s_path,user_path,1023);
} else if (!s_path) {
... | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movb 0x14e95b(%rip), %al # 0x1ef100
testb %al, %al
je 0xa088d
pushq $0x7
popq %rdi
pushq $0x1
popq %rsi
callq 0x7e968
testb %bpl, %bpl
je 0xa07c9
leaq 0x14e91c(%rip), %rdi # 0x1ef0e0
callq 0x835d6
movq 0x14e928(%rip), %rdi # 0x1ef0f8
testq %rbx,... | /abel0b[P]shadow/external/cimg/CImg.h |
cimg_library::CImgList<char>::insert(cimg_library::CImg<char> const&, unsigned int, bool) | CImgList<T>& insert(const CImg<T>& img, const unsigned int pos=~0U, const bool is_shared=false) {
const unsigned int npos = pos==~0U?_width:pos;
if (npos>_width)
throw CImgArgumentException(_cimglist_instance
"insert(): Invalid insertion request of specified image... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r12d
movq %rsi, %rbp
movq %rdi, %rbx
cmpl $-0x1, %edx
movl (%rdi), %r13d
cmovel %r13d, %r12d
cmpl %r12d, %r13d
jb 0xa0c49
leal 0x1(%r13), %edx
movl %edx, (%rbx)
movl 0x4(%rbx), %eax
cmpl %eax, %edx
jbe 0xa0ae8
movl %ecx, 0x4(... | /abel0b[P]shadow/external/cimg/CImg.h |
cimg_library::CImg<unsigned char>::_load_ascii(_IO_FILE*, char const*) | CImg<T>& _load_ascii(std::FILE *const file, const char *const filename) {
if (!file && !filename)
throw CImgArgumentException(_cimg_instance
"load_ascii(): Specified filename is (null).",
cimg_instance);
std::FILE *const nfile ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq %rsi, %rax
orq %rdx, %rax
je 0xa0ee3
movq %rdx, %r15
movq %rsi, %r12
movq %rsi, 0x10(%rsp)
testq %rsi, %rsi
jne 0xa0d2f
leaq 0x99c18(%rip), %rsi # 0x13a93c
movq %r15, %rdi
callq 0xa1029
movq %rax, %r12
leaq 0x38(... | /abel0b[P]shadow/external/cimg/CImg.h |
cimg_library::cimg::fopen(char const*, char const*) | inline std::FILE *fopen(const char *const path, const char *const mode) {
if (!path)
throw CImgArgumentException("cimg::fopen(): Specified file path is (null).");
if (!mode)
throw CImgArgumentException("cimg::fopen(): File '%s', specified mode is (null).",
... | pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xa1083
movq %rsi, %r15
movq %rdi, %r14
testq %rsi, %rsi
je 0xa10a1
cmpb $0x2d, (%r14)
jne 0xa1061
movzbl 0x1(%r14), %eax
cmpl $0x2e, %eax
je 0xa1052
testl %eax, %eax
jne 0xa1061
cmpb $0x72, (%r15)
jne 0xa106e
movq 0x14bf49(%rip), %rax # 0x1ecfa8
jmp 0xa1075
movq ... | /abel0b[P]shadow/external/cimg/CImg.h |
cimg_library::CImg<unsigned char>::_load_dlm(_IO_FILE*, char const*) | CImg<T>& _load_dlm(std::FILE *const file, const char *const filename) {
if (!file && !filename)
throw CImgArgumentException(_cimg_instance
"load_dlm(): Specified filename is (null).",
cimg_instance);
std::FILE *const nfile = fi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq %rsi, %rax
orq %rdx, %rax
je 0xa132d
movq %rdx, %r14
movq %rsi, %r15
movq %rsi, %r12
testq %rsi, %rsi
jne 0xa1155
leaq 0x10631c(%rip), %rsi # 0x1a7466
movq %r14, %rdi
callq 0xa1029
movq %rax, %r12
leaq 0x28(%rsp),... | /abel0b[P]shadow/external/cimg/CImg.h |
unsigned long cimg_library::cimg::fread<unsigned char>(unsigned char*, unsigned long, _IO_FILE*) | inline size_t fread(T *const ptr, const size_t nmemb, std::FILE *stream) {
if (!ptr || !stream)
throw CImgArgumentException("cimg::fread(): Invalid reading request of %u %s%s from file %p to buffer %p.",
nmemb,cimg::type<T>::string(),nmemb>1?"s":"",stream,ptr);
if... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdi, %rdi
je 0xa2008
testq %r14, %r14
je 0xa2008
xorl %r12d, %r12d
testq %rbx, %rbx
je 0xa1ff6
pushq $0x1
popq %r13
movq %rbx, 0x10(%rsp)
movl $0x3f00000, %eax # imm = 0x3F000... | /abel0b[P]shadow/external/cimg/CImg.h |
cimg_library::CImg<unsigned char>::_load_jpeg(_IO_FILE*, char const*) | CImg<T>& _load_jpeg(std::FILE *const file, const char *const filename) {
if (!file && !filename)
throw CImgArgumentException(_cimg_instance
"load_jpeg(): Specified filename is (null).",
cimg_instance);
#ifndef cimg_use_jpeg
if ... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq %rsi, %rax
orq %rdx, %rax
je 0xa2798
testq %rsi, %rsi
jne 0xa27fa
movq %r14, %rdi
movq %rdx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7e11a
pushq $0x10
popq %rdi
callq 0x794c0
movq %rax, %rbx
movl (%r14), %edx
movl 0x4(%r14), %ecx
movl 0x8(%r14), %r8d
movl 0xc... | /abel0b[P]shadow/external/cimg/CImg.h |
cimg_library::CImg<unsigned char>::_load_png(_IO_FILE*, char const*, unsigned int*) | CImg<T>& _load_png(std::FILE *const file, const char *const filename, unsigned int *const bits_per_pixel) {
if (!file && !filename)
throw CImgArgumentException(_cimg_instance
"load_png(): Specified filename is (null).",
cimg_instance)... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq %rsi, %rax
orq %rdx, %rax
je 0xa28a4
testq %rsi, %rsi
jne 0xa2906
movq %r14, %rdi
movq %rdx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7e11a
pushq $0x10
popq %rdi
callq 0x794c0
movq %rax, %rbx
movl (%r14), %edx
movl 0x4(%r14), %ecx
movl 0x8(%r14), %r8d
movl 0xc... | /abel0b[P]shadow/external/cimg/CImg.h |
cimg_library::CImg<char>::CImg(unsigned int, unsigned int, unsigned int, unsigned int, char const&) | CImg(const unsigned int size_x, const unsigned int size_y,
const unsigned int size_z, const unsigned int size_c, const T& value):
_is_shared(false) {
const size_t siz = (size_t)size_x*size_y*size_z*size_c;
if (siz) {
_width = size_x; _height = size_y; _depth = size_z; _spectrum = size... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %r15d
movq %rdi, %rbp
movb $0x0, 0x10(%rdi)
movl %esi, %eax
movl %edx, %ecx
imulq %rax, %rcx
movl %r15d, %eax
movl %r8d, %r13d
imulq %rax, %r13
imulq %rcx, %r13
testq %r13, %r13
je 0xa370a
movq %r9, %rbx
movl %r8d, %r12d
movl ... | /abel0b[P]shadow/external/cimg/CImg.h |
cimg_library::CImg<unsigned short>::assign(unsigned int, unsigned int, unsigned int, unsigned int) | CImg<T>& assign(const unsigned int size_x, const unsigned int size_y=1,
const unsigned int size_z=1, const unsigned int size_c=1) {
const size_t siz = (size_t)size_x*size_y*size_z*size_c;
if (!siz) return assign();
const size_t curr_siz = (size_t)size();
if (siz!=curr_siz) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r13
movq %rsi, 0x18(%rsp)
movl %esi, %r15d
movq %rdx, 0x10(%rsp)
movl %edx, %eax
movq %rcx, 0x8(%rsp)
movl %ecx, %ebp
imulq %rax, %rbp
movl %r8d, %r14d
movq %r15, %rbx
imulq %r14, %rbx
imulq %rbp, %rbx
testq %rbx, %rbx
je 0xa... | /abel0b[P]shadow/external/cimg/CImg.h |
unsigned long cimg_library::cimg::fread<unsigned short>(unsigned short*, unsigned long, _IO_FILE*) | inline size_t fread(T *const ptr, const size_t nmemb, std::FILE *stream) {
if (!ptr || !stream)
throw CImgArgumentException("cimg::fread(): Invalid reading request of %u %s%s from file %p to buffer %p.",
nmemb,cimg::type<T>::string(),nmemb>1?"s":"",stream,ptr);
if... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdi, %rdi
je 0xa3afe
testq %r14, %r14
je 0xa3afe
xorl %r12d, %r12d
testq %rbx, %rbx
je 0xa3aec
pushq $0x2
popq %r13
movq %rbx, 0x10(%rsp)
leaq (%rbx,%rbx), %rax
cmpq $0x3f00000, %rax... | /abel0b[P]shadow/external/cimg/CImg.h |
cimg_library::CImg<unsigned char>::load_graphicsmagick_external(char const*) | CImg<T>& load_graphicsmagick_external(const char *const filename) {
if (!filename)
throw CImgArgumentException(_cimg_instance
"load_graphicsmagick_external(): Specified filename is (null).",
cimg_instance);
cimg::fclose(cimg::fo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %r14
testq %rsi, %rsi
je 0xb1a7c
movq %rsi, %r15
leaq 0x89115(%rip), %rsi # 0x13a93c
movq %r15, %rdi
callq 0xa1029
movq %rax, %rdi
callq 0x7e0c0
leaq 0x30(%rsp), %rdi
pushq $0x1
popq %rbx
movl $0x400, %esi # imm... | /abel0b[P]shadow/external/cimg/CImg.h |
Console::log(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void Console::log(std::string message) {
Log entry;
entry.date = std::chrono::system_clock::now();
entry.message = message;
std::time_t date_c = std::chrono::system_clock::to_time_t(entry.date);
std::ostringstream stream;
stream << std::put_time(std::localtime(&date_c), "%H:%M:%S");
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x20(%rsp), %rax
andq $0x0, -0x18(%rax)
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq 0x30(%rsp), %r14
leaq 0x40(%rsp), %r12
movq %r12, -0x10(%r12)
andq $0x0, ... | /abel0b[P]shadow/src/Console.cpp |
ResourcePack::load_mesh(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | void ResourcePack::load_mesh(std::string& name) {
std::ostringstream mesh_file_path_stream;
mesh_file_path_stream << "../res/" << name << ".obj";
std::string mesh_file_path = mesh_file_path_stream.str();
tinyobj::attrib_t attrib;
std::vector<tinyobj::shape_t> shapes;
std::vector<tinyobj::mater... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x308, %rsp # imm = 0x308
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x190(%rsp), %r15
movq %r15, %rdi
callq 0x79d30
leaq 0xc40e0(%rip), %rsi # 0x176566
movq %r15, %rdi
callq 0x79a40
movq %rax, %rdi
movq %rbx, %rsi
callq 0x79920
leaq 0xc40ce(%rip), %rsi # 0... | /abel0b[P]shadow/src/ResourcePack.cpp |
ResourcePack::load_shader(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | void ResourcePack::load_shader(std::string& name) {
std::ostringstream vertex_file_path_stream, fragment_file_path_stream;
vertex_file_path_stream << "../res/" << name << ".vert";
fragment_file_path_stream << "../res/" << name << ".frag";
std::string vertex_file_path = vertex_file_path_stream.str();... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x958, %rsp # imm = 0x958
movq %rsi, %r14
movq %rdi, 0x20(%rsp)
leaq 0x5d8(%rsp), %rdi
callq 0x79d30
leaq 0x460(%rsp), %rdi
callq 0x79d30
leaq 0xc3e30(%rip), %rsi # 0x176566
leaq 0x5d8(%rsp), %rdi
callq 0x79a40
movq %rax, %rdi
movq %... | /abel0b[P]shadow/src/ResourcePack.cpp |
Camera::initialize(GLFWwindow*) | void Camera::initialize(GLFWwindow * window) {
// TODO: FIX
//glfwSetWindowUserPointer(window, this);
auto scroll_callback = [](GLFWwindow * window, double xoffset, double yoffset) {
((Camera *)(window))->scroll(xoffset, yoffset);
};
glfwSetScrollCallback(
window,
scro... | movq %rsi, %rdi
leaq 0x28e(%rip), %rsi # 0xb4026
jmp 0xb76c8
nop
| /abel0b[P]shadow/src/Camera.cpp |
Camera::update_angle(float, double, double, int, int) | void Camera::update_angle(float delta_time, double mouse_x, double mouse_y, int display_w, int display_h) {
horizontal_angle += mouse_speed * delta_time * (display_w/2.0 - mouse_x);
vertical_angle += mouse_speed * delta_time * (display_h/2.0 - mouse_y);
direction = glm::vec3(
cos(vertical_ang... | pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
mulss 0x50(%rdi), %xmm0
movd %edx, %xmm3
movd %esi, %xmm4
punpckldq %xmm3, %xmm4 # xmm4 = xmm4[0],xmm3[0],xmm4[1],xmm3[1]
cvtdq2pd %xmm4, %xmm3
cvtss2sd %xmm0, %xmm0
mulpd 0xc2859(%rip), %xmm3 # 0x176620
unpcklpd %xmm2, %xmm1 # xmm1 = xmm1[0],xmm2[0]
subpd %x... | /abel0b[P]shadow/src/Camera.cpp |
Camera::get_view() | glm::mat4 Camera::get_view() {
up = glm::cross(right, direction);
return glm::lookAt(
position,
position+direction,
up
);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rsi), %rdi
leaq 0x24(%rsi), %r15
movq %r15, %rsi
callq 0xb40c8
leaq 0x18(%r14), %r12
movlps %xmm0, 0x18(%r14)
movss %xmm1, 0x20(%r14)
movq %r14, %rdi
movq %r15, %rsi
callq 0xb40b2
leaq 0x8(%rsp), %rdx
movlps %xmm0, (... | /abel0b[P]shadow/src/Camera.cpp |
Camera::get_projection(float) | glm::mat4 Camera::get_projection(float aspect) {
// std::cout << FoV << std::endl;
return glm::perspective(
glm::radians(FoV),
aspect,
z_near,
z_far
);
} | pushq %rbx
movaps %xmm0, %xmm1
movq %rdi, %rbx
movss 0x48(%rsi), %xmm0
movss 0x54(%rsi), %xmm2
mulss 0xc2639(%rip), %xmm0 # 0x176650
movss 0x58(%rsi), %xmm3
callq 0xb4335
movq %rbx, %rax
popq %rbx
retq
| /abel0b[P]shadow/src/Camera.cpp |
Scene::update(ResourcePack&) | void Scene::update(ResourcePack& resource_pack) {
grid_vertices.reserve((grid_height+1)*(grid_width+1));
for(int i=0; i < grid_height+1; ++i) {
for(int j=0; j < grid_width+1; ++j) {
grid_vertices.push_back(grid_start_x+grid_cell_size*j);
grid_vertices.push_back(-1.0);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, 0x48(%rsp)
movq %rdi, %rbx
leaq 0x20(%rdi), %r15
movslq 0xc(%rdi), %rax
incq %rax
movslq 0x8(%rdi), %rsi
incq %rsi
imulq %rax, %rsi
movq %r15, %rdi
callq 0xb4ff8
leaq 0x40(%rbx), %r12
xorl %ebp, %ebp
leaq 0x28(%rsp), %r13
movq... | /abel0b[P]shadow/src/Scene.cpp |
get_gl_err_str(unsigned int) | const char * get_gl_err_str(GLenum err) {
switch (err) {
case GL_NO_ERROR:
return "No error";
case GL_INVALID_ENUM:
return "Invalid enum";
case GL_INVALID_VALUE:
return "Invalid value";
case GL_INVALID_OPERATION:
return "Invalid operati... | leal -0x500(%rdi), %eax
cmpl $0x5, %eax
ja 0xb48a5
leaq 0xc1f1c(%rip), %rcx # 0x1767b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xc1f54(%rip), %rax # 0x1767f8
retq
testl %edi, %edi
jne 0xb48c1
leaq 0xc1f3f(%rip), %rax # 0x1767ef
retq
leaq 0xc1f7c(%rip), %rax # 0x176834
retq
leaq 0xc1f5... | /abel0b[P]shadow/src/Scene.cpp |
Scene::render(Shadow, bool, int, int, ResourcePack&, Camera&) | void Scene::render(Shadow shadow, bool light_projection, int display_w, int display_h, ResourcePack& resource_pack, Camera& camera) {
if (shadow != Shadow::NoShadow) {
// Generate depth map
render_pass(RenderPass::GenerateDepthMap, shadow, light_projection, display_w, display_h, resource_pack, camer... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movl %r8d, %ebp
movl %ecx, %r14d
movl %esi, %r15d
movq %rdi, %r12
movq 0x40(%rsp), %rax
movzbl %dl, %r13d
testl %esi, %esi
je 0xb492a
movq %r12, %rdi
xorl %esi, %esi
movl %r15d, %edx
movl %r13d, %ecx
movl %r14d, %r8d
movl %ebp, ... | /abel0b[P]shadow/src/Scene.cpp |
Scene::render_pass(RenderPass, Shadow, bool, int, int, ResourcePack&, Camera&) | void Scene::render_pass(RenderPass pass, Shadow shadow, bool light_projection, int display_w, int display_h, ResourcePack& resource_pack, Camera& camera) {
std::string shadow_shader("shadow");
std::string shadowpcf_shader("shadowpcf");
std::string blue_shader("blue");
std::string box_mesh("box");
st... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp # imm = 0x238
movl %r9d, %r12d
movl %r8d, %ebp
movl %ecx, %r15d
movl %edx, 0x4(%rsp)
movl %esi, %ebx
movq %rdi, %r14
leaq 0xf4ad6(%rip), %rsi # 0x1a9498
leaq 0x158(%rsp), %rdi
leaq 0x118(%rsp), %rdx
movq %rdi, 0x8(%rsp)
c... | /abel0b[P]shadow/src/Scene.cpp |
glfwChooseFBConfig | const _GLFWfbconfig* _glfwChooseFBConfig(const _GLFWfbconfig* desired,
const _GLFWfbconfig* alternatives,
unsigned int count)
{
unsigned int i;
unsigned int missing, leastMissing = UINT_MAX;
unsigned int colorDiff, leastColorD... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ecx
movl $0xffffffff, %edx # imm = 0xFFFFFFFF
movq $0x0, -0x8(%rsp)
movl %edx, %r9d
movl %edx, %r10d
subq $0x1, %rcx
jb 0xb5bb4
cmpl $0x0, 0x2c(%rdi)
jle 0xb5a0f
cmpl $0x0, 0x2c(%rsi)
je 0xb5b99
movl 0x38(%rdi), %eax
cmpl 0x38(%rsi), %e... | /abel0b[P]shadow/external/glfw/src/context.c |
glfwGetKeyName | GLFWAPI const char* glfwGetKeyName(int key, int scancode)
{
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (key != GLFW_KEY_UNKNOWN)
{
if (key != GLFW_KEY_KP_EQUAL &&
(key < GLFW_KEY_KP_0 || key > GLFW_KEY_KP_ADD) &&
(key < GLFW_KEY_APOSTROPHE || key > GLFW_KEY_WORLD_2))
{
... | pushq %rax
leaq 0x1381b6(%rip), %rax # 0x1ef160
cmpl $0x0, (%rax)
je 0xb6fe7
cmpl $-0x1, %edi
je 0xb6fdf
cmpl $0x150, %edi # imm = 0x150
je 0xb6fd8
leal -0x14f(%rdi), %eax
cmpl $-0xf, %eax
setb %al
leal -0xa3(%rdi), %ecx
cmpl $-0x7c, %ecx
setb %cl
testb %cl, %al
jne 0xb6ff5
callq 0xc1bd0
movl %eax, %esi
m... | /abel0b[P]shadow/external/glfw/src/input.c |
glfwGetKey | GLFWAPI int glfwGetKey(GLFWwindow* handle, int key)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(GLFW_RELEASE);
if (key < GLFW_KEY_SPACE || key > GLFW_KEY_LAST)
{
_glfwInputError(GLFW_INVALID_ENUM, "Invalid key %i", key);
retur... | pushq %rbx
testq %rdi, %rdi
je 0xb70b1
leaq 0x13810a(%rip), %rax # 0x1ef160
cmpl $0x0, (%rax)
je 0xb7081
movl %esi, %edx
leal -0x15d(%rdx), %eax
cmpl $0xfffffec2, %eax # imm = 0xFFFFFEC2
ja 0xb7093
leaq 0xdb16c(%rip), %rsi # 0x1921dd
xorl %ebx, %ebx
movl $0x10003, %edi # imm = 0x10003
xorl %eax, %... | /abel0b[P]shadow/external/glfw/src/input.c |
refreshVideoModes | static GLFWbool refreshVideoModes(_GLFWmonitor* monitor)
{
int modeCount;
GLFWvidmode* modes;
if (monitor->modes)
return GLFW_TRUE;
modes = _glfwPlatformGetVideoModes(monitor, &modeCount);
if (!modes)
return GLFW_FALSE;
qsort(modes, modeCount, sizeof(GLFWvidmode), compareVideo... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
pushq $0x1
popq %rbx
cmpq $0x0, 0x20(%rdi)
jne 0xb8f20
movq %rdi, %r14
leaq 0xc(%rsp), %rsi
callq 0xbe126
testq %rax, %rax
je 0xb8f1e
movq %rax, %r15
movslq 0xc(%rsp), %rsi
leaq 0x32(%rip), %rcx # 0xb8f2e
pushq $0x18
popq %rdx
movq %rax, %rdi
callq 0x7a3c0
movq 0... | /abel0b[P]shadow/external/glfw/src/monitor.c |
compareVideoModes | static int compareVideoModes(const void* fp, const void* sp)
{
const GLFWvidmode* fm = fp;
const GLFWvidmode* sm = sp;
const int fbpp = fm->redBits + fm->greenBits + fm->blueBits;
const int sbpp = sm->redBits + sm->greenBits + sm->blueBits;
const int farea = fm->width * fm->height;
const int sar... | movl 0xc(%rdi), %eax
addl 0x8(%rdi), %eax
addl 0x10(%rdi), %eax
movl 0xc(%rsi), %ecx
addl 0x8(%rsi), %ecx
addl 0x10(%rsi), %ecx
subl %ecx, %eax
jne 0xb8f65
movl (%rdi), %ecx
movl (%rsi), %edx
movl 0x4(%rdi), %eax
imull %ecx, %eax
movl 0x4(%rsi), %r8d
imull %edx, %r8d
subl %r8d, %eax
jne 0xb8f65
subl %edx, %ecx
jne 0xb8... | /abel0b[P]shadow/external/glfw/src/monitor.c |
ImGui::ColorConvertU32ToFloat4(unsigned int) | ImVec4 ImGui::ColorConvertU32ToFloat4(ImU32 in)
{
float s = 1.0f/255.0f;
return ImVec4(
((in >> IM_COL32_R_SHIFT) & 0xFF) * s,
((in >> IM_COL32_G_SHIFT) & 0xFF) * s,
((in >> IM_COL32_B_SHIFT) & 0xFF) * s,
((in >> IM_COL32_A_SHIFT) & 0xFF) * s);
} | movl $0xff, %eax
movl %edi, %ecx
andl %eax, %ecx
cvtsi2ss %ecx, %xmm0
movss 0xd0b6b(%rip), %xmm2 # 0x197810
mulss %xmm2, %xmm0
movl %edi, %ecx
shrl $0x8, %ecx
andl %eax, %ecx
cvtsi2ss %ecx, %xmm1
mulss %xmm2, %xmm1
unpcklps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movl %edi, %ecx
shrl $0x10, ... | /abel0b[P]shadow/external/imgui/imgui.cpp |
ImGui::BeginChildEx(char const*, unsigned int, ImVec2 const&, bool, int) | bool ImGui::BeginChildEx(const char* name, ImGuiID id, const ImVec2& size_arg, bool border, ImGuiWindowFlags flags)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* parent_window = g.CurrentWindow;
flags |= ImGuiWindowFlags_NoTitleBar|ImGuiWindowFlags_NoResize|ImGuiWindowFlags_NoSavedSettings|ImGuiWindowFlags_Chi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movl %r8d, (%rsp)
movl %ecx, %r15d
movq %rdx, %r13
movl %esi, %ebx
movq %rdi, %r12
movq 0x13ed51(%rip), %rbp # 0x210610
movq 0x1a18(%rbp), %rax
movq %rax, 0x8(%rsp)
movl 0xc(%rax), %r14d
callq 0xd1a6c
movsd (... | /abel0b[P]shadow/external/imgui/imgui.cpp |
ImGui::NavInitWindow(ImGuiWindow*, bool) | void ImGui::NavInitWindow(ImGuiWindow* window, bool force_reinit)
{
ImGuiContext& g = *GImGui;
IM_ASSERT(window == g.NavWindow);
bool init_for_nav = false;
if (!(window->Flags & ImGuiWindowFlags_NoNavInputs))
if (!(window->Flags & ImGuiWindowFlags_ChildWindow) || (window->Flags & ImGuiWindowFlag... | pushq %rbx
movq 0x13eb7b(%rip), %rbx # 0x210610
cmpq %rdi, 0x1b88(%rbx)
jne 0xd1b0b
movl 0xc(%rdi), %eax
btl $0x12, %eax
jb 0xd1af6
andl $0x5000000, %eax # imm = 0x5000000
cmpl $0x1000000, %eax # imm = 0x1000000
jne 0xd1ac7
movl 0x388(%rdi), %eax
testl %eax, %eax
setne %cl
xorb $0x1, %sil
testb %sil, %... | /abel0b[P]shadow/external/imgui/imgui.cpp |
ImGui::EndChild() | void ImGui::EndChild()
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
IM_ASSERT(g.WithinEndChild == false);
IM_ASSERT(window->Flags & ImGuiWindowFlags_ChildWindow); // Mismatched BeginChild()/EndChild() calls
g.WithinEndChild = true;
if (window->BeginCount > 1)
{
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq 0x13ea51(%rip), %r14 # 0x210610
cmpb $0x0, 0x19be(%r14)
jne 0xd1d1d
movq 0x1a18(%r14), %r15
testb $0x1, 0xf(%r15)
je 0xd1d3c
movb $0x1, 0x19be(%r14)
cmpw $0x2, 0x88(%r15)
jl 0xd1bfc
callq 0xd0aea
jmp 0xd1d0b
movq 0x18(%r15), %rcx
movq %rcx, 0x8(%rsp)
movb 0x96(%... | /abel0b[P]shadow/external/imgui/imgui.cpp |
ImGui::BeginChildFrame(unsigned int, ImVec2 const&, int) | bool ImGui::BeginChildFrame(ImGuiID id, const ImVec2& size, ImGuiWindowFlags extra_flags)
{
ImGuiContext& g = *GImGui;
const ImGuiStyle& style = g.Style;
PushStyleColor(ImGuiCol_ChildBg, style.Colors[ImGuiCol_FrameBg]);
PushStyleVar(ImGuiStyleVar_ChildRounding, style.FrameRounding);
PushStyleVar(ImG... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movl %edi, %r15d
movq 0x13e89b(%rip), %r12 # 0x210610
leaq 0x1678(%r12), %rsi
pushq $0x3
popq %rbp
movl %ebp, %edi
callq 0xd1df9
movss 0x1598(%r12), %xmm0
pushq $0x6
popq %rdi
callq 0xd1e49
movss 0x159c(%r12)... | /abel0b[P]shadow/external/imgui/imgui.cpp |
ImGui::PushStyleColor(int, ImVec4 const&) | void ImGui::PushStyleColor(ImGuiCol idx, const ImVec4& col)
{
ImGuiContext& g = *GImGui;
ImGuiColorMod backup;
backup.Col = idx;
backup.BackupValue = g.Style.Colors[idx];
g.ColorModifiers.push_back(backup);
g.Style.Colors[idx] = col;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq 0x13e804(%rip), %r14 # 0x210610
leaq 0xc(%rsp), %rsi
movl %edi, (%rsi)
movslq %edi, %r15
shlq $0x4, %r15
movups 0x1608(%r14,%r15), %xmm0
movups %xmm0, 0x4(%rsi)
leaq 0x1b38(%r14), %rdi
callq 0xda3c4
movups (%rbx), %xmm0
movups %xmm0, 0x1608(%r14,... | /abel0b[P]shadow/external/imgui/imgui.cpp |
ImGui::PushStyleVar(int, ImVec2 const&) | void ImGui::PushStyleVar(ImGuiStyleVar idx, const ImVec2& val)
{
const ImGuiStyleVarInfo* var_info = GetStyleVarInfo(idx);
if (var_info->Type == ImGuiDataType_Float && var_info->Count == 2)
{
ImGuiContext& g = *GImGui;
ImVec2* pvar = (ImVec2*)var_info->GetVarPtr(&g.Style);
g.StyleMod... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movl %edi, %ebp
callq 0xd3357
cmpl $0x8, (%rax)
jne 0xd1f30
cmpl $0x2, 0x4(%rax)
jne 0xd1f30
movq 0x13e71c(%rip), %r14 # 0x210610
movl 0x8(%rax), %r15d
leaq 0x1b48(%r14), %rdi
movsd 0x1558(%r14,%r15), %xmm0
leaq 0xc(%rsp), %rsi
movl %ebp, (... | /abel0b[P]shadow/external/imgui/imgui.cpp |
ImGui::PopStyleVar(int) | void ImGui::PopStyleVar(int count)
{
ImGuiContext& g = *GImGui;
while (count > 0)
{
// We avoid a generic memcpy(data, &backup.Backup.., GDataTypeSize[info->Type] * info->Count), the overhead in Debug is not worth it.
ImGuiStyleMod& backup = g.StyleModifiers.back();
const ImGuiStyleV... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
movq 0x13e6b0(%rip), %r12 # 0x210610
leaq 0x1b48(%r12), %r14
testl %ebx, %ebx
jle 0xd1fd1
movq %r14, %rdi
callq 0xda4de
movq %rax, %r15
movl (%rax), %edi
callq 0xd3357
cmpl $0x8, (%rax)
jne 0xd1fc5
movl 0x8(%rax), %ecx
movl 0x4(%rax), %eax
cmpl $... | /abel0b[P]shadow/external/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 %r15
pushq %r14
pushq %rbx
movl %edi, %ebx
movq 0x13e625(%rip), %r15 # 0x210610
leaq 0x1b38(%r15), %r14
addq $0x1608, %r15 # imm = 0x1608
testl %ebx, %ebx
jle 0xd2021
movq %r14, %rdi
callq 0xda420
movslq (%rax), %rcx
shlq $0x4, %rcx
movups 0x4(%rax), %xmm0
movups %xmm0, (%r15,%rcx)
movq %r14, %rdi
ca... | /abel0b[P]shadow/external/imgui/imgui.cpp |
CalcWindowContentSize(ImGuiWindow*) | static ImVec2 CalcWindowContentSize(ImGuiWindow* window)
{
if (window->Collapsed)
if (window->AutoFitFramesX <= 0 && window->AutoFitFramesY <= 0)
return window->ContentSize;
if (window->Hidden && window->HiddenFramesCannotSkipItems == 0 && window->HiddenFramesCanSkipItems > 0)
return... | cmpb $0x1, 0x81(%rdi)
jne 0xd2096
cmpb $0x0, 0x94(%rdi)
jg 0xd2096
cmpb $0x0, 0x95(%rdi)
jle 0xd2102
cmpb $0x1, 0x85(%rdi)
jne 0xd20a8
cmpl $0x0, 0xa0(%rdi)
je 0xd20f9
movss 0x30(%rdi), %xmm1
xorps %xmm0, %xmm0
ucomiss %xmm0, %xmm1
jne 0xd20c7
jp 0xd20c7
movss 0xe8(%rdi), %xmm1
subss 0xe0(%rdi), %xmm1
cvttps2dq %xmm1, ... | /abel0b[P]shadow/external/imgui/imgui.cpp |
CalcWindowSizeAfterConstraint(ImGuiWindow*, ImVec2) | static ImVec2 CalcWindowSizeAfterConstraint(ImGuiWindow* window, ImVec2 new_size)
{
ImGuiContext& g = *GImGui;
if (g.NextWindowData.Flags & ImGuiNextWindowDataFlags_HasSizeConstraint)
{
// Using -1,-1 on either X/Y axis to preserve the current size.
ImRect cr = g.NextWindowData.SizeConstrain... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq 0x13e390(%rip), %r15 # 0x210610
testb $0x10, 0x1ab8(%r15)
je 0xd2354
movss 0x1aec(%r15), %xmm3
movss 0x1af0(%r15), %xmm2
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm3
jb 0xd22d0
movss 0x1af4(%r15), %xmm4
ucomiss %xmm1, %xmm4
jb 0xd22d0
minss %xmm0, %xm... | /abel0b[P]shadow/external/imgui/imgui.cpp |
ImGui::UpdateWindowParentAndRootLinks(ImGuiWindow*, int, ImGuiWindow*) | void ImGui::UpdateWindowParentAndRootLinks(ImGuiWindow* window, ImGuiWindowFlags flags, ImGuiWindow* parent_window)
{
window->ParentWindow = parent_window;
window->RootWindow = window->RootWindowForTitleBarHighlight = window->RootWindowForNav = window;
if (parent_window && (flags & ImGuiWindowFlags_ChildWin... | pushq %rax
movq %rdx, 0x360(%rdi)
movq %rdi, 0x378(%rdi)
movq %rdi, 0x370(%rdi)
movq %rdi, 0x368(%rdi)
testq %rdx, %rdx
sete %al
movl %esi, %ecx
andl $0x3000000, %ecx # imm = 0x3000000
cmpl $0x1000000, %ecx # imm = 0x1000000
setne %cl
orb %al, %cl
jne 0xd24a4
movq 0x368(%rdx), %rax
movq %rax, 0x368(%rdi)
... | /abel0b[P]shadow/external/imgui/imgui.cpp |
ImGui::ErrorCheckBeginEndCompareStacksSize(ImGuiWindow*, bool) | static void ImGui::ErrorCheckBeginEndCompareStacksSize(ImGuiWindow* window, bool write)
{
ImGuiContext& g = *GImGui;
short* p = &window->DC.StackSizesBackup[0];
// Window stacks
// NOT checking: DC.ItemWidth, DC.AllowKeyboardFocus, DC.ButtonRepeat, DC.TextWrapPos (per window) to allow user to convenien... | pushq %rax
movq 0x13e101(%rip), %rax # 0x210610
movl 0xc0(%rdi), %ecx
testl %esi, %esi
je 0xd2568
movw %cx, 0x208(%rdi)
movzwl 0x1f8(%rdi), %ecx
movw %cx, 0x20a(%rdi)
movzwl 0x1b78(%rax), %ecx
movw %cx, 0x20c(%rdi)
movzwl 0x1b38(%rax), %ecx
movw %cx, 0x20e(%rdi)
movzwl 0x1b48(%rax), %ecx
movw %cx, 0x210(%rdi)
movzwl... | /abel0b[P]shadow/external/imgui/imgui.cpp |
ImGui::FindBestWindowPosForPopup(ImGuiWindow*) | ImVec2 ImGui::FindBestWindowPosForPopup(ImGuiWindow* window)
{
ImGuiContext& g = *GImGui;
ImRect r_outer = GetWindowAllowedExtentRect(window);
if (window->Flags & ImGuiWindowFlags_ChildMenu)
{
// Child menus typically request _any_ position within the parent menu item, and then we move the new ... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq 0x13de91(%rip), %r15 # 0x210610
callq 0xd5633
movlhps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movups %xmm0, 0x40(%rsp)
movl 0xc(%rbx), %eax
btl $0x1c, %eax
jb 0xd27fd
btl $0x1a, %eax
jb 0xd2897
btl $0x19, %eax
jae 0xd29b3
movss 0x15fc(%r... | /abel0b[P]shadow/external/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 0x13dc11(%rip), %r14 # 0x210610
movsd 0x54(%rdi), %xmm6
movss 0x64(%rdi), %xmm2
movss 0x67703(%rip), %xmm0 # 0x13a114
ucomiss %xmm2, %xmm0
jbe 0xd2a88
movss 0x6c(%rbx), %xmm1
testb %bpl, %bpl
je 0xd2a32
xorps %xmm3, %xmm3
ucomi... | /abel0b[P]shadow/external/imgui/imgui.cpp |
ImGui::PushMultiItemsWidths(int, float) | void ImGui::PushMultiItemsWidths(int components, float w_full)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
const ImGuiStyle& style = g.Style;
const float w_item_one = ImMax(1.0f, IM_FLOOR((w_full - (style.ItemInnerSpacing.x) * (components-1)) / (float)components));
const flo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x13d78c(%rip), %r15 # 0x210610
movq 0x1a18(%r15), %r12
movss 0x15a8(%r15), %xmm1
leal -0x1(%rdi), %ebp
cvtsi2ss %ebp, %xmm2
movaps %xmm1, %xmm3
mulss %xmm2, %xmm3
movaps %xmm0, %xmm4
subss %xmm3, %xmm4
cvtsi2ss %edi, %xmm3
divss %xmm3... | /abel0b[P]shadow/external/imgui/imgui.cpp |
ImGui::GetContentRegionMaxAbs() | ImVec2 ImGui::GetContentRegionMaxAbs()
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
ImVec2 mx = window->ContentRegionRect.Max;
if (window->DC.CurrentColumns)
mx.x = window->WorkRect.Max.x;
return mx;
} | movq 0x13d5fc(%rip), %rax # 0x210610
movq 0x1a18(%rax), %rax
movsd 0x270(%rax), %xmm0
cmpq $0x0, 0x1a0(%rax)
je 0xd3039
movss 0x250(%rax), %xmm1
movss %xmm1, %xmm0 # xmm0 = xmm1[0],xmm0[1,2,3]
retq
| /abel0b[P]shadow/external/imgui/imgui.cpp |
ImGui::PushItemFlag(int, bool) | void ImGui::PushItemFlag(ImGuiItemFlags option, bool enabled)
{
ImGuiWindow* window = GetCurrentWindow();
if (enabled)
window->DC.ItemFlags |= option;
else
window->DC.ItemFlags &= ~option;
window->DC.ItemFlagsStack.push_back(window->DC.ItemFlags);
} | movl %esi, %eax
movq 0x13d447(%rip), %rcx # 0x210610
movq 0x1a18(%rcx), %rsi
movb $0x1, 0x80(%rsi)
testl %eax, %eax
je 0xd31e3
orl %edi, 0x1b8(%rsi)
jmp 0xd31eb
notl %edi
andl %edi, 0x1b8(%rsi)
leaq 0x1c8(%rsi), %rdi
addq $0x1b8, %rsi # imm = 0x1B8
jmp 0xda130
| /abel0b[P]shadow/external/imgui/imgui.cpp |
ImGui::IsWindowHovered(int) | bool ImGui::IsWindowHovered(ImGuiHoveredFlags flags)
{
IM_ASSERT((flags & ImGuiHoveredFlags_AllowWhenOverlapped) == 0); // Flags not supported by this function
ImGuiContext& g = *GImGui;
if (flags & ImGuiHoveredFlags_AnyWindow)
{
if (g.HoveredWindow == NULL)
return false;
}
... | pushq %r15
pushq %r14
pushq %rbx
movl %edi, %ebx
testb $0x40, %bl
jne 0xd34b4
movq 0x13d236(%rip), %r15 # 0x210610
testb $0x4, %bl
jne 0xd340a
movl %ebx, %eax
andl $0x3, %eax
leaq 0xc4545(%rip), %rcx # 0x197930
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x1a20(%r15), %r14
cmpq 0x1a18(%r15), %r14
... | /abel0b[P]shadow/external/imgui/imgui.cpp |
ImGui::SetNextWindowCollapsed(bool, int) | void ImGui::SetNextWindowCollapsed(bool collapsed, ImGuiCond cond)
{
ImGuiContext& g = *GImGui;
IM_ASSERT(cond == 0 || ImIsPowerOfTwo(cond)); // Make sure the user doesn't attempt to combine multiple condition flags.
g.NextWindowData.Flags |= ImGuiNextWindowDataFlags_HasCollapsed;
g.NextWindowData.Colla... | leal -0x1(%rsi), %eax
testl %eax, %esi
jne 0xd37ca
movq 0x13ce61(%rip), %rax # 0x210610
orl $0x8, 0x1ab8(%rax)
movb %dil, 0x1ae8(%rax)
cmpl $0x1, %esi
adcl $0x0, %esi
movl %esi, 0x1ac4(%rax)
retq
pushq %rax
leaq 0xc5bef(%rip), %rdi # 0x1993c1
leaq 0xc4840(%rip), %rsi # 0x198019
leaq 0xc5d0b(%rip), %rcx #... | /abel0b[P]shadow/external/imgui/imgui.cpp |
ImGui::SetKeyboardFocusHere(int) | void ImGui::SetKeyboardFocusHere(int offset)
{
IM_ASSERT(offset >= -1); // -1 is allowed but not below
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
g.FocusRequestNextWindow = window;
g.FocusRequestNextCounterRegular = window->DC.FocusCounterRegular + 1 + offset;
g.FocusRe... | cmpl $-0x2, %edi
jle 0xd3c09
movq 0x13ca30(%rip), %rax # 0x210610
movq 0x1a18(%rax), %rcx
movq %rcx, 0x1cd0(%rax)
movl 0x1b0(%rcx), %ecx
addl %edi, %ecx
incl %ecx
movl %ecx, 0x1ce0(%rax)
movl $0x7fffffff, 0x1ce4(%rax) # imm = 0x7FFFFFFF
retq
pushq %rax
leaq 0xc590e(%rip), %rdi # 0x19951f
leaq 0xc4401(%rip), %rsi... | /abel0b[P]shadow/external/imgui/imgui.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
imulq $0x14, %rax, %rax
addq %rdi, %rax
movs... | /abel0b[P]shadow/external/imgui/imgui_draw.cpp |
ImDrawListSplitter::Split(ImDrawList*, int) | void ImDrawListSplitter::Split(ImDrawList* draw_list, int channels_count)
{
IM_ASSERT(_Current == 0 && _Count <= 1);
int old_channels_count = _Channels.Size;
if (old_channels_count < channels_count)
_Channels.resize(channels_count);
_Count = channels_count;
// Channels[] (24/32 bytes each) ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
cmpl $0x0, (%rdi)
jne 0xdeca7
movq %rdi, %r12
cmpl $0x2, 0x4(%rdi)
jge 0xdeca7
movl %edx, %ebx
movq %rsi, %rbp
leaq 0x8(%r12), %r15
movl 0x8(%r12), %r13d
cmpl %edx, %r13d
jge 0xdebc0
movq %r15, %rdi
movl %ebx, %esi
callq 0xe7f30
movl %eb... | /abel0b[P]shadow/external/imgui/imgui_draw.cpp |
ImDrawListSplitter::Merge(ImDrawList*) | void ImDrawListSplitter::Merge(ImDrawList* draw_list)
{
// Note that we never use or rely on channels.Size because it is merely a buffer that we never shrink back to 0 to keep all sub-buffers ready for use.
if (_Count <= 1)
return;
SetCurrentChannel(draw_list, 0);
if (draw_list->CmdBuffer.Size ... | cmpl $0x2, 0x4(%rdi)
jl 0xdef2c
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %r14
xorl %ebx, %ebx
xorl %edx, %edx
callq 0xdef2e
cmpl $0x0, (%r15)
je 0xded08
movq %r15, %rdi
callq 0xda03e
cmpl $0x0, (%rax)
jne 0xded08
movq %r15, %rdi
callq 0xdab86
cmpl $0x... | /abel0b[P]shadow/external/imgui/imgui_draw.cpp |
ImDrawListSplitter::SetCurrentChannel(ImDrawList*, int) | void ImDrawListSplitter::SetCurrentChannel(ImDrawList* draw_list, int idx)
{
IM_ASSERT(idx >= 0 && idx < _Count);
if (_Current == idx)
return;
// Overwrite ImVector (12/16 bytes), four times. This is merely a silly optimization instead of doing .swap()
memcpy(&_Channels.Data[_Current]._CmdBuffer... | testl %edx, %edx
js 0xdef91
cmpl %edx, 0x4(%rdi)
jle 0xdef91
movslq (%rdi), %rax
cmpl %edx, %eax
je 0xdef90
movq 0x10(%rdi), %rcx
shlq $0x5, %rax
movups (%rsi), %xmm0
movups %xmm0, (%rcx,%rax)
movq 0x10(%rdi), %rax
movslq (%rdi), %rcx
shlq $0x5, %rcx
movups 0x10(%rsi), %xmm0
movups %xmm0, 0x10(%rax,%rcx)
movl %edx, (%r... | /abel0b[P]shadow/external/imgui/imgui_draw.cpp |
ImDrawData::ScaleClipRects(ImVec2 const&) | void ImDrawData::ScaleClipRects(const ImVec2& fb_scale)
{
for (int i = 0; i < CmdListsCount; i++)
{
ImDrawList* cmd_list = CmdLists[i];
for (int cmd_i = 0; cmd_i < cmd_list->CmdBuffer.Size; cmd_i++)
{
ImDrawCmd* cmd = &cmd_list->CmdBuffer[cmd_i];
cmd->ClipRect = I... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
movslq 0x10(%r14), %rax
cmpq %rax, %r12
jge 0xdf104
movq 0x8(%r14), %rax
movq (%rax,%r12,8), %r15
xorl %ebp, %ebp
cmpl (%r15), %ebp
jge 0xdf0ff
movq %r15, %rdi
movl %ebp, %esi
callq 0xe7f6e
movsd (%rbx), %xmm0
movlh... | /abel0b[P]shadow/external/imgui/imgui_draw.cpp |
ImFontConfig::ImFontConfig() | ImFontConfig::ImFontConfig()
{
FontData = NULL;
FontDataSize = 0;
FontDataOwnedByAtlas = true;
FontNo = 0;
SizePixels = 0.0f;
OversampleH = 3; // FIXME: 2 may be a better default?
OversampleV = 1;
PixelSnapH = false;
GlyphExtraSpacing = ImVec2(0.0f, 0.0f);
GlyphOffset = ImVec2(0.... | andq $0x0, (%rdi)
andl $0x0, 0x8(%rdi)
movb $0x1, 0xc(%rdi)
movaps 0xbd6df(%rip), %xmm0 # 0x19c940
movups %xmm0, 0x10(%rdi)
xorl %eax, %eax
movb %al, 0x20(%rdi)
andq $0x0, 0x38(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x24(%rdi)
movsd 0xbd6d2(%rip), %xmm1 # 0x19c950
movsd %xmm1, 0x40(%rdi)
movb %al, 0x48(%rdi)
mova... | /abel0b[P]shadow/external/imgui/imgui_draw.cpp |
ImFontAtlas::ClearInputData() | void ImFontAtlas::ClearInputData()
{
IM_ASSERT(!Locked && "Cannot modify a locked ImFontAtlas between NewFrame() and EndFrame/Render()!");
for (int i = 0; i < ConfigData.Size; i++)
if (ConfigData[i].FontData && ConfigData[i].FontDataOwnedByAtlas)
{
IM_FREE(ConfigData[i].FontData);... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x0, (%rdi)
jne 0xdf43c
movq %rdi, %rbx
leaq 0x60(%rdi), %r14
xorl %ebp, %ebp
cmpl (%r14), %ebp
jge 0xdf3b0
movq %r14, %rdi
movl %ebp, %esi
callq 0xe807c
cmpq $0x0, (%rax)
je 0xdf3ac
movq %r14, %rdi
movl %ebp, %esi
callq 0xe807c
cmpb $0x1, 0xc(%rax)
jne 0xdf3... | /abel0b[P]shadow/external/imgui/imgui_draw.cpp |
ImFontAtlas::ClearFonts() | void ImFontAtlas::ClearFonts()
{
IM_ASSERT(!Locked && "Cannot modify a locked ImFontAtlas between NewFrame() and EndFrame/Render()!");
for (int i = 0; i < Fonts.Size; i++)
IM_DELETE(Fonts[i]);
Fonts.clear();
} | pushq %rbp
pushq %rbx
pushq %rax
cmpb $0x0, (%rdi)
jne 0xdf4e5
movq %rdi, %rbx
addq $0x40, %rbx
xorl %ebp, %ebp
cmpl (%rbx), %ebp
jge 0xdf4d7
movq %rbx, %rdi
movl %ebp, %esi
callq 0xdaafc
movq (%rax), %rdi
callq 0xe80eb
incl %ebp
jmp 0xdf4bd
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xd9b6a
leaq 0xc2b93(%... | /abel0b[P]shadow/external/imgui/imgui_draw.cpp |
ImFontAtlas::AddFontDefault(ImFontConfig const*) | ImFont* ImFontAtlas::AddFontDefault(const ImFontConfig* font_cfg_template)
{
ImFontConfig font_cfg = font_cfg_template ? *font_cfg_template : ImFontConfig();
if (!font_cfg_template)
{
font_cfg.OversampleH = font_cfg.OversampleV = 1;
font_cfg.PixelSnapH = true;
}
if (font_cfg.SizePixe... | pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0xdf5a9
movq %rsp, %r14
movl $0x88, %edx
movq %r14, %rdi
callq 0x79830
movss 0x14(%r14), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jae 0xdf620
jmp 0xdf630
andq $0x0, (%rsp)
andl $0x0, 0x8(%rsp)
movb $0x1, %al
movb %al, 0xc(%rsp)
andl $0x0, 0... | /abel0b[P]shadow/external/imgui/imgui_draw.cpp |
ImFontAtlas::AddFontFromFileTTF(char const*, float, ImFontConfig const*, unsigned short const*) | ImFont* ImFontAtlas::AddFontFromFileTTF(const char* filename, float size_pixels, const ImFontConfig* font_cfg_template, const ImWchar* glyph_ranges)
{
IM_ASSERT(!Locked && "Cannot modify a locked ImFontAtlas between NewFrame() and EndFrame/Render()!");
size_t data_size = 0;
void* data = ImFileLoadToMemory(f... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movss %xmm0, 0x4(%rsp)
cmpb $0x1, (%rdi)
je 0xdfb6c
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %r14
leaq 0x8(%rsp), %rdx
andq $0x0, (%rdx)
leaq 0x5aeec(%rip), %rsi # 0x13a93c
movq %r12, %rdi
xorl %ecx, %ecx
callq 0xc6... | /abel0b[P]shadow/external/imgui/imgui_draw.cpp |
ImFontAtlas::AddFontFromMemoryCompressedTTF(void const*, int, float, ImFontConfig const*, unsigned short const*) | ImFont* ImFontAtlas::AddFontFromMemoryCompressedTTF(const void* compressed_ttf_data, int compressed_ttf_size, float size_pixels, const ImFontConfig* font_cfg_template, const ImWchar* glyph_ranges)
{
const unsigned int buf_decompressed_size = stb_decompress_length((const unsigned char*)compressed_ttf_data);
unsi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r8, %r14
movq %rcx, %r12
movss %xmm0, 0xc(%rsp)
movq %rsi, %r13
movq %rdi, %r15
movq %rsi, %rdi
callq 0xe00df
movl %eax, %ebp
movl %eax, %edi
callq 0xc649a
movq %rax, %rbx
movl (%r13), %eax
bswapl %eax
cmpl $0x57bc0000, %eax ... | /abel0b[P]shadow/external/imgui/imgui_draw.cpp |
ImFontAtlas::AddCustomRectFontGlyph(ImFont*, unsigned short, int, int, float, ImVec2 const&) | int ImFontAtlas::AddCustomRectFontGlyph(ImFont* font, ImWchar id, int width, int height, float advance_x, const ImVec2& offset)
{
IM_ASSERT(font != NULL);
IM_ASSERT(width > 0 && width <= 0xFFFF);
IM_ASSERT(height > 0 && height <= 0xFFFF);
ImFontAtlasCustomRect r;
r.ID = id;
r.Width = (unsigned s... | pushq %rbx
subq $0x20, %rsp
testq %rsi, %rsi
je 0xe01f8
leal -0x1(%rcx), %eax
cmpl $0xffff, %eax # imm = 0xFFFF
jae 0xe0217
leal -0x1(%r8), %eax
cmpl $0xffff, %eax # imm = 0xFFFF
jae 0xe0236
movq %rdi, %rbx
movq %rsp, %rax
orl $-0x1, 0x8(%rax)
movzwl %dx, %edx
movl %edx, (%rax)
movw %cx, 0x4(%rax)
m... | /abel0b[P]shadow/external/imgui/imgui_draw.cpp |
ImFontAtlas::GetMouseCursorTexData(int, ImVec2*, ImVec2*, ImVec2*, ImVec2*) | bool ImFontAtlas::GetMouseCursorTexData(ImGuiMouseCursor cursor_type, ImVec2* out_offset, ImVec2* out_size, ImVec2 out_uv_border[2], ImVec2 out_uv_fill[2])
{
if (cursor_type <= ImGuiMouseCursor_None || cursor_type >= ImGuiMouseCursor_COUNT)
return false;
if (Flags & ImFontAtlasFlags_NoMouseCursors)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x8, %esi
ja 0xe03d7
movq %rdi, %r14
testb $0x2, 0x4(%rdi)
jne 0xe03d7
movl %esi, %ebp
movl 0x70(%r14), %esi
cmpl $-0x1, %esi
je 0xe03e8
movq %r9, %rbx
movq %r8, %r15
movq %rcx, %r13
movq %rdx, %r12
leaq 0x50(%r14), %rdi
callq 0xe81fc
xo... | /abel0b[P]shadow/external/imgui/imgui_draw.cpp |
ImFontAtlasBuildMultiplyRectAlpha8(unsigned char const*, unsigned char*, int, int, int, int, int) | void ImFontAtlasBuildMultiplyRectAlpha8(const unsigned char table[256], unsigned char* pixels, int x, int y, int w, int h, int stride)
{
unsigned char* data = pixels + x + y * stride;
for (int j = h; j > 0; j--, data += stride)
for (int i = 0; i < w; i++)
data[i] = table[data[i]];
} | movslq 0x8(%rsp), %rax
movslq %edx, %rdx
addq %rsi, %rdx
imull %eax, %ecx
movslq %ecx, %rcx
addq %rdx, %rcx
xorl %edx, %edx
testl %r8d, %r8d
cmovlel %edx, %r8d
testl %r9d, %r9d
jle 0xe307c
xorl %edx, %edx
cmpq %rdx, %r8
je 0xe3074
movzbl (%rcx,%rdx), %esi
movb (%rdi,%rsi), %sil
movb %sil, (%rcx,%rdx)
incq %rdx
jmp 0xe3... | /abel0b[P]shadow/external/imgui/imgui_draw.cpp |
stbtt_FindGlyphIndex(stbtt_fontinfo const*, int) | STBTT_DEF int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codepoint)
{
stbtt_uint8 *data = info->data;
stbtt_uint32 index_map = info->index_map;
stbtt_uint16 format = ttUSHORT(data + index_map + 0);
if (format == 0) { // apple byte encoding
stbtt_int32 bytes = ttUSHORT(data + index_m... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rcx
movl 0x34(%rdi), %eax
leaq (%rcx,%rax), %r12
movzwl (%rcx,%rax), %r8d
rolw $0x8, %r8w
cmpw $0x6, %r8w
ja 0xe3118
movzwl %r8w, %edx
leaq 0xb9917(%rip), %rdi # 0x19ca00
movslq (%rdi,%rdx,4), %rdx
addq %rdi, %rdx
jmpq *%r... | /abel0b[P]shadow/external/imgui/imstb_truetype.h |
Items_SingleStringGetter(void*, int, char const**) | static bool Items_SingleStringGetter(void* data, int idx, const char** out_text)
{
// FIXME-OPT: we could pre-compute the indices to fasten this. But only 1 active combo means the waste is limited.
const char* items_separated_by_zeros = (const char*)data;
int items_count = 0;
const char* p = items_separ... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movb (%r14), %al
subl $0x1, %ebp
setb %cl
testb %al, %al
je 0xed196
testb %cl, %cl
jne 0xed196
movq %r14, %rdi
callq 0x79440
addq %rax, %r14
incq %r14
jmp 0xed175
testq %rbx, %rbx
je 0xed1a2
testb %al, %al
je 0xed1a2
movq %r14, (%rbx)
test... | /abel0b[P]shadow/external/imgui/imgui_widgets.cpp |
ImGui::TreeNodeBehaviorIsOpen(unsigned int, int) | bool ImGui::TreeNodeBehaviorIsOpen(ImGuiID id, ImGuiTreeNodeFlags flags)
{
if (flags & ImGuiTreeNodeFlags_Leaf)
return true;
// We only write to the tree storage if the user clicks (or explicitly use the SetNextItemOpen function)
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movb $0x1, %bpl
btl $0x8, %esi
jb 0xf8123
movl %esi, %ebx
movl %edi, %r14d
leaq 0x11858d(%rip), %rax # 0x210610
movq (%rax), %r12
movq 0x1a18(%r12), %r13
movq 0x198(%r13), %r15
testb $0x2, 0x1b20(%r12)
jne 0xf80b5
movl %ebx, %edx
shrl $0x5,... | /abel0b[P]shadow/external/imgui/imgui_widgets.cpp |
ImGui::TabItemBackground(ImDrawList*, ImRect const&, int, unsigned int) | void ImGui::TabItemBackground(ImDrawList* draw_list, const ImRect& bb, ImGuiTabItemFlags flags, ImU32 col)
{
// While rendering tabs, we trim 1 pixel off the top of our bounding box so they can fit within a regular frame height while looking "detached" from it.
ImGuiContext& g = *GImGui;
const float width =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, 0xc(%rsp)
movss (%rsi), %xmm0
movss 0x8(%rsi), %xmm1
subss %xmm0, %xmm1
xorps %xmm3, %xmm3
ucomiss %xmm3, %xmm1
jbe 0xfbc55
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x114bf5(%rip), %rax # 0x210610
movq (%rax), %rbp
mulss 0x3e6b... | /abel0b[P]shadow/external/imgui/imgui_widgets.cpp |
ImGui::TabItemLabelAndCloseButton(ImDrawList*, ImRect const&, int, ImVec2, char const*, unsigned int, unsigned int) | bool ImGui::TabItemLabelAndCloseButton(ImDrawList* draw_list, const ImRect& bb, ImGuiTabItemFlags flags, ImVec2 frame_padding, const char* label, ImGuiID tab_id, ImGuiID close_button_id)
{
ImGuiContext& g = *GImGui;
ImVec2 label_size = CalcTextSize(label, NULL, true);
if (bb.GetWidth() <= 1.0f)
retu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %r9d, %r15d
movl %r8d, 0xc(%rsp)
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r14
movaps %xmm0, 0x10(%rsp)
movlps %xmm0, 0x48(%rsp)
leaq 0x11496a(%rip), %rax # 0x210610
movq (%rax), %r13
xorl %ebp, %ebp
pushq $0x1
popq %rdx
movss ... | /abel0b[P]shadow/external/imgui/imgui_widgets.cpp |
ImGui::GetColumnWidth(int) | float ImGui::GetColumnWidth(int column_index)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
ImGuiColumns* columns = window->DC.CurrentColumns;
if (columns == NULL)
return GetContentRegionAvail().x;
if (column_index < 0)
column_index = columns->Current;
retu... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0x114565(%rip), %rax # 0x210610
movq (%rax), %rax
movq 0x1a18(%rax), %rax
movq 0x1a0(%rax), %r15
testq %r15, %r15
je 0xfc10a
movl %edi, %ebx
testl %edi, %edi
jns 0xfc0cb
movl 0xc(%r15), %ebx
leaq 0x50(%r15), %r14
leal 0x1(%rbx), %esi
movq %r14, %rdi
callq 0x1022... | /abel0b[P]shadow/external/imgui/imgui_widgets.cpp |
ImGui::SetColumnOffset(int, float) | void ImGui::SetColumnOffset(int column_index, float offset)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
ImGuiColumns* columns = window->DC.CurrentColumns;
IM_ASSERT(columns != NULL);
if (column_index < 0)
column_index = columns->Current;
IM_ASSERT(column_index < ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edi, %ebx
leaq 0x1144e0(%rip), %r12 # 0x210610
movq (%r12), %r13
movq 0x1a18(%r13), %rax
movq 0x1a0(%rax), %rbp
testq %rbp, %rbp
je 0xfc299
testl %ebx, %ebx
jns 0xfc152
movl 0xc(%rbp), %ebx
cmpl 0x50(%rbp), %ebx
jge 0xfc2b8
leaq... | /abel0b[P]shadow/external/imgui/imgui_widgets.cpp |
ImGui::SetColumnWidth(int, float) | void ImGui::SetColumnWidth(int column_index, float width)
{
ImGuiWindow* window = GetCurrentWindowRead();
ImGuiColumns* columns = window->DC.CurrentColumns;
IM_ASSERT(columns != NULL);
if (column_index < 0)
column_index = columns->Current;
SetColumnOffset(column_index + 1, GetColumnOffset(c... | pushq %rbx
subq $0x10, %rsp
leaq 0x11432d(%rip), %rax # 0x210610
movq (%rax), %rax
movq 0x1a18(%rax), %rax
movq 0x1a0(%rax), %rax
testq %rax, %rax
je 0xfc320
movss %xmm0, 0xc(%rsp)
testl %edi, %edi
jns 0xfc306
movl 0xc(%rax), %edi
leal 0x1(%rdi), %ebx
callq 0xfc02a
addss 0xc(%rsp), %xmm0
movl %ebx, %edi
addq $0x10, ... | /abel0b[P]shadow/external/imgui/imgui_widgets.cpp |
ImGui::GetColumnsID(char const*, int) | ImGuiID ImGui::GetColumnsID(const char* str_id, int columns_count)
{
ImGuiWindow* window = GetCurrentWindow();
// Differentiate column ID with an arbitrary prefix for cases where users name their columns set the same as another widget.
// In addition, when an identifier isn't explicitly provided we include... | pushq %r14
pushq %rbx
pushq %rax
leaq 0x1141fc(%rip), %rax # 0x210610
movq (%rax), %rax
movq 0x1a18(%rax), %rbx
movb $0x1, 0x80(%rbx)
movl $0x11223347, %ecx # imm = 0x11223347
leal (%rsi,%rcx), %eax
testq %rdi, %rdi
cmovnel %ecx, %eax
leaq 0xa9cfa(%rip), %r14 # 0x1a6134
cmovneq %rdi, %r14
movl %eax, %edi
c... | /abel0b[P]shadow/external/imgui/imgui_widgets.cpp |
ImGui::BeginColumns(char const*, int, int) | void ImGui::BeginColumns(const char* str_id, int columns_count, ImGuiColumnsFlags flags)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = GetCurrentWindow();
IM_ASSERT(columns_count >= 1 && columns_count <= 64); // Maximum 64 columns
IM_ASSERT(window->DC.CurrentColumns == NULL); // Nested... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %esi, %r15d
leaq 0x114195(%rip), %rax # 0x210610
movq (%rax), %r12
movq 0x1a18(%r12), %rbx
movb $0x1, 0x80(%rbx)
leal -0x1(%r15), %eax
cmpl $0x40, %eax
jae 0xfc7d1
cmpq $0x0, 0x1a0(%rbx)
jne 0xfc7f0
movl %edx, %ebp
movl %r15d, %e... | /abel0b[P]shadow/external/imgui/imgui_widgets.cpp |
ImGui::NextColumn() | bool ImGui::Combo(const char* label, int* current_item, const char* const items[], int items_count, int height_in_items)
{
const bool value_changed = Combo(label, current_item, Items_ArrayGetter, (void*)items, items_count, height_in_items);
return value_changed;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0x113dd2(%rip), %rax # 0x210610
movq (%rax), %r15
movq 0x1a18(%r15), %rbx
movb $0x1, 0x80(%rbx)
cmpb $0x0, 0x83(%rbx)
jne 0xfca12
movq 0x1a0(%rbx), %r14
testq %r14, %r14
je 0xfca12
cmpl $0x1, 0x10(%r14)
jne 0xfc8c1
movss 0x10(%rbx), %xmm0
addss 0x108(%rbx), %xmm... | /abel0b[P]shadow/external/imgui/imgui_widgets.cpp |
ImGui::EndColumns() | void ImGui::EndColumns()
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = GetCurrentWindow();
ImGuiColumns* columns = window->DC.CurrentColumns;
IM_ASSERT(columns != NULL);
PopItemWidth();
if (columns->Count > 1)
{
PopClipRect();
window->DrawList->ChannelsMerge();
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
leaq 0x113bdc(%rip), %rax # 0x210610
movq (%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x1a18(%rax), %r13
movb $0x1, 0x80(%r13)
movq 0x1a0(%r13), %r15
testq %r15, %r15
je 0xfce0d
callq 0xd2f47
cmpl $0x2, 0x10(%r15)
jl 0xfca78
callq 0xd05e2... | /abel0b[P]shadow/external/imgui/imgui_widgets.cpp |
ImStb::STB_TEXTEDIT_DELETECHARS(ImGuiInputTextState*, int, int) | static void STB_TEXTEDIT_DELETECHARS(STB_TEXTEDIT_STRING* obj, int pos, int n)
{
ImWchar* dst = obj->TextW.Data + pos;
// We maintain our buffer length in both UTF-8 and wchar formats
obj->CurLenA -= ImTextCountUtf8BytesFromStr(dst, dst + n);
obj->CurLenW -= n;
// Offset remaining text (FIXME-OPT:... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r14
movslq %esi, %r15
leaq (%r14,%r15,2), %rdi
movslq %edx, %r12
leaq (%rdi,%r12,2), %rsi
callq 0xc6c2f
subl %eax, 0x8(%rbx)
subl %r12d, 0x4(%rbx)
addq %r12, %r12
addq 0x18(%rbx), %r12
addq %r15, %r15
movzwl (%r12,%r15), %eax
testw... | /abel0b[P]shadow/external/imgui/imgui_widgets.cpp |
ImStb::STB_TEXTEDIT_INSERTCHARS(ImGuiInputTextState*, int, unsigned short const*, int) | static bool STB_TEXTEDIT_INSERTCHARS(STB_TEXTEDIT_STRING* obj, int pos, const ImWchar* new_text, int new_text_len)
{
const bool is_resizable = (obj->UserFlags & ImGuiInputTextFlags_CallbackResize) != 0;
const int text_len = obj->CurLenW;
IM_ASSERT(pos <= text_len);
const int new_text_len_utf8 = ImTextC... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl 0x4(%rdi), %ebp
movl %esi, 0x4(%rsp)
cmpl %esi, %ebp
jl 0xfd06f
movl %ecx, %ebx
movq %rdx, %r13
movq %rdi, %r14
movl 0xe78(%rdi), %r15d
movslq %ecx, %r12
leaq (%rdx,%r12,2), %rsi
movq %rdx, %rdi
callq 0xc6c2f
btl $0x12, %r15d
jb 0xf... | /abel0b[P]shadow/external/imgui/imgui_widgets.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.