name string | code string | asm string | file string |
|---|---|---|---|
open_socket_to_openssh_server | libssh2_socket_t open_socket_to_openssh_server(void)
{
return open_socket_to_container(running_container_id);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x403b(%rip), %rbx # 0x72d8
xorl %eax, %eax
movq %rax, (%rsp)
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x4021(%rip) # 0x72d0
je 0x3322
leaq 0x1794(%rip), %rdi # 0x4a4c
callq 0x2200
testq %rax, %rax
je 0x3361
movq %rax, %r14
le... | /libssh2[P]libssh2/tests/openssh_fixture.c |
is_running_inside_a_container | static int is_running_inside_a_container(void)
{
#ifdef _WIN32
return 0;
#else
const char *cgroup_filename = "/proc/self/cgroup";
FILE *f;
char *line = NULL;
size_t len = 0;
int found = 0;
f = fopen(cgroup_filename, "r");
if(!f) {
/* Don't go further, we are not in a container */... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorl %r14d, %r14d
movq %r14, 0x8(%rsp)
movq %r14, 0x10(%rsp)
leaq 0x12bd(%rip), %rdi # 0x4a60
leaq 0x12cd(%rip), %rsi # 0x4a77
callq 0x20d0
testq %rax, %rax
je 0x380b
movq %rax, %rbx
leaq 0x8(%rsp), %r14
leaq 0x10(%rsp), %r15
leaq 0x12aa(%rip), %r12... | /libssh2[P]libssh2/tests/openssh_fixture.c |
nk_strfilter | NK_API int
nk_strfilter(const char *text, const char *regexp)
{
/*
c matches any literal character c
. matches any single character
^ matches the beginning of the input string
$ matches the end of the input string
* matches zero or more occurrences of the previous character*/
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x5e, (%rsi)
jne 0x1ae44
incq %rbx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1ae6e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1ae6e
testl %eax, %eax
jne 0x1ae61
cmpb $0x0, (%r14)
leaq 0x1(%r14), %r14
jne 0x1ae44
xorl %ea... | /Konf[P]LearnOpenGL-CLion/glfw/deps/nuklear.h |
nk_rgba_f | NK_API struct nk_color
nk_rgba_f(float r, float g, float b, float a)
{
struct nk_color ret;
ret.r = (nk_byte)(NK_SATURATE(r) * 255.0f);
ret.g = (nk_byte)(NK_SATURATE(g) * 255.0f);
ret.b = (nk_byte)(NK_SATURATE(b) * 255.0f);
ret.a = (nk_byte)(NK_SATURATE(a) * 255.0f);
return ret;
} | movss 0x40237(%rip), %xmm4 # 0x5b99c
movaps %xmm4, %xmm6
minss %xmm0, %xmm6
movss 0x4022c(%rip), %xmm0 # 0x5b9a0
movaps %xmm6, %xmm5
mulss %xmm0, %xmm5
cvttss2si %xmm5, %ecx
movl $0xff, %esi
andl %esi, %ecx
xorl %edx, %edx
xorps %xmm5, %xmm5
ucomiss %xmm5, %xmm6
cmovbel %edx, %ecx
movaps %xmm4, %xmm6
minss %xmm1,... | /Konf[P]LearnOpenGL-CLion/glfw/deps/nuklear.h |
nk_hsv | NK_API struct nk_color
nk_hsv(int h, int s, int v)
{
return nk_hsva(h, s, v, 255);
} | movl $0xff, %eax
cmpl %eax, %edi
cmovgel %eax, %edi
xorl %ecx, %ecx
testl %edi, %edi
cmovlel %ecx, %edi
cvtsi2ss %edi, %xmm0
cmpl %eax, %esi
cmovgel %eax, %esi
testl %esi, %esi
cmovlel %ecx, %esi
cvtsi2ss %esi, %xmm1
cmpl %eax, %edx
cmovll %edx, %eax
testl %eax, %eax
cmovlel %ecx, %eax
movss 0x400e3(%rip), %xmm3 # 0... | /Konf[P]LearnOpenGL-CLion/glfw/deps/nuklear.h |
nk_subimage_id | NK_API struct nk_image
nk_subimage_id(int id, unsigned short w, unsigned short h, struct nk_rect r)
{
struct nk_image s;
nk_zero(&s, sizeof(s));
s.handle.id = id;
s.w = w; s.h = h;
s.region[0] = (unsigned short)r.x;
s.region[1] = (unsigned short)r.y;
s.region[2] = (unsigned short)r.w;
s.... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
movl $0x18, %esi
callq 0x1bf91
movl %r14d, (%r15)
movw %bp, 0x8(%r15)
movw %bx, 0xa(%r15)
movaps (%rsp), %xmm0
unpcklpd 0x10(%rsp), %xmm0 # xm... | /Konf[P]LearnOpenGL-CLion/glfw/deps/nuklear.h |
nk_image_ptr | NK_API struct nk_image
nk_image_ptr(void *ptr)
{
struct nk_image s;
nk_zero(&s, sizeof(s));
NK_ASSERT(ptr);
s.handle.ptr = ptr;
s.w = 0; s.h = 0;
s.region[0] = 0;
s.region[1] = 0;
s.region[2] = 0;
s.region[3] = 0;
return s;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0x18, %esi
callq 0x1bf91
testq %r14, %r14
je 0x1c1d8
movq %r14, (%rbx)
movq $0x0, 0x8(%rbx)
movl $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x4731c(%rip), %rdi # 0x634fb
leaq 0x3f8aa(%rip), %rsi # 0x5ba90
... | /Konf[P]LearnOpenGL-CLion/glfw/deps/nuklear.h |
nk_utf_decode | NK_API int
nk_utf_decode(const char *c, nk_rune *u, int clen)
{
int i, j, len, type=0;
nk_rune udecoded;
NK_ASSERT(c);
NK_ASSERT(u);
if (!c || !u) return 0;
if (!clen) return 0;
*u = NK_UTF_INVALID;
udecoded = nk_utf_decode_byte(c[0], &len);
if (!NK_BETWEEN(len, 1, NK_UTF_SIZE))
... | pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1c444
testq %rsi, %rsi
je 0x1c463
testl %edx, %edx
je 0x1c42c
movl $0xfffd, (%rsi) # imm = 0xFFFD
movb (%rdi), %r9b
xorl %ebx, %ebx
leaq 0x3f5b4(%rip), %rcx # 0x5b930
leaq 0x3f5b2(%rip), %r8 # 0x5b935
movb (%rbx,%rcx), %r10b
movl %r10d, %eax
andb %... | /Konf[P]LearnOpenGL-CLion/glfw/deps/nuklear.h |
nk_buffer_alloc | NK_INTERN void*
nk_buffer_alloc(struct nk_buffer *b, enum nk_buffer_allocation_type type,
nk_size size, nk_size align)
{
int full;
nk_size alignment;
void *unaligned;
void *memory;
NK_ASSERT(b);
NK_ASSERT(size);
if (!b || !size) return 0;
b->needed += size;
/* calculate total s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1cc97
movq %rdx, %r14
testq %rdx, %rdx
je 0x1ccb6
movq %rcx, %r15
movl %esi, %r8d
movq %rdi, %rbx
addq %r14, 0x60(%rdi)
movq 0x40(%rdi), %rsi
testl %r8d, %r8d
je 0x1ca68
movq 0x70(%rbx), %r13
movq %r13, %r12
subq %r14, %r... | /Konf[P]LearnOpenGL-CLion/glfw/deps/nuklear.h |
nk_buffer_reset | NK_API void
nk_buffer_reset(struct nk_buffer *buffer, enum nk_buffer_allocation_type type)
{
NK_ASSERT(buffer);
if (!buffer) return;
if (type == NK_BUFFER_BACK) {
/* reset back buffer either back to marker or empty */
buffer->needed -= (buffer->memory.size - buffer->marker[type].offset);
... | testq %rdi, %rdi
je 0x1cf21
cmpl $0x1, %esi
jne 0x1cef2
movq 0x18(%rdi), %rcx
movq 0x48(%rdi), %rdx
movq %rcx, %rax
subq %rdx, %rax
addq %rax, 0x60(%rdi)
cmpl $0x0, 0x10(%rdi)
leaq 0x10(%rdi), %rax
cmoveq %rdx, %rcx
movq %rcx, 0x70(%rdi)
jmp 0x1cf1a
movl %esi, %eax
shlq $0x4, %rax
movq 0x8(%rdi,%rax), %rcx
movq %rcx, %... | /Konf[P]LearnOpenGL-CLion/glfw/deps/nuklear.h |
nk_str_init_default | NK_API void
nk_str_init_default(struct nk_str *str)
{
struct nk_allocator alloc;
alloc.userdata.ptr = 0;
alloc.alloc = nk_malloc;
alloc.free = nk_mfree;
nk_buffer_init(&str->buffer, &alloc, 32);
str->len = 0;
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
leaq -0x975(%rip), %rax # 0x1c750
movq %rax, 0x8(%rsi)
leaq -0x978(%rip), %rax # 0x1c758
movq %rax, 0x10(%rsi)
movl $0x20, %edx
callq 0x1c760
movl $0x0, 0x78(%rbx)
addq $0x20, %rsp
popq %rbx
retq
| /Konf[P]LearnOpenGL-CLion/glfw/deps/nuklear.h |
nk_str_insert_at_char | NK_API int
nk_str_insert_at_char(struct nk_str *s, int pos, const char *str, int len)
{
int i;
void *mem;
char *src;
char *dst;
int copylen;
NK_ASSERT(s);
NK_ASSERT(str);
NK_ASSERT(len >= 0);
if (!s || !str || !len || (nk_size)pos > s->buffer.allocated) return 0;
if ((s->buffer.... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x1d501
movq %rdx, %r8
testq %rdx, %rdx
je 0x1d520
movl %ecx, %r12d
testl %ecx, %ecx
js 0x1d53f
xorl %r13d, %r13d
testl %r12d, %r12d
je 0x1d4ef
movl %esi, %ebp
movq %rdi, %rbx
movslq %esi, %r9
movq 0x58(%rdi), %r14
cm... | /Konf[P]LearnOpenGL-CLion/glfw/deps/nuklear.h |
nk_str_at_rune | NK_API char*
nk_str_at_rune(struct nk_str *str, int pos, nk_rune *unicode, int *len)
{
int i = 0;
int src_len = 0;
int glyph_len = 0;
char *text;
int text_len;
NK_ASSERT(str);
NK_ASSERT(unicode);
NK_ASSERT(len);
if (!str || !unicode || !len) return 0;
if (pos < 0) {
*un... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1d72c
movq %rdx, %r15
testq %rdx, %rdx
je 0x1d74b
movq %rcx, %r14
testq %rcx, %rcx
je 0x1d76a
movl %esi, %ebp
testl %esi, %esi
js 0x1d6f5
movq 0x40(%rdi), %rbx
movl 0x58(%rdi), %r12d
movq %rbx, %rdi
movq %r15, %rsi
movl %... | /Konf[P]LearnOpenGL-CLion/glfw/deps/nuklear.h |
nk_push_scissor | NK_API void
nk_push_scissor(struct nk_command_buffer *b, struct nk_rect r)
{
struct nk_command_scissor *cmd;
NK_ASSERT(b);
if (!b) return;
b->clip.x = r.x;
b->clip.y = r.y;
b->clip.w = r.w;
b->clip.h = r.h;
cmd = (struct nk_command_scissor*)
nk_command_buffer_push(b, NK_COMMAND_... | subq $0x28, %rsp
testq %rdi, %rdi
je 0x1e017
movdqa %xmm0, (%rsp)
movdqa %xmm1, 0x10(%rsp)
punpcklqdq %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0]
movdqu %xmm0, 0x8(%rdi)
movl $0x18, %edx
movl $0x1, %esi
callq 0x1e036
testq %rax, %rax
je 0x1e012
cvttps2dq (%rsp), %xmm0
pshuflw $0xe8, %xmm0, %xmm0 # xmm0 = xmm0[0,2,2,3,... | /Konf[P]LearnOpenGL-CLion/glfw/deps/nuklear.h |
nk_command_buffer_push | NK_INTERN void*
nk_command_buffer_push(struct nk_command_buffer* b,
enum nk_command_type t, nk_size size)
{
NK_STORAGE const nk_size align = NK_ALIGNOF(struct nk_command);
struct nk_command *cmd;
nk_size alignment;
void *unaligned;
void *memory;
NK_ASSERT(b);
NK_ASSERT(b->base);
if ... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x1e08f
movq %rdx, %r14
movl %esi, %ebp
movl $0x8, %ecx
xorl %esi, %esi
callq 0x1ca06
testq %rax, %rax
je 0x1e08a
movq (%rbx), %rcx
movq %rax, %rdx
subq 0x40(%rcx), %rdx
movq %rdx, 0x38(%rbx)
leaq (%rax,%r14), %rdx
leaq (%rax,%r14), ... | /Konf[P]LearnOpenGL-CLion/glfw/deps/nuklear.h |
nk_stroke_line | NK_API void
nk_stroke_line(struct nk_command_buffer *b, float x0, float y0,
float x1, float y1, float line_thickness, struct nk_color c)
{
struct nk_command_line *cmd;
NK_ASSERT(b);
if (!b || line_thickness <= 0) return;
cmd = (struct nk_command_line*)
nk_command_buffer_push(b, NK_COMMAND_LI... | pushq %rbx
subq $0x50, %rsp
testq %rdi, %rdi
je 0x1e151
xorps %xmm5, %xmm5
ucomiss %xmm4, %xmm5
jae 0x1e14b
movl %esi, %ebx
movl $0x20, %edx
movl $0x2, %esi
movss %xmm3, 0xc(%rsp)
movaps %xmm4, 0x40(%rsp)
movaps %xmm1, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm2, 0x10(%rsp)
callq 0x1e036
movaps 0x10(%rsp), %xmm4
m... | /Konf[P]LearnOpenGL-CLion/glfw/deps/nuklear.h |
nk_fill_circle | NK_API void
nk_fill_circle(struct nk_command_buffer *b, struct nk_rect r, struct nk_color c)
{
struct nk_command_circle_filled *cmd;
NK_ASSERT(b);
if (!b || c.a == 0 || r.w == 0 || r.h == 0) return;
if (b->use_clipping) {
const struct nk_rect *clip = &b->clip;
if (!NK_INTERSECT(r.x, r.y,... | pushq %rbx
subq $0x20, %rsp
testq %rdi, %rdi
je 0x1e7eb
movl %esi, %ebx
cmpl $0x1000000, %esi # imm = 0x1000000
jb 0x1e7e5
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm1
jne 0x1e734
jnp 0x1e7e5
movaps %xmm1, %xmm4
shufps $0x55, %xmm1, %xmm4 # xmm4 = xmm4[1,1],xmm1[1,1]
ucomiss %xmm2, %xmm4
jne 0x1e746
jnp 0x1e7e5
c... | /Konf[P]LearnOpenGL-CLion/glfw/deps/nuklear.h |
nk_draw_image | NK_API void
nk_draw_image(struct nk_command_buffer *b, struct nk_rect r,
const struct nk_image *img, struct nk_color col)
{
struct nk_command_image *cmd;
NK_ASSERT(b);
if (!b) return;
if (b->use_clipping) {
const struct nk_rect *c = &b->clip;
if (c->w == 0 || c->h == 0 || !NK_INTERSE... | pushq %r14
pushq %rbx
subq $0x28, %rsp
testq %rdi, %rdi
je 0x1ef8f
movl %edx, %ebx
movq %rsi, %r14
cmpl $0x0, 0x18(%rdi)
je 0x1ef2b
movss 0x10(%rdi), %xmm4
xorps %xmm2, %xmm2
ucomiss %xmm2, %xmm4
jne 0x1eed5
jnp 0x1ef87
movss 0x14(%rdi), %xmm5
ucomiss %xmm2, %xmm5
jne 0x1eee5
jnp 0x1ef87
movss 0x8(%rdi), %xmm2
movaps %... | /Konf[P]LearnOpenGL-CLion/glfw/deps/nuklear.h |
nk__draw_list_end | NK_API const struct nk_draw_command*
nk__draw_list_end(const struct nk_draw_list *canvas, const struct nk_buffer *buffer)
{
nk_size size;
nk_size offset;
nk_byte *memory;
const struct nk_draw_command *end;
NK_ASSERT(buffer);
NK_ASSERT(canvas);
if (!buffer || !canvas)
return 0;
... | pushq %rax
testq %rsi, %rsi
je 0x1f8cb
testq %rdi, %rdi
je 0x1f8ea
movq 0x48(%rsi), %rax
subq 0xd8(%rdi), %rax
addq 0x40(%rsi), %rax
movl 0xd0(%rdi), %ecx
decl %ecx
shlq $0x5, %rcx
subq %rcx, %rax
popq %rcx
retq
leaq 0x68082(%rip), %rdi # 0x87954
leaq 0x3c1b7(%rip), %rsi # 0x5ba90
leaq 0x3d3d1(%rip), %rcx #... | /Konf[P]LearnOpenGL-CLion/glfw/deps/nuklear.h |
nk_draw_list_alloc_vertices | NK_INTERN void*
nk_draw_list_alloc_vertices(struct nk_draw_list *list, nk_size count)
{
void *vtx;
NK_ASSERT(list);
if (!list) return 0;
vtx = nk_buffer_alloc(list->vertices, NK_BUFFER_FRONT,
list->config.vertex_size*count, list->config.vertex_alignment);
if (!vtx) return 0;
list->vertex... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0xa8(%rdi), %rcx
movq 0xb8(%rdi), %rdi
movq 0xa0(%r14), %rdx
imulq %rsi, %rdx
xorl %esi, %esi
callq 0x1ca06
testq %rax, %rax
je 0x2059c
addl %ebx, 0xcc(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /Konf[P]LearnOpenGL-CLion/glfw/deps/nuklear.h |
nk_font_chinese_glyph_ranges | NK_API const nk_rune*
nk_font_chinese_glyph_ranges(void)
{
NK_STORAGE const nk_rune ranges[] = {
0x0020, 0x00FF,
0x3000, 0x30FF,
0x31F0, 0x31FF,
0xFF00, 0xFFEF,
0x4e00, 0x9FAF,
0
};
return ranges;
} | leaq 0x35a4d(%rip), %rax # 0x58810
retq
| /Konf[P]LearnOpenGL-CLion/glfw/deps/nuklear.h |
nk_font_atlas_init_custom | NK_API void
nk_font_atlas_init_custom(struct nk_font_atlas *atlas,
struct nk_allocator *permanent, struct nk_allocator *temporary)
{
NK_ASSERT(atlas);
NK_ASSERT(permanent);
NK_ASSERT(temporary);
if (!atlas || !permanent || !temporary) return;
nk_zero_struct(*atlas);
atlas->permanent = *perma... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x231a2
movq %rsi, %r15
testq %rsi, %rsi
je 0x231c1
movq %rdx, %rbx
testq %rdx, %rdx
je 0x231e0
movq %rdi, %r14
movq %rdi, %r12
andq $0x3, %r12
je 0x23168
movl $0x4, %r13d
subq %r12, %r13
movq %r14, %rdi
xorl %esi, %esi
movq %r13, %rdx
callq 0x1... | /Konf[P]LearnOpenGL-CLion/glfw/deps/nuklear.h |
nk_font_atlas_end | NK_API void
nk_font_atlas_end(struct nk_font_atlas *atlas, nk_handle texture,
struct nk_draw_null_texture *null)
{
int i = 0;
struct nk_font *font_iter;
NK_ASSERT(atlas);
if (!atlas) {
if (!null) return;
null->texture = texture;
null->uv = nk_vec2(0.5f,0.5f);
}
if (nu... | pushq %rbx
testq %rdi, %rdi
je 0x273cc
movq %rdi, %rbx
testq %rdx, %rdx
je 0x27324
movq %rsi, (%rdx)
movq 0x40(%rbx), %xmm0
punpcklwd %xmm0, %xmm0 # xmm0 = xmm0[0,0,1,1,2,2,3,3]
psrad $0x10, %xmm0
cvtdq2ps %xmm0, %xmm0
addps 0x30f0b(%rip), %xmm0 # 0x58220
movsd 0x8(%rbx), %xmm1
cvtdq2ps %xmm1, %xmm1
divps %xmm1, ... | /Konf[P]LearnOpenGL-CLion/glfw/deps/nuklear.h |
nk_font_atlas_clear | NK_API void
nk_font_atlas_clear(struct nk_font_atlas *atlas)
{
NK_ASSERT(atlas);
NK_ASSERT(atlas->temporary.alloc);
NK_ASSERT(atlas->temporary.free);
NK_ASSERT(atlas->permanent.alloc);
NK_ASSERT(atlas->permanent.free);
if (!atlas || !atlas->permanent.alloc || !atlas->permanent.free) return;
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x27661
movq %rdi, %rbx
cmpq $0x0, 0x30(%rdi)
je 0x27680
cmpq $0x0, 0x38(%rbx)
je 0x2769f
cmpq $0x0, 0x18(%rbx)
je 0x276be
cmpq $0x0, 0x20(%rbx)
je 0x276dd
movq 0x180(%rbx), %r14
testq %r14, %r14
je 0x275ca
movq 0x48(%r14), %r15
cmpq %r14, %r15
... | /Konf[P]LearnOpenGL-CLion/glfw/deps/nuklear.h |
nk_insert_window | NK_INTERN void
nk_insert_window(struct nk_context *ctx, struct nk_window *win,
enum nk_window_insert_location loc)
{
const struct nk_window *iter;
NK_ASSERT(ctx);
NK_ASSERT(win);
if (!win || !ctx) return;
iter = ctx->begin;
while (iter) {
NK_ASSERT(iter != iter->next);
NK_AS... | pushq %rax
leaq 0x40c0(%rdi), %rax
movq 0x40c0(%rdi), %rcx
movq %rcx, %r8
testq %r8, %r8
je 0x2b9ff
movq 0x1c0(%r8), %r9
cmpq %r9, %r8
je 0x2ba8b
cmpq %rsi, %r8
movq %r9, %r8
jne 0x2b9c3
leaq 0x36d02(%rip), %rdi # 0x626e9
leaq 0x300a2(%rip), %rsi # 0x5ba90
leaq 0x36c95(%rip), %rcx # 0x6268a
movl $0x4849, %e... | /Konf[P]LearnOpenGL-CLion/glfw/deps/nuklear.h |
nk_window_is_collapsed | NK_API int
nk_window_is_collapsed(struct nk_context *ctx, const char *name)
{
int title_len;
nk_hash title_hash;
struct nk_window *win;
NK_ASSERT(ctx);
if (!ctx) return 0;
title_len = (int)nk_strlen(name);
title_hash = nk_murmur_hash(name, (int)title_len, NK_WINDOW_TITLE);
win = nk_find... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x2da78
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x1ab54
movq %rbx, %rdi
movl %eax, %esi
movl $0x40, %edx
callq 0x1b1ab
movq %r14, %rdi
movl %eax, %esi
movq %rbx, %rdx
callq 0x2b92c
testq %rax, %rax
je 0x2da6e
movq %rax, %rcx
movl $0x8000, %eax ... | /Konf[P]LearnOpenGL-CLion/glfw/deps/nuklear.h |
nk_layout_ratio_from_pixel | NK_API float
nk_layout_ratio_from_pixel(struct nk_context *ctx, float pixel_width)
{
struct nk_window *win;
NK_ASSERT(ctx);
NK_ASSERT(pixel_width);
if (!ctx || !ctx->current || !ctx->current->layout) return 0;
win = ctx->current;
return NK_CLAMP(0.0f, pixel_width/win->bounds.x, 1.0f);
} | pushq %rax
testq %rdi, %rdi
je 0x2e1ef
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x2e19e
jnp 0x2e20e
movq 0x40d8(%rdi), %rax
testq %rax, %rax
je 0x2e1ea
cmpq $0x0, 0xa8(%rax)
je 0x2e1ea
divss 0x4c(%rax), %xmm0
movss 0x2d7db(%rip), %xmm1 # 0x5b99c
ucomiss %xmm0, %xmm1
setbe %al
xorps %xmm2, %xmm2
ucomiss %xmm0, %xm... | /Konf[P]LearnOpenGL-CLion/glfw/deps/nuklear.h |
nk_do_button_text | NK_INTERN int
nk_do_button_text(nk_flags *state,
struct nk_command_buffer *out, struct nk_rect bounds,
const char *string, int len, nk_flags align, enum nk_button_behavior behavior,
const struct nk_style_button *style, const struct nk_input *in,
const struct nk_user_font *font)
{
struct nk_rect cont... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movaps %xmm0, %xmm2
movlhps %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0]
movups %xmm2, 0x28(%rsp)
testq %rdi, %rdi
je 0x32513
movq 0x70(%rsp), %r12
testq %r12, %r12
je 0x32532
movq %rsi, %rbx
testq %rsi, %rsi
je 0x32551
testq %rdx, %... | /Konf[P]LearnOpenGL-CLion/glfw/deps/nuklear.h |
nk_checkbox_flags_text | NK_API int
nk_checkbox_flags_text(struct nk_context *ctx, const char *text, int len,
unsigned int *flags, unsigned int value)
{
int active;
NK_ASSERT(ctx);
NK_ASSERT(text);
NK_ASSERT(flags);
if (!ctx || !text || !flags) return 0;
active = (int)((*flags & value) & value);
if (nk_checkbox... | pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x345ec
testq %rsi, %rsi
je 0x3460b
movq %rcx, %r14
testq %rcx, %rcx
je 0x3462a
movl %r8d, %ebx
movl (%r14), %ebp
andl %r8d, %ebp
movl %ebp, %ecx
callq 0x33d36
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %ebp
je 0x345e7
testl %ecx, %ecx
je 0x345da
orl (%r14), %ebx
jmp... | /Konf[P]LearnOpenGL-CLion/glfw/deps/nuklear.h |
nk_menu_begin_text | NK_API int
nk_menu_begin_text(struct nk_context *ctx, const char *title, int len,
nk_flags align, struct nk_vec2 size)
{
struct nk_window *win;
const struct nk_input *in;
struct nk_rect header;
int is_clicked = nk_false;
nk_flags state;
NK_ASSERT(ctx);
NK_ASSERT(ctx->current);
NK_AS... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
testq %rdi, %rdi
je 0x3dd17
movq %rdi, %r14
movq 0x40d8(%rdi), %r15
testq %r15, %r15
je 0x3dd36
movaps %xmm0, 0x10(%rsp)
cmpq $0x0, 0xa8(%r15)
je 0x3dd55
movl %ecx, %ebp
movl %edx, %r12d
movq %rsi, %rbx
movq %rsp, %rdi
movq %r14, %rsi
callq 0x300a1... | /Konf[P]LearnOpenGL-CLion/glfw/deps/nuklear.h |
nk_menu_begin_symbol_text | NK_API int
nk_menu_begin_symbol_text(struct nk_context *ctx, const char *title, int len,
nk_flags align, enum nk_symbol_type sym, struct nk_vec2 size)
{
struct nk_window *win;
struct nk_rect header;
const struct nk_input *in;
int is_clicked = nk_false;
nk_flags state;
NK_ASSERT(ctx);
NK... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rdi, %rdi
je 0x3e3b0
movq %rdi, %r14
movq 0x40d8(%rdi), %r15
testq %r15, %r15
je 0x3e3cf
movaps %xmm0, 0x10(%rsp)
cmpq $0x0, 0xa8(%r15)
je 0x3e3ee
movl %r8d, %r13d
movl %ecx, %ebp
movl %edx, %r12d
movq %rsi, %rbx
movq %rsp, %rdi
m... | /Konf[P]LearnOpenGL-CLion/glfw/deps/nuklear.h |
nk_textedit_createundo | NK_INTERN nk_rune*
nk_textedit_createundo(struct nk_text_undo_state *state, int pos,
int insert_len, int delete_len)
{
struct nk_text_undo_record *r = nk_textedit_create_undo_record(state, insert_len);
if (r == 0)
return 0;
r->where = pos;
r->insert_length = (short) insert_len;
r->delet... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
movw $0x63, 0x1442(%rdi)
movw $0x3e7, 0x1446(%rdi) # imm = 0x3E7
cmpw $0x63, 0x1440(%rdi)
jne 0x41b4f
movq %rbx, %rdi
callq 0x41bf9
cmpl $0x3e7, %r14d # imm = 0x3E7
jle 0x41b6d
xorl %eax... | /Konf[P]LearnOpenGL-CLion/glfw/deps/nuklear.h |
nk_draw_scrollbar | NK_INTERN void
nk_draw_scrollbar(struct nk_command_buffer *out, nk_flags state,
const struct nk_style_scrollbar *style, const struct nk_rect *bounds,
const struct nk_rect *scroll)
{
const struct nk_style_item *background;
const struct nk_style_item *cursor;
/* select correct colors/images to draw *... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r13
movl %esi, %eax
addl %eax, %eax
andl $0x20, %eax
leaq 0x68(%rax), %rcx
testb $0x20, %sil
movl $0xa8, %r12d
cmoveq %rcx, %r12
movq %rdx, %r15
movl $0x40, %ecx
cmovel %eax, %ecx
movq %rdi, %r14
leaq (%rdx,%rcx), %r... | /Konf[P]LearnOpenGL-CLion/glfw/deps/nuklear.h |
nk_textedit_layout_row | NK_INTERN void
nk_textedit_layout_row(struct nk_text_edit_row *r, struct nk_text_edit *edit,
int line_start_id, float row_height, const struct nk_user_font *font)
{
int l;
int glyphs = 0;
nk_rune unicode;
const char *remaining;
int len = nk_str_len_char(&edit->string);
const char *end = nk_s... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movss %xmm0, 0x8(%rsp)
movq %rdi, %rbx
movl $0x0, 0xc(%rsp)
xorl %r13d, %r13d
cmpl $0x0, 0x90(%rsi)
je 0x44479
movq 0x70(%rsi), %rax
testq %rax, %rax
je 0x44479
movq 0x58(%rsi), %r15
cltq
jmp 0x4447e
xorl %eax, %eax
xorl %r15d, %r15... | /Konf[P]LearnOpenGL-CLion/glfw/deps/nuklear.h |
nk_textedit_find_charpos | NK_INTERN void
nk_textedit_find_charpos(struct nk_text_find *find, struct nk_text_edit *state,
int n, int single_line, const struct nk_user_font *font, float row_height)
{
/* find the x/y location of a character, and remember info about the previous
* row in case we get a move-up event (for page up, we'll ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movl 0x90(%rsi), %eax
xorps %xmm1, %xmm1
movaps %xmm1, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
cmpl %edx, %eax
movss %xmm0, 0x8(%rsp)
jne 0x445da
movl %ecx, %r12d
leaq 0x10(%rsp), %... | /Konf[P]LearnOpenGL-CLion/glfw/deps/nuklear.h |
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
testl %edx, %edx
je 0x47c64
movl 0x2c(%rdi), %ecx
movl %edx, %edx
movl $0xffffffff, %r8d # imm = 0xFFFFFFFF
movq $0x0, -0x10(%rsp)
movl $0xffffffff, %r11d # imm = 0xFFFFFFFF
movl $0xffffffff, %ebx # imm = 0xFFFFFFFF
movl %ecx, -0x4(%rsp)... | /Konf[P]LearnOpenGL-CLion/glfw/src/context.c |
glfwExtensionSupported | GLFWAPI int glfwExtensionSupported(const char* extension)
{
_GLFWwindow* window;
assert(extension != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
window = _glfwPlatformGetTls(&_glfw.contextSlot);
if (!window)
{
_glfwInputError(GLFW_NO_CURRENT_CONTEXT,
"Canno... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x481e6
leaq 0x53f40(%rip), %rax # 0x9c008
cmpl $0x0, (%rax)
je 0x48157
movq %rdi, %rbx
movl $0x1fe14, %edi # imm = 0x1FE14
addq 0x4cf08(%rip), %rdi # 0x94fe8
callq 0x54c21
testq %rax, %rax
je 0x48163
cmpb $0x0, (%rbx)
je 0x4817... | /Konf[P]LearnOpenGL-CLion/glfw/src/context.c |
glfwSwapBuffers | GLFWAPI void glfwSwapBuffers(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT();
if (window->context.client == GLFW_NO_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT,
"Cannot swap buffers of a window that h... | testq %rdi, %rdi
je 0x482e1
leaq 0x53d57(%rip), %rax # 0x9c008
cmpl $0x0, (%rax)
je 0x482c5
cmpl $0x0, 0x1f0(%rdi)
je 0x482ce
jmpq *0x240(%rdi)
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
jmp 0x482da
leaq 0x1ef39(%rip), %rsi # 0x6720e
movl $0x1000a, %edi # imm = 0x1000A
xorl %eax, %eax... | /Konf[P]LearnOpenGL-CLion/glfw/src/context.c |
glfwInit | GLFWAPI int glfwInit(void)
{
if (_glfw.initialized)
return GLFW_TRUE;
memset(&_glfw, 0, sizeof(_glfw));
_glfw.hints.init = _glfwInitHints;
if (!_glfwPlatformInit())
{
terminate();
return GLFW_FALSE;
}
if (!_glfwPlatformCreateMutex(&_glfw.errorLock) ||
!_glf... | pushq %r14
pushq %rbx
pushq %rax
leaq 0x53a7f(%rip), %r14 # 0x9c008
cmpl $0x0, (%r14)
je 0x48599
movl $0x1, %ebx
jmp 0x48670
xorl %ebx, %ebx
movl $0x20978, %edx # imm = 0x20978
movq %r14, %rdi
xorl %esi, %esi
callq 0x1a0d0
movq 0x4dc37(%rip), %rax # 0x961e8
movq %rax, 0x8(%r14)
movl 0x4dc35(%rip), %eax... | /Konf[P]LearnOpenGL-CLion/glfw/src/init.c |
glfwJoystickPresent | GLFWAPI int glfwJoystickPresent(int jid)
{
_GLFWjoystick* js;
assert(jid >= GLFW_JOYSTICK_1);
assert(jid <= GLFW_JOYSTICK_LAST);
_GLFW_REQUIRE_INIT_OR_RETURN(GLFW_FALSE);
if (jid < 0 || jid > GLFW_JOYSTICK_LAST)
{
_glfwInputError(GLFW_INVALID_ENUM, "Invalid joystick ID %i", jid);
... | pushq %rax
testl %edi, %edi
js 0x4976e
cmpl $0x10, %edi
jae 0x4978d
leaq 0x528d7(%rip), %rax # 0x9c008
cmpl $0x0, (%rax)
je 0x4975c
movl %edi, %ecx
imulq $0x1fa0, %rcx, %rcx # imm = 0x1FA0
cmpl $0x0, 0x400(%rax,%rcx)
je 0x4976a
leaq (%rax,%rcx), %rdi
addq $0x400, %rdi # imm = 0x400
xorl %esi, %esi
po... | /Konf[P]LearnOpenGL-CLion/glfw/src/input.c |
glfwGetJoystickAxes | GLFWAPI const float* glfwGetJoystickAxes(int jid, int* count)
{
_GLFWjoystick* js;
assert(jid >= GLFW_JOYSTICK_1);
assert(jid <= GLFW_JOYSTICK_LAST);
assert(count != NULL);
*count = 0;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (jid < 0 || jid > GLFW_JOYSTICK_LAST)
{
_glfwInputEr... | pushq %r14
pushq %rbx
pushq %rax
testl %edi, %edi
js 0x49839
cmpl $0x10, %edi
jae 0x49858
movq %rsi, %rbx
testq %rsi, %rsi
je 0x49877
movl $0x0, (%rbx)
leaq 0x5282e(%rip), %rax # 0x9c008
cmpl $0x0, (%rax)
je 0x4981e
movl %edi, %ecx
imulq $0x1fa0, %rcx, %rcx # imm = 0x1FA0
cmpl $0x0, 0x400(%rax,%rcx)
je 0x4981a
... | /Konf[P]LearnOpenGL-CLion/glfw/src/input.c |
glfwSetTime | GLFWAPI void glfwSetTime(double time)
{
_GLFW_REQUIRE_INIT();
if (time != time || time < 0.0 || time > 18446744073.0)
{
_glfwInputError(GLFW_INVALID_VALUE, "Invalid time %f", time);
return;
}
_glfw.timer.offset = _glfwPlatformGetTimerValue() -
(uint64_t) (time * _glfwPlatfo... | pushq %r14
pushq %rbx
pushq %rax
leaq 0x51527(%rip), %r14 # 0x9c008
cmpl $0x0, (%r14)
je 0x4ab6c
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x4ab81
ucomisd 0x37d1f(%rip), %xmm0 # 0x82820
ja 0x4ab81
movsd %xmm0, (%rsp)
callq 0x54b45
movq %rax, %rbx
callq 0x54b91
movq %rax, %xmm0
punpckldq 0x37cce(%rip), %xmm0 # x... | /Konf[P]LearnOpenGL-CLion/glfw/src/input.c |
glfwCreateWindowSurface | GLFWAPI VkResult glfwCreateWindowSurface(VkInstance instance,
GLFWwindow* handle,
const VkAllocationCallbacks* allocator,
VkSurfaceKHR* surface)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x4bdf5
movq %rsi, %r15
testq %rsi, %rsi
je 0x4be14
movq %rcx, %rbx
testq %rcx, %rcx
je 0x4be33
movq $0x0, (%rbx)
leaq 0x502ad(%rip), %r13 # 0x9c008
cmpl $0x0, (%r13)
je 0x4bda4
movq %rdx, %r14
movq %rdi, %r12
movl $0x2, %edi
callq 0x4b7c8
t... | /Konf[P]LearnOpenGL-CLion/glfw/src/vulkan.c |
glfwGetWindowSize | GLFWAPI void glfwGetWindowSize(GLFWwindow* handle, int* width, int* height)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
if (width)
*width = 0;
if (height)
*height = 0;
_GLFW_REQUIRE_INIT();
_glfwPlatformGetWindowSize(window, width, height);
} | testq %rdi, %rdi
je 0x4c821
testq %rsi, %rsi
je 0x4c7f7
movl $0x0, (%rsi)
testq %rdx, %rdx
je 0x4c802
movl $0x0, (%rdx)
leaq 0x4f7ff(%rip), %rax # 0x9c008
cmpl $0x0, (%rax)
je 0x4c813
jmp 0x51c05
movl $0x10001, %edi # imm = 0x10001
xorl %esi, %esi
xorl %eax, %eax
jmp 0x483e3
pushq %rax
leaq 0x1a955(%rip), ... | /Konf[P]LearnOpenGL-CLion/glfw/src/window.c |
glfwPlatformGetWindowPos | void _glfwPlatformGetWindowPos(_GLFWwindow* window, int* xpos, int* ypos)
{
Window dummy;
int x, y;
XTranslateCoordinates(_glfw.x11.display, window->x11.handle, _glfw.x11.root,
0, 0, &x, &y, &dummy);
if (xpos)
*xpos = x;
if (ypos)
*ypos = y;
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x4a55e(%rip), %rax # 0x9c008
movq 0x340(%rdi), %rsi
movq 0x1feb8(%rax), %rdi
movq 0x1fec8(%rax), %rdx
leaq 0x10(%rsp), %rax
leaq 0x8(%rsp), %r10
leaq 0xc(%rsp), %r9
xorl %ecx, %ecx
xorl %r8d, %r8d
pushq %rax
pushq %r10
callq 0x1a2e0
addq $... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
glfwPlatformPostEmptyEvent | void _glfwPlatformPostEmptyEvent(void)
{
XEvent event;
memset(&event, 0, sizeof(event));
event.type = ClientMessage;
event.xclient.window = _glfw.x11.helperWindowHandle;
event.xclient.format = 32; // Data is 32-bit longs
event.xclient.message_type = _glfw.x11.NULL_;
XSendEvent(_glfw.x11.di... | pushq %r14
pushq %rbx
subq $0xc8, %rsp
leaq 0x8(%rsp), %rbx
movl $0xc0, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1a0d0
movl $0x21, (%rbx)
leaq 0x4827e(%rip), %r14 # 0x9c008
movq 0x1feb8(%r14), %rdi
movq 0x1fed8(%r14), %rsi
movq %rsi, 0x20(%rbx)
movl $0x20, 0x30(%rbx)
movq 0x20530(%r14), %rax
movq %rax, 0x28(%rb... | /Konf[P]LearnOpenGL-CLion/glfw/src/x11_window.c |
extensionSupportedGLX | static int extensionSupportedGLX(const char* extension)
{
const char* extensions =
glXQueryExtensionsString(_glfw.x11.display, _glfw.x11.screen);
if (extensions)
{
if (_glfwStringInExtensionString(extension, extensions))
return GLFW_TRUE;
}
return GLFW_FALSE;
} | pushq %rbx
movq %rdi, %rbx
leaq 0x46da4(%rip), %rax # 0x9c008
movq 0x1feb8(%rax), %rdi
movl 0x1fec0(%rax), %esi
callq *0x207b0(%rax)
testq %rax, %rax
je 0x55292
movq %rbx, %rdi
movq %rax, %rsi
callq 0x48205
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x55294
xorl %eax, %eax
popq %rbx
retq
| /Konf[P]LearnOpenGL-CLion/glfw/src/glx_context.c |
glfwCreateContextOSMesa | GLFWbool _glfwCreateContextOSMesa(_GLFWwindow* window,
const _GLFWctxconfig* ctxconfig,
const _GLFWfbconfig* fbconfig)
{
OSMesaContext share = NULL;
const int accumBits = fbconfig->accumRedBits +
fbconfig->accumGreenBi... | pushq %rbx
subq $0xa0, %rsp
cmpl $0x30002, (%rsi) # imm = 0x30002
jne 0x56f38
leaq 0x30845(%rip), %rsi # 0x87771
xorl %ebx, %ebx
movl $0x10006, %edi # imm = 0x10006
jmp 0x570da
movq %rdi, %rbx
movl 0x1c(%rdx), %ecx
addl 0x18(%rdx), %ecx
addl 0x20(%rdx), %ecx
movq 0x28(%rsi), %rax
testq %rax, %rax
je... | /Konf[P]LearnOpenGL-CLion/glfw/src/osmesa_context.c |
glfwPlatformPollJoystick | int _glfwPlatformPollJoystick(_GLFWjoystick* js, int mode)
{
// Read all queued events (non-blocking)
for (;;)
{
struct input_event e;
errno = 0;
if (read(js->linjs.fd, &e, sizeof(e)) < 0)
{
// Reset the joystick slot if the device was disconnected
if... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0x1a5f0
movq %rax, %r14
movl $0x0, (%rax)
movl 0x78(%rbx), %edi
leaq 0x8(%rsp), %rsi
movl $0x18, %edx
callq 0x1a230
testq %rax, %rax
js 0x57cd0
leaq 0x443e4(%rip), %r12 # 0x9c008
leaq 0x8(%rsp), %r15
movzwl 0x18(%rsp), %eb... | /Konf[P]LearnOpenGL-CLion/glfw/src/linux_joystick.c |
lowercase | static char* lowercase(const char* string)
{
char *new_string;
char *p;
size_t stringSize;
stringSize = CM_CAST(size_t, strlen(string) + 1);
new_string = CM_CAST(char*, malloc(sizeof(char) * stringSize));
if (new_string == CM_NULL) { /* NOLINT */
return CM_NULL; /* NOLINT */
}
strcpy(ne... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2080
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
shlq $0x0, %rdi
callq 0x20f0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x279f
movq $0x0, -0x8(%rbp)
jmp 0x27ea
movq -0x18(%rbp), %rdi
movq -0x10(%r... | /micst[P]CMake/build_O0/Source/kwsys/cmsysTestsC.c |
cmsysMD5_Append | void kwsysMD5_Append(kwsysMD5* md5, unsigned char const* data, int length)
{
size_t dlen;
if (length < 0) {
dlen = strlen((char const*)data);
} else {
dlen = (size_t)length;
}
md5_append(&md5->md5_state, (md5_byte_t const*)data, dlen);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x2ac8
movq -0x10(%rbp), %rdi
callq 0x2080
movq %rax, -0x20(%rbp)
jmp 0x2ad0
movslq -0x14(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(... | /micst[P]CMake/Source/kwsys/MD5.c |
md5_finish | static void md5_finish(md5_state_t* pms, md5_byte_t digest[16])
{
static const md5_byte_t pad[64] = { 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
cmpl $0x8, -0x1c(%rbp)
jge 0x2cdd
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
sarl $0x2, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl -0x1c(%rbp), %ecx
andl $0x3, %ecx
shll $0x3, %ecx
shrl %cl, %eax
... | /micst[P]CMake/Source/kwsys/MD5.c |
phmap::priv::hash_internal::GetSharedRng() | std::mt19937_64* GetSharedRng() {
RandomDeviceSeedSeq seed_seq;
static auto* rng = new std::mt19937_64(seed_seq);
return rng;
} | pushq %rbp
movq %rsp, %rbp
subq $0x13b0, %rsp # imm = 0x13B0
leaq -0x1388(%rbp), %rdi
callq 0x34d20
cmpb $0x0, 0x36dc4a(%rip) # 0x3a2888
jne 0x34c93
leaq 0x36dc41(%rip), %rdi # 0x3a2888
callq 0x30f20
cmpl $0x0, %eax
je 0x34c93
movl $0x9c8, %edi # imm = 0x9C8
callq 0x30740
movq %rax, -0x13a0(%... | /greg7mdp[P]parallel-hashmap/tests/hash_generator_testing.h |
phmap::priv::parallel_hash_set<4ul, phmap::priv::raw_hash_set, phmap::NullMutex, phmap::priv::FlatHashMapPolicy<phmap::priv::(anonymous namespace)::ParallelFlatHashMap_StandardLayout_Test::TestBody()::Int, phmap::priv::(anonymous namespace)::ParallelFlatHashMap_StandardLayout_Test::TestBody()::Int>, phmap::priv::(anony... | size_t bucket_count() const {
size_t sz = 0;
for (const auto& inner : sets_)
{
SharedLock m(const_cast<Inner&>(inner));
sz += inner.set_.bucket_count();
}
return sz;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, -0x10(%rbp)
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x392a0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x392c0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x35994
movq -0x2... | /greg7mdp[P]parallel-hashmap/parallel_hashmap/phmap.h |
void phmap::priv::Deallocate<8ul, std::allocator<std::pair<phmap::priv::(anonymous namespace)::ParallelFlatHashMap_StandardLayout_Test::TestBody()::Int const, phmap::priv::(anonymous namespace)::ParallelFlatHashMap_StandardLayout_Test::TestBody()::Int>>>(std::allocator<std::pair<phmap::priv::(anonymous namespace)::Para... | void Deallocate(Alloc* alloc, void* p, size_t n) {
static_assert(Alignment > 0, "");
assert(n && "n must be positive");
struct alignas(Alignment) M {};
using A = typename phmap::allocator_traits<Alloc>::template rebind_alloc<M>;
using AT = typename phmap::allocator_traits<Alloc>::template rebind_traits<M>;
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x2d(%rbp)
je 0x360f7
movb $0x1, %al
movb %al, -0x2d(%rbp)
jmp 0x360f7
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x36100
jmp 0x36102
jmp 0x36121
leaq 0x248b3a... | /greg7mdp[P]parallel-hashmap/parallel_hashmap/phmap_base.h |
std::tuple<phmap::priv::parallel_hash_set<4ul, phmap::priv::raw_hash_set, phmap::NullMutex, phmap::priv::FlatHashMapPolicy<phmap::priv::(anonymous namespace)::ParallelFlatHashMap_StandardLayout_Test::TestBody()::Int, phmap::priv::(anonymous namespace)::ParallelFlatHashMap_StandardLayout_Test::TestBody()::Int>, phmap::p... | std::tuple<Inner*, size_t, bool>
find_or_prepare_insert_with_hash(size_t hashval, const K& key, UniqueLock &mutexlock) {
Inner& inner = sets_[subidx(hashval)];
auto& set = inner.set_;
mutexlock = std::move(UniqueLock(inner));
size_t offset = set._find_key(key, hashval);
... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rdi
callq 0x36a40
movq -0x70(%rbp), ... | /greg7mdp[P]parallel-hashmap/parallel_hashmap/phmap.h |
phmap::priv::raw_hash_set<phmap::priv::FlatHashMapPolicy<phmap::priv::(anonymous namespace)::ParallelFlatHashMap_StandardLayout_Test::TestBody()::Int, phmap::priv::(anonymous namespace)::ParallelFlatHashMap_StandardLayout_Test::TestBody()::Int>, phmap::priv::(anonymous namespace)::ParallelFlatHashMap_StandardLayout_Tes... | void set_ctrl(size_t i, ctrl_t h) {
assert(i < capacity_);
if (IsFull(h)) {
SanitizerUnpoisonObject(slots_ + i);
} else {
SanitizerPoisonObject(slots_ + i);
}
ctrl_[i] = h;
ctrl_[((i - Group::kWidth) & capacity_) + 1 +
((Group::kWid... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq 0x18(%rcx), %rax
jae 0x36889
jmp 0x368a8
leaq 0x249007(%rip), %rdi # 0x27f897
leaq 0x2481f8(%rip), %rsi # 0x27ea8f
m... | /greg7mdp[P]parallel-hashmap/parallel_hashmap/phmap.h |
phmap::priv::raw_hash_set<phmap::priv::FlatHashMapPolicy<phmap::priv::(anonymous namespace)::ParallelFlatHashMap_StandardLayout_Test::TestBody()::Int, phmap::priv::(anonymous namespace)::ParallelFlatHashMap_StandardLayout_Test::TestBody()::Int>, phmap::priv::(anonymous namespace)::ParallelFlatHashMap_StandardLayout_Tes... | FindInfo find_first_non_full(size_t hashval) {
auto seq = probe(hashval);
while (true) {
Group g{ctrl_ + seq.offset()};
auto mask = g.MatchEmptyOrDeleted();
if (mask) {
return {seq.offset((size_t)mask.LowestBitSet()), seq.getindex()};
}
... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rsi
movq %rsi, -0x60(%rbp)
movq -0x20(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0x36d60
movq -0x60(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x68(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x51a00
movq -0x68(%rbp), %rsi
... | /greg7mdp[P]parallel-hashmap/parallel_hashmap/phmap.h |
phmap::priv::raw_hash_set<phmap::priv::FlatHashMapPolicy<phmap::priv::(anonymous namespace)::ParallelFlatHashMap_StandardLayout_Test::TestBody()::Int, phmap::priv::(anonymous namespace)::ParallelFlatHashMap_StandardLayout_Test::TestBody()::Int>, phmap::priv::(anonymous namespace)::ParallelFlatHashMap_StandardLayout_Tes... | void resize(size_t new_capacity) {
assert(IsValidCapacity(new_capacity));
auto* old_ctrl = ctrl_;
auto* old_slots = slots_;
const size_t old_capacity = capacity_;
initialize_slots(new_capacity);
capacity_ = new_capacity;
for (size_t i = 0; i != old_capacity; ++i)... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rdi
callq 0x51920
testb $0x1, %al
jne 0x3743a
jmp 0x3743c
jmp 0x3745b
leaq 0x247aee(%rip), %rdi # 0x27ef31
leaq 0x247645(%rip), %rsi # 0x27ea8f
movl $0x807, %edx... | /greg7mdp[P]parallel-hashmap/parallel_hashmap/phmap.h |
void* phmap::priv::Allocate<8ul, std::allocator<std::pair<phmap::priv::(anonymous namespace)::ParallelFlatHashMap_StandardLayout_Test::TestBody()::Int const, phmap::priv::(anonymous namespace)::ParallelFlatHashMap_StandardLayout_Test::TestBody()::Int>>>(std::allocator<std::pair<phmap::priv::(anonymous namespace)::Paral... | void* Allocate(Alloc* alloc, size_t n) {
static_assert(Alignment > 0, "");
assert(n && "n must be positive");
struct alignas(Alignment) M {};
using A = typename phmap::allocator_traits<Alloc>::template rebind_alloc<M>;
using AT = typename phmap::allocator_traits<Alloc>::template rebind_traits<M>;
A mem_allo... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x2d(%rbp)
je 0x37af3
movb $0x1, %al
movb %al, -0x2d(%rbp)
jmp 0x37af3
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x37afc
jmp 0x37afe
jmp 0x37b1d
leaq 0x24713e(%rip), %rdi # 0x27e... | /greg7mdp[P]parallel-hashmap/parallel_hashmap/phmap_base.h |
void phmap::priv::Deallocate<4ul, std::allocator<std::pair<int const, phmap::priv::(anonymous namespace)::balast>>>(std::allocator<std::pair<int const, phmap::priv::(anonymous namespace)::balast>>*, void*, unsigned long) | void Deallocate(Alloc* alloc, void* p, size_t n) {
static_assert(Alignment > 0, "");
assert(n && "n must be positive");
struct alignas(Alignment) M {};
using A = typename phmap::allocator_traits<Alloc>::template rebind_alloc<M>;
using AT = typename phmap::allocator_traits<Alloc>::template rebind_traits<M>;
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x2d(%rbp)
je 0x3a597
movb $0x1, %al
movb %al, -0x2d(%rbp)
jmp 0x3a597
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x3a5a0
jmp 0x3a5a2
jmp 0x3a5c1
leaq 0x24469a... | /greg7mdp[P]parallel-hashmap/parallel_hashmap/phmap_base.h |
testing::internal::PairMatcherImpl<std::pair<int const, phmap::priv::(anonymous namespace)::balast> const&>::ExplainSuccess(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&, testing::MatchResultLi... | void ExplainSuccess(const std::string& first_explanation,
const std::string& second_explanation,
MatchResultListener* listener) const {
*listener << "whose both fields match";
if (!first_explanation.empty()) {
*listener << ", where the first field is a value " <... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x242e80(%rip), %rsi # 0x2810e3
callq 0x53a40
movq -0x10(%rbp), %rdi
callq 0x30df0
testb $0x1, %al
jne 0x3e291
movq -0x20(%rbp), %rdi
leaq 0x242e7b(%rip),... | /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googlemock/include/gmock/gmock-matchers.h |
phmap::priv::raw_hash_set<phmap::priv::FlatHashMapPolicy<int, phmap::priv::(anonymous namespace)::balast>, phmap::Hash<int>, phmap::EqualTo<int>, std::allocator<std::pair<int const, phmap::priv::(anonymous namespace)::balast>>>::raw_hash_set(phmap::priv::raw_hash_set<phmap::priv::FlatHashMapPolicy<int, phmap::priv::(an... | raw_hash_set(raw_hash_set&& that, const allocator_type& a)
: ctrl_(EmptyGroup<std_alloc_t>()),
slots_(nullptr),
size_(0),
capacity_(0),
settings_(0, that.hash_ref(), that.eq_ref(), a) {
if (a == that.alloc_ref()) {
std::swap(ctrl_, that.ctrl_);
... | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
callq 0x3a120
movq %rax, %rcx
movq -0x98(%rbp), %rax
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
addq $0x28, %rax
movq %rax,... | /greg7mdp[P]parallel-hashmap/parallel_hashmap/phmap.h |
phmap::priv::raw_hash_set<phmap::priv::FlatHashMapPolicy<int, phmap::priv::(anonymous namespace)::balast>, phmap::Hash<int>, phmap::EqualTo<int>, std::allocator<std::pair<int const, phmap::priv::(anonymous namespace)::balast>>>::raw_hash_set(phmap::priv::raw_hash_set<phmap::priv::FlatHashMapPolicy<int, phmap::priv::(an... | raw_hash_set(raw_hash_set&& that) noexcept(
std::is_nothrow_copy_constructible<hasher>::value&&
std::is_nothrow_copy_constructible<key_equal>::value&&
std::is_nothrow_copy_constructible<allocator_type>::value)
: ctrl_(phmap::exchange(that.ctrl_, EmptyGroup<std_alloc_t>())),
slots... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x3a120
movq -0x40(%rbp), %rdi
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rsi
callq 0x54ab0
movq %rax, -0x38(%rb... | /greg7mdp[P]parallel-hashmap/parallel_hashmap/phmap.h |
testing::internal::TypeParameterizedTestSuite<phmap::priv::ModifiersTest, testing::internal::Templates<phmap::priv::gtest_suite_ModifiersTest_::Clear, phmap::priv::gtest_suite_ModifiersTest_::Insert, phmap::priv::gtest_suite_ModifiersTest_::InsertHint, phmap::priv::gtest_suite_ModifiersTest_::InsertRange, phmap::priv::... | static bool Register(const char* prefix, CodeLocation code_location,
const TypedTestSuitePState* state, const char* case_name,
const char* test_names,
const std::vector<std::string>& type_names =
GenerateNames<DefaultNameGen... | pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
movq %rsi, -0x108(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2351b0
movq -0x28(%rbp), %rsi
leaq -0x70(%rbp), %rdi
movq %r... | /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/include/gtest/internal/gtest-internal.h |
testing::AssertionResult::~AssertionResult() | class GTEST_API_ AssertionResult {
public:
// Copy constructor.
// Used in EXPECT_TRUE/FALSE(assertion_result).
AssertionResult(const AssertionResult& other);
// C4800 is a level 3 warning in Visual Studio 2015 and earlier.
// This warning is not emitted in Visual Studio 2017.
// This warning is off by default ... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x541e0
addq $0x10, %rsp
popq %rbp
retq
nop
| /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/include/gtest/gtest-assertion-result.h |
std::pair<phmap::priv::parallel_hash_set<4ul, phmap::priv::raw_hash_set, phmap::NullMutex, phmap::priv::FlatHashMapPolicy<int, int>, phmap::Hash<int>, phmap::EqualTo<int>, std::allocator<std::pair<int const, int>>>::iterator, bool> phmap::priv::parallel_hash_map<4ul, phmap::priv::raw_hash_set, phmap::NullMutex, phmap::... | std::pair<iterator, bool> insert_or_assign_impl(K&& k, V&& v) {
size_t hashval = this->hash(k);
UniqueLock m;
auto res = this->find_or_prepare_insert_with_hash(hashval, k, m);
typename Base::Inner *inner = std::get<0>(res);
if (std::get<2>(res)) {
inner->set_.emplace_... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xb0(%rbp)
movq %rdi, -0xa8(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
movq -0x10(%rbp), %rsi
callq 0x60730
movq %rax, -0x20(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x519b0
movq -0xa0(%rbp), %r... | /greg7mdp[P]parallel-hashmap/parallel_hashmap/phmap.h |
testing::internal::UnorderedElementsAreMatcherImpl<std::vector<std::pair<phmap::priv::hash_internal::Enum, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<phmap::priv::hash_internal::Enum, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<c... | UnorderedElementsAreMatcherImpl(UnorderedMatcherRequire::Flags matcher_flags,
InputIter first, InputIter last)
: UnorderedElementsAreMatcherImplBase(matcher_flags) {
for (; first != last; ++first) {
matchers_.push_back(MatcherCast<const Element&>(*first));
}
for... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdx, -0x8(%rbp)
movq %rcx, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xdb460
movq -0x80(%rbp), %rdi
addq $0x8, %rdi
movl -0x1c(%rbp), %esi
callq 0x5c5c0
movq -0x80(%rbp), %rdi
leaq 0x2bbbde(%rip), %rax ... | /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googlemock/include/gmock/gmock-matchers.h |
testing::internal::MatcherCastImpl<std::pair<int, phmap::priv::NonStandardLayout> const&, std::pair<int const, phmap::priv::NonStandardLayout>>::Cast(std::pair<int const, phmap::priv::NonStandardLayout> const&) | static Matcher<T> Cast(const M& polymorphic_matcher_or_value) {
// M can be a polymorphic matcher, in which case we want to use
// its conversion operator to create Matcher<T>. Or it can be a value
// that should be passed to the Matcher<T>'s constructor.
//
// We can't call Matcher<T>(polymorphic_... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
callq 0xef7c0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googlemock/include/gmock/gmock-matchers.h |
phmap::priv::operator==(phmap::priv::raw_hash_set<phmap::priv::FlatHashMapPolicy<int, phmap::priv::NonStandardLayout>, phmap::priv::StatefulTestingHash, phmap::priv::StatefulTestingEqual, phmap::priv::Alloc<std::pair<int const, phmap::priv::NonStandardLayout>>> const&, phmap::priv::raw_hash_set<phmap::priv::FlatHashMap... | bool operator==(const raw_hash_set& a, const raw_hash_set& b) {
if (a.size() != b.size()) return false;
const raw_hash_set* outer = &a;
const raw_hash_set* inner = &b;
if (outer->capacity() > inner->capacity())
std::swap(outer, inner);
for (const value_type& elem : *... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x86e90
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
callq 0x86e90
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
je 0x117a6b
movb $0x0, -0x1(%rbp)
jmp 0x117b1c
movq -0x10(%rbp), %rax
movq %ra... | /greg7mdp[P]parallel-hashmap/parallel_hashmap/phmap.h |
testing::internal::SuiteApiResolver<phmap::priv::gtest_suite_ConstructorTest_::CopyConstructor<phmap::parallel_flat_hash_map<phmap::priv::NonStandardLayout, int, phmap::priv::StatefulTestingHash, phmap::priv::StatefulTestingEqual, phmap::priv::Alloc<std::pair<phmap::priv::NonStandardLayout const, int>>, 4ul, phmap::Nul... | static SetUpTearDownSuiteFuncType GetSetUpCaseOrSuite(const char* filename,
int line_num) {
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
SetUpTearDownSuiteFuncType test_case_fp =
GetNotDefaultOrNull(&T::SetUpTestCase, &Test::SetUpTestCase);
SetUpTearD... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0xa7aa6(%rip), %rsi # 0x704a0
movq %rsi, %rdi
callq 0x70470
movq %rax, -0x18(%rbp)
leaq -0xa7aa9(%rip), %rsi # 0x704b0
movq %rsi, %rdi
callq 0x70470
movq %rax, -0x20(%rbp)
movb $0x1, %al
cmpq $0x0, -0x18(%rbp)
movb %al, ... | /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/include/gtest/internal/gtest-internal.h |
testing::internal::SuiteApiResolver<phmap::priv::gtest_suite_ConstructorTest_::CopyConstructor<phmap::parallel_flat_hash_map<phmap::priv::NonStandardLayout, int, phmap::priv::StatefulTestingHash, phmap::priv::StatefulTestingEqual, phmap::priv::Alloc<std::pair<phmap::priv::NonStandardLayout const, int>>, 4ul, phmap::Nul... | static SetUpTearDownSuiteFuncType GetTearDownCaseOrSuite(const char* filename,
int line_num) {
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
SetUpTearDownSuiteFuncType test_case_fp =
GetNotDefaultOrNull(&T::TearDownTestCase, &Test::TearDownTestCase);
... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0xa7bc6(%rip), %rsi # 0x704c0
movq %rsi, %rdi
callq 0x70470
movq %rax, -0x18(%rbp)
leaq -0xa7bc9(%rip), %rsi # 0x704d0
movq %rsi, %rdi
callq 0x70470
movq %rax, -0x20(%rbp)
movb $0x1, %al
cmpq $0x0, -0x18(%rbp)
movb %al, ... | /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/include/gtest/internal/gtest-internal.h |
phmap::priv::gtest_suite_ConstructorTest_::CopyConstructor<phmap::parallel_flat_hash_map<phmap::priv::NonStandardLayout, int, phmap::priv::StatefulTestingHash, phmap::priv::StatefulTestingEqual, phmap::priv::Alloc<std::pair<phmap::priv::NonStandardLayout const, int>>, 4ul, phmap::NullMutex>>::~CopyConstructor() | TYPED_TEST_P(ConstructorTest, CopyConstructor) {
using T = hash_internal::GeneratedType<TypeParam>;
using H = typename TypeParam::hasher;
using E = typename TypeParam::key_equal;
using A = typename TypeParam::allocator_type;
H hasher;
E equal;
A alloc(0);
TypeParam m(123, hasher, equal, alloc);
for (s... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x118310
movq -0x10(%rbp), %rdi
movl $0x10, %esi
callq 0x30770
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| /greg7mdp[P]parallel-hashmap/tests/unordered_map_constructor_test.h |
std::pair<phmap::priv::parallel_hash_set<4ul, phmap::priv::raw_hash_set, phmap::NullMutex, phmap::priv::FlatHashMapPolicy<phmap::priv::NonStandardLayout, int>, phmap::priv::StatefulTestingHash, phmap::priv::StatefulTestingEqual, phmap::priv::Alloc<std::pair<phmap::priv::NonStandardLayout const, int>>>::iterator, bool> ... | std::pair<iterator, bool> emplace_decomposable_with_hash(const K& key, size_t hashval, Args&&... args)
{
Inner& inner = sets_[subidx(hashval)];
auto& set = inner.set_;
UniqueLock m(inner);
size_t offset = set._find_key(key, hashval);
if (offset == (size_t)-1) ... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xc0(%rbp)
movq %rdi, -0xb8(%rbp)
movq 0x10(%rbp), %rax
movq %rsi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq -0x18(%rbp), %rdi
callq 0xf5100
movq -0xb0(%rb... | /greg7mdp[P]parallel-hashmap/parallel_hashmap/phmap.h |
void phmap::priv::map_slot_policy<phmap::priv::NonStandardLayout, int>::construct<phmap::priv::Alloc<std::pair<phmap::priv::NonStandardLayout const, int>>, std::piecewise_construct_t const&, std::tuple<phmap::priv::NonStandardLayout const&&>, std::tuple<int&&>>(phmap::priv::Alloc<std::pair<phmap::priv::NonStandardLayou... | static void construct(Allocator* alloc, slot_type* slot, Args&&... args) {
emplace(slot);
if (kMutableKeys::value) {
phmap::allocator_traits<Allocator>::construct(*alloc, &slot->mutable_value,
std::forward<Args>(args)...);
} el... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0xf6200
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x11911... | /greg7mdp[P]parallel-hashmap/parallel_hashmap/phmap_base.h |
phmap::priv::raw_hash_set<phmap::priv::FlatHashMapPolicy<phmap::priv::NonStandardLayout, int>, phmap::priv::StatefulTestingHash, phmap::priv::StatefulTestingEqual, phmap::priv::Alloc<std::pair<phmap::priv::NonStandardLayout const, int>>>::raw_hash_set(phmap::priv::raw_hash_set<phmap::priv::FlatHashMapPolicy<phmap::priv... | raw_hash_set(const raw_hash_set& that, const allocator_type& a)
: raw_hash_set(0, that.hash_ref(), that.eq_ref(), a) {
rehash(that.capacity()); // operator=() should preserve load_factor
// Because the table is guaranteed to be empty, we can do something faster
// than a full `insert`.... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa08a0
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rdi
callq 0xa75e0
movq -0x88(%rbp), %rdx
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movq... | /greg7mdp[P]parallel-hashmap/parallel_hashmap/phmap.h |
void phmap::priv::raw_hash_set<phmap::priv::FlatHashMapPolicy<phmap::priv::NonStandardLayout, int>, phmap::priv::StatefulTestingHash, phmap::priv::StatefulTestingEqual, phmap::priv::Alloc<std::pair<phmap::priv::NonStandardLayout const, int>>>::emplace_at<std::pair<phmap::priv::NonStandardLayout const, int> const&>(unsi... | void emplace_at(size_t i, Args&&... args) {
PolicyTraits::construct(&alloc_ref(), slots_ + i,
std::forward<Args>(args)...);
#ifdef PHMAP_CHECK_CONSTRUCTED_VALUE
// this check can be costly, so do it only when requested
assert(PolicyTraits::apply(FindEleme... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x8bef0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
imulq $0x30, -0x10(%rbp), %rax
addq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x119c70
addq... | /greg7mdp[P]parallel-hashmap/parallel_hashmap/phmap.h |
phmap::priv::gtest_suite_ConstructorTest_::MoveAssignment<phmap::parallel_flat_hash_map<phmap::priv::hash_internal::EnumClass, int, phmap::priv::StatefulTestingHash, phmap::priv::StatefulTestingEqual, phmap::priv::Alloc<std::pair<phmap::priv::hash_internal::EnumClass const, int>>, 4ul, phmap::NullMutex>>::~MoveAssignme... | TYPED_TEST_P(ConstructorTest, MoveAssignment) {
using T = hash_internal::GeneratedType<TypeParam>;
using H = typename TypeParam::hasher;
using E = typename TypeParam::key_equal;
using A = typename TypeParam::allocator_type;
H hasher;
E equal;
A alloc(0);
hash_internal::Generator<T> gen;
TypeParam m({g... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x802f0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /greg7mdp[P]parallel-hashmap/tests/unordered_map_constructor_test.h |
testing::internal::SuiteApiResolver<phmap::priv::gtest_suite_ConstructorTest_::AssignmentFromInitializerList<phmap::parallel_flat_hash_map<int, phmap::priv::NonStandardLayout, phmap::priv::StatefulTestingHash, phmap::priv::StatefulTestingEqual, phmap::priv::Alloc<std::pair<int const, phmap::priv::NonStandardLayout>>, 4... | static SetUpTearDownSuiteFuncType GetSetUpCaseOrSuite(const char* filename,
int line_num) {
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
SetUpTearDownSuiteFuncType test_case_fp =
GetNotDefaultOrNull(&T::SetUpTestCase, &Test::SetUpTestCase);
SetUpTearD... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0xe8c16(%rip), %rsi # 0x704a0
movq %rsi, %rdi
callq 0x70470
movq %rax, -0x18(%rbp)
leaq -0xe8c19(%rip), %rsi # 0x704b0
movq %rsi, %rdi
callq 0x70470
movq %rax, -0x20(%rbp)
movb $0x1, %al
cmpq $0x0, -0x18(%rbp)
movb %al, ... | /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/include/gtest/internal/gtest-internal.h |
testing::internal::SuiteApiResolver<phmap::priv::gtest_suite_ConstructorTest_::AssignmentFromInitializerList<phmap::parallel_flat_hash_map<int, phmap::priv::NonStandardLayout, phmap::priv::StatefulTestingHash, phmap::priv::StatefulTestingEqual, phmap::priv::Alloc<std::pair<int const, phmap::priv::NonStandardLayout>>, 4... | static SetUpTearDownSuiteFuncType GetTearDownCaseOrSuite(const char* filename,
int line_num) {
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
SetUpTearDownSuiteFuncType test_case_fp =
GetNotDefaultOrNull(&T::TearDownTestCase, &Test::TearDownTestCase);
... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0xe8d36(%rip), %rsi # 0x704c0
movq %rsi, %rdi
callq 0x70470
movq %rax, -0x18(%rbp)
leaq -0xe8d39(%rip), %rsi # 0x704d0
movq %rsi, %rdi
callq 0x70470
movq %rax, -0x20(%rbp)
movb $0x1, %al
cmpq $0x0, -0x18(%rbp)
movb %al, ... | /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/include/gtest/internal/gtest-internal.h |
testing::internal::TypeParameterizedTest<phmap::priv::ConstructorTest, testing::internal::TemplateSel<phmap::priv::gtest_suite_ConstructorTest_::AssignmentFromInitializerList>, testing::internal::Types<phmap::parallel_flat_hash_map<phmap::priv::NonStandardLayout, int, phmap::priv::StatefulTestingHash, phmap::priv::Stat... | static bool Register(const char* prefix, CodeLocation code_location,
const char* case_name, const char* test_names, int index,
const std::vector<std::string>& type_names =
GenerateNames<DefaultNameGenerator, Types>()) {
typedef typename Types:... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rsi, -0x1b0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1a8(%rbp)
leaq -0xd1(%rbp), %rdi
movq %rdi, -0x1a0(%rb... | /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/include/gtest/internal/gtest-internal.h |
phmap::priv::gtest_suite_ConstructorTest_::AssignmentFromInitializerList<phmap::parallel_flat_hash_map<int, phmap::priv::NonStandardLayout, phmap::priv::StatefulTestingHash, phmap::priv::StatefulTestingEqual, phmap::priv::Alloc<std::pair<int const, phmap::priv::NonStandardLayout>>, 4ul, phmap::NullMutex>>::AssignmentFr... | TYPED_TEST_P(ConstructorTest, AssignmentFromInitializerList) {
using T = hash_internal::GeneratedType<TypeParam>;
hash_internal::Generator<T> gen;
std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
TypeParam m;
m = values;
EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x85920
movq -0x10(%rbp), %rax
leaq 0x240b34(%rip), %rcx # 0x39a408
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /greg7mdp[P]parallel-hashmap/tests/unordered_map_constructor_test.h |
phmap::priv::gtest_suite_ConstructorTest_::AssignmentFromInitializerList<phmap::parallel_flat_hash_map<int, phmap::priv::NonStandardLayout, phmap::priv::StatefulTestingHash, phmap::priv::StatefulTestingEqual, phmap::priv::Alloc<std::pair<int const, phmap::priv::NonStandardLayout>>, 4ul, phmap::NullMutex>>::~AssignmentF... | TYPED_TEST_P(ConstructorTest, AssignmentFromInitializerList) {
using T = hash_internal::GeneratedType<TypeParam>;
hash_internal::Generator<T> gen;
std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
TypeParam m;
m = values;
EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x85cd0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /greg7mdp[P]parallel-hashmap/tests/unordered_map_constructor_test.h |
phmap::priv::gtest_suite_ConstructorTest_::AssignmentFromInitializerList<phmap::parallel_flat_hash_map<int, phmap::priv::NonStandardLayout, phmap::priv::StatefulTestingHash, phmap::priv::StatefulTestingEqual, phmap::priv::Alloc<std::pair<int const, phmap::priv::NonStandardLayout>>, 4ul, phmap::NullMutex>>::~AssignmentF... | TYPED_TEST_P(ConstructorTest, AssignmentFromInitializerList) {
using T = hash_internal::GeneratedType<TypeParam>;
hash_internal::Generator<T> gen;
std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
TypeParam m;
m = values;
EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x1598f0
movq -0x10(%rbp), %rdi
movl $0x10, %esi
callq 0x30770
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| /greg7mdp[P]parallel-hashmap/tests/unordered_map_constructor_test.h |
phmap::priv::gtest_suite_ConstructorTest_::AssignmentFromInitializerList<phmap::parallel_flat_hash_map<int, phmap::priv::NonStandardLayout, phmap::priv::StatefulTestingHash, phmap::priv::StatefulTestingEqual, phmap::priv::Alloc<std::pair<int const, phmap::priv::NonStandardLayout>>, 4ul, phmap::NullMutex>>::TestBody() | TYPED_TEST_P(ConstructorTest, AssignmentFromInitializerList) {
using T = hash_internal::GeneratedType<TypeParam>;
hash_internal::Generator<T> gen;
std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
TypeParam m;
m = values;
EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values... | pushq %rbp
movq %rsp, %rbp
subq $0xb40, %rsp # imm = 0xB40
movq %rdi, -0x8(%rbp)
leaq -0x110(%rbp), %rdi
movq %rdi, -0x118(%rbp)
leaq -0x9(%rbp), %rsi
callq 0xea960
jmp 0x159968
leaq -0xe0(%rbp), %rdi
movq %rdi, -0x118(%rbp)
leaq -0x9(%rbp), %rsi
callq 0xea960
jmp 0x159981
leaq -0xb0(%rbp), %rdi
movq %rdi, -... | /greg7mdp[P]parallel-hashmap/tests/unordered_map_constructor_test.h |
testing::internal::SuiteApiResolver<phmap::priv::gtest_suite_ConstructorTest_::AssignmentFromInitializerList<phmap::parallel_flat_hash_map<phmap::priv::NonStandardLayout, int, phmap::priv::StatefulTestingHash, phmap::priv::StatefulTestingEqual, phmap::priv::Alloc<std::pair<phmap::priv::NonStandardLayout const, int>>, 4... | static SetUpTearDownSuiteFuncType GetSetUpCaseOrSuite(const char* filename,
int line_num) {
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
SetUpTearDownSuiteFuncType test_case_fp =
GetNotDefaultOrNull(&T::SetUpTestCase, &Test::SetUpTestCase);
SetUpTearD... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0xe99b6(%rip), %rsi # 0x704a0
movq %rsi, %rdi
callq 0x70470
movq %rax, -0x18(%rbp)
leaq -0xe99b9(%rip), %rsi # 0x704b0
movq %rsi, %rdi
callq 0x70470
movq %rax, -0x20(%rbp)
movb $0x1, %al
cmpq $0x0, -0x18(%rbp)
movb %al, ... | /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/include/gtest/internal/gtest-internal.h |
testing::internal::SuiteApiResolver<phmap::priv::gtest_suite_ConstructorTest_::AssignmentFromInitializerList<phmap::parallel_flat_hash_map<phmap::priv::NonStandardLayout, int, phmap::priv::StatefulTestingHash, phmap::priv::StatefulTestingEqual, phmap::priv::Alloc<std::pair<phmap::priv::NonStandardLayout const, int>>, 4... | static SetUpTearDownSuiteFuncType GetTearDownCaseOrSuite(const char* filename,
int line_num) {
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
SetUpTearDownSuiteFuncType test_case_fp =
GetNotDefaultOrNull(&T::TearDownTestCase, &Test::TearDownTestCase);
... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0xe9ad6(%rip), %rsi # 0x704c0
movq %rsi, %rdi
callq 0x70470
movq %rax, -0x18(%rbp)
leaq -0xe9ad9(%rip), %rsi # 0x704d0
movq %rsi, %rdi
callq 0x70470
movq %rax, -0x20(%rbp)
movb $0x1, %al
cmpq $0x0, -0x18(%rbp)
movb %al, ... | /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/include/gtest/internal/gtest-internal.h |
phmap::priv::gtest_suite_ConstructorTest_::AssignmentFromInitializerList<phmap::parallel_flat_hash_map<phmap::priv::NonStandardLayout, int, phmap::priv::StatefulTestingHash, phmap::priv::StatefulTestingEqual, phmap::priv::Alloc<std::pair<phmap::priv::NonStandardLayout const, int>>, 4ul, phmap::NullMutex>>::AssignmentFr... | TYPED_TEST_P(ConstructorTest, AssignmentFromInitializerList) {
using T = hash_internal::GeneratedType<TypeParam>;
hash_internal::Generator<T> gen;
std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
TypeParam m;
m = values;
EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x8b0c0
movq -0x10(%rbp), %rax
leaq 0x24029c(%rip), %rcx # 0x39a4a0
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /greg7mdp[P]parallel-hashmap/tests/unordered_map_constructor_test.h |
phmap::priv::gtest_suite_ConstructorTest_::AssignmentFromInitializerList<phmap::parallel_flat_hash_map<phmap::priv::NonStandardLayout, int, phmap::priv::StatefulTestingHash, phmap::priv::StatefulTestingEqual, phmap::priv::Alloc<std::pair<phmap::priv::NonStandardLayout const, int>>, 4ul, phmap::NullMutex>>::~AssignmentF... | TYPED_TEST_P(ConstructorTest, AssignmentFromInitializerList) {
using T = hash_internal::GeneratedType<TypeParam>;
hash_internal::Generator<T> gen;
std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
TypeParam m;
m = values;
EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x15a220
movq -0x10(%rbp), %rdi
movl $0x10, %esi
callq 0x30770
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| /greg7mdp[P]parallel-hashmap/tests/unordered_map_constructor_test.h |
phmap::priv::gtest_suite_ConstructorTest_::AssignmentFromInitializerList<phmap::parallel_flat_hash_map<phmap::priv::NonStandardLayout, int, phmap::priv::StatefulTestingHash, phmap::priv::StatefulTestingEqual, phmap::priv::Alloc<std::pair<phmap::priv::NonStandardLayout const, int>>, 4ul, phmap::NullMutex>>::TestBody() | TYPED_TEST_P(ConstructorTest, AssignmentFromInitializerList) {
using T = hash_internal::GeneratedType<TypeParam>;
hash_internal::Generator<T> gen;
std::initializer_list<T> values = {gen(), gen(), gen(), gen(), gen()};
TypeParam m;
m = values;
EXPECT_THAT(items(m), ::testing::UnorderedElementsAreArray(values... | pushq %rbp
movq %rsp, %rbp
subq $0xb40, %rsp # imm = 0xB40
movq %rdi, -0x8(%rbp)
leaq -0x110(%rbp), %rdi
movq %rdi, -0x118(%rbp)
leaq -0x9(%rbp), %rsi
callq 0xf3e50
jmp 0x15a298
leaq -0xe0(%rbp), %rdi
movq %rdi, -0x118(%rbp)
leaq -0x9(%rbp), %rsi
callq 0xf3e50
jmp 0x15a2b1
leaq -0xb0(%rbp), %rdi
movq %rdi, -... | /greg7mdp[P]parallel-hashmap/tests/unordered_map_constructor_test.h |
testing::internal::TypeParameterizedTest<phmap::priv::ConstructorTest, testing::internal::TemplateSel<phmap::priv::gtest_suite_ConstructorTest_::AssignmentOverwritesExisting>, testing::internal::Types<phmap::parallel_flat_hash_map<int, int, phmap::priv::StatefulTestingHash, phmap::priv::StatefulTestingEqual, phmap::pri... | static bool Register(const char* prefix, CodeLocation code_location,
const char* case_name, const char* test_names, int index,
const std::vector<std::string>& type_names =
GenerateNames<DefaultNameGenerator, Types>()) {
typedef typename Types:... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rsi, -0x1b0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1a8(%rbp)
leaq -0xd1(%rbp), %rdi
movq %rdi, -0x1a0(%rb... | /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/include/gtest/internal/gtest-internal.h |
testing::internal::TypeParameterizedTestSuite<phmap::priv::ConstructorTest, testing::internal::Templates<phmap::priv::gtest_suite_ConstructorTest_::MoveAssignmentOverwritesExisting, phmap::priv::gtest_suite_ConstructorTest_::AssignmentFromInitializerListOverwritesExisting, phmap::priv::gtest_suite_ConstructorTest_::Ass... | static bool Register(const char* prefix, CodeLocation code_location,
const TypedTestSuitePState* state, const char* case_name,
const char* test_names,
const std::vector<std::string>& type_names =
GenerateNames<DefaultNameGen... | pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
movq %rsi, -0x108(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2351b0
movq -0x28(%rbp), %rsi
leaq -0x70(%rbp), %rdi
movq %r... | /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/include/gtest/internal/gtest-internal.h |
testing::internal::SuiteApiResolver<phmap::priv::gtest_suite_ConstructorTest_::AssignmentOverwritesExisting<phmap::parallel_flat_hash_map<int, int, phmap::priv::StatefulTestingHash, phmap::priv::StatefulTestingEqual, phmap::priv::Alloc<std::pair<int const, int>>, 4ul, phmap::NullMutex>>>::GetSetUpCaseOrSuite(char const... | static SetUpTearDownSuiteFuncType GetSetUpCaseOrSuite(const char* filename,
int line_num) {
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
SetUpTearDownSuiteFuncType test_case_fp =
GetNotDefaultOrNull(&T::SetUpTestCase, &Test::SetUpTestCase);
SetUpTearD... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0xeaa46(%rip), %rsi # 0x704a0
movq %rsi, %rdi
callq 0x70470
movq %rax, -0x18(%rbp)
leaq -0xeaa49(%rip), %rsi # 0x704b0
movq %rsi, %rdi
callq 0x70470
movq %rax, -0x20(%rbp)
movb $0x1, %al
cmpq $0x0, -0x18(%rbp)
movb %al, ... | /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/include/gtest/internal/gtest-internal.h |
testing::internal::SuiteApiResolver<phmap::priv::gtest_suite_ConstructorTest_::AssignmentOverwritesExisting<phmap::parallel_flat_hash_map<int, int, phmap::priv::StatefulTestingHash, phmap::priv::StatefulTestingEqual, phmap::priv::Alloc<std::pair<int const, int>>, 4ul, phmap::NullMutex>>>::GetTearDownCaseOrSuite(char co... | static SetUpTearDownSuiteFuncType GetTearDownCaseOrSuite(const char* filename,
int line_num) {
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
SetUpTearDownSuiteFuncType test_case_fp =
GetNotDefaultOrNull(&T::TearDownTestCase, &Test::TearDownTestCase);
... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0xeab66(%rip), %rsi # 0x704c0
movq %rsi, %rdi
callq 0x70470
movq %rax, -0x18(%rbp)
leaq -0xeab69(%rip), %rsi # 0x704d0
movq %rsi, %rdi
callq 0x70470
movq %rax, -0x20(%rbp)
movb $0x1, %al
cmpq $0x0, -0x18(%rbp)
movb %al, ... | /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/include/gtest/internal/gtest-internal.h |
testing::internal::TypeParameterizedTest<phmap::priv::ConstructorTest, testing::internal::TemplateSel<phmap::priv::gtest_suite_ConstructorTest_::AssignmentOverwritesExisting>, testing::internal::Types<phmap::parallel_flat_hash_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, phma... | static bool Register(const char* prefix, CodeLocation code_location,
const char* case_name, const char* test_names, int index,
const std::vector<std::string>& type_names =
GenerateNames<DefaultNameGenerator, Types>()) {
typedef typename Types:... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rsi, -0x1b0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x1a8(%rbp)
leaq -0xd1(%rbp), %rdi
movq %rdi, -0x1a0(%rb... | /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/include/gtest/internal/gtest-internal.h |
phmap::priv::gtest_suite_ConstructorTest_::AssignmentOverwritesExisting<phmap::parallel_flat_hash_map<int, int, phmap::priv::StatefulTestingHash, phmap::priv::StatefulTestingEqual, phmap::priv::Alloc<std::pair<int const, int>>, 4ul, phmap::NullMutex>>::AssignmentOverwritesExisting() | TYPED_TEST_P(ConstructorTest, AssignmentOverwritesExisting) {
using T = hash_internal::GeneratedType<TypeParam>;
hash_internal::Generator<T> gen;
TypeParam m({gen(), gen(), gen()});
TypeParam n({gen()});
n = m;
EXPECT_EQ(m, n);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x705d0
movq -0x10(%rbp), %rax
leaq 0x23ee34(%rip), %rcx # 0x39a538
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /greg7mdp[P]parallel-hashmap/tests/unordered_map_constructor_test.h |
phmap::priv::gtest_suite_ConstructorTest_::AssignmentOverwritesExisting<phmap::parallel_flat_hash_map<int, int, phmap::priv::StatefulTestingHash, phmap::priv::StatefulTestingEqual, phmap::priv::Alloc<std::pair<int const, int>>, 4ul, phmap::NullMutex>>::~AssignmentOverwritesExisting() | TYPED_TEST_P(ConstructorTest, AssignmentOverwritesExisting) {
using T = hash_internal::GeneratedType<TypeParam>;
hash_internal::Generator<T> gen;
TypeParam m({gen(), gen(), gen()});
TypeParam n({gen()});
n = m;
EXPECT_EQ(m, n);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x70980
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /greg7mdp[P]parallel-hashmap/tests/unordered_map_constructor_test.h |
phmap::priv::gtest_suite_ConstructorTest_::AssignmentOverwritesExisting<phmap::parallel_flat_hash_map<int, int, phmap::priv::StatefulTestingHash, phmap::priv::StatefulTestingEqual, phmap::priv::Alloc<std::pair<int const, int>>, 4ul, phmap::NullMutex>>::~AssignmentOverwritesExisting() | TYPED_TEST_P(ConstructorTest, AssignmentOverwritesExisting) {
using T = hash_internal::GeneratedType<TypeParam>;
hash_internal::Generator<T> gen;
TypeParam m({gen(), gen(), gen()});
TypeParam n({gen()});
n = m;
EXPECT_EQ(m, n);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x15b720
movq -0x10(%rbp), %rdi
movl $0x10, %esi
callq 0x30770
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| /greg7mdp[P]parallel-hashmap/tests/unordered_map_constructor_test.h |
phmap::priv::gtest_suite_ConstructorTest_::AssignmentOverwritesExisting<phmap::parallel_flat_hash_map<int, int, phmap::priv::StatefulTestingHash, phmap::priv::StatefulTestingEqual, phmap::priv::Alloc<std::pair<int const, int>>, 4ul, phmap::NullMutex>>::TestBody() | TYPED_TEST_P(ConstructorTest, AssignmentOverwritesExisting) {
using T = hash_internal::GeneratedType<TypeParam>;
hash_internal::Generator<T> gen;
TypeParam m({gen(), gen(), gen()});
TypeParam n({gen()});
n = m;
EXPECT_EQ(m, n);
} | pushq %rbp
movq %rsp, %rbp
subq $0x9f0, %rsp # imm = 0x9F0
movq %rdi, -0x8(%rbp)
leaq -0x9(%rbp), %rdi
movq %rdi, -0x9d8(%rbp)
callq 0xc4730
movq -0x9d8(%rbp), %rdi
movq %rax, -0x4b8(%rbp)
callq 0xc4730
movq -0x9d8(%rbp), %rdi
movq %rax, -0x4b0(%rbp)
callq 0xc4730
movq %rax, -0x4a8(%rbp)
leaq -0x4b8(%rbp), %... | /greg7mdp[P]parallel-hashmap/tests/unordered_map_constructor_test.h |
testing::internal::SuiteApiResolver<phmap::priv::gtest_suite_ConstructorTest_::AssignmentOverwritesExisting<phmap::parallel_flat_hash_map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, phmap::priv::StatefulTestingHash, phmap::priv::StatefulTestingEqual, phmap::priv::Alloc<std::pair... | static SetUpTearDownSuiteFuncType GetSetUpCaseOrSuite(const char* filename,
int line_num) {
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
SetUpTearDownSuiteFuncType test_case_fp =
GetNotDefaultOrNull(&T::SetUpTestCase, &Test::SetUpTestCase);
SetUpTearD... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0xeb6a6(%rip), %rsi # 0x704a0
movq %rsi, %rdi
callq 0x70470
movq %rax, -0x18(%rbp)
leaq -0xeb6a9(%rip), %rsi # 0x704b0
movq %rsi, %rdi
callq 0x70470
movq %rax, -0x20(%rbp)
movb $0x1, %al
cmpq $0x0, -0x18(%rbp)
movb %al, ... | /greg7mdp[P]parallel-hashmap/build_O0/googletest-src/googletest/include/gtest/internal/gtest-internal.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.