name string | code string | asm string | file string |
|---|---|---|---|
embree::ImageT<embree::Col3<unsigned char>>::ImageT(unsigned long, unsigned long, embree::Col3<unsigned char> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | ImageT (size_t width, size_t height, const T& color, const std::string& name = "")
: Image(width,height,name)
{
data = new T[width*height];
for (size_t i=0; i<width*height; i++) data[i] = color;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq $0x0, 0x8(%rdi)
leaq 0x7c1fc(%rip), %r13 # 0x16b2a0
movq %r13, (%rdi)
movq %rsi, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
addq $0x20, %rdi
leaq 0x30(%rbx), %rbp
movq %rbp, 0x20(%... | /embree[P]embree/tutorials/common/image/image.h |
embree::ImageT<embree::Col3<unsigned char>>::ImageT(unsigned long, unsigned long, embree::Col3<unsigned char>*, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | ImageT (size_t width, size_t height, T* color, const bool copy = true, const std::string& name = "", const bool flip_y = false)
: Image(width,height,name)
{
if (copy)
{
data = new T[width*height];
if (flip_y)
{
const T* in = color + (height-1) * width;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq $0x0, 0x8(%rdi)
leaq 0x7c127(%rip), %r13 # 0x16b2a0
movq %r13, (%rdi)
movq %rsi, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
addq $0x20, %rdi
leaq 0x30(%r12), %rax
m... | /embree[P]embree/tutorials/common/image/image.h |
embree::ImageT<embree::Col3<unsigned char>>::~ImageT() | virtual ~ImageT() {
delete[] data; data = nullptr;
} | pushq %rbx
movq %rdi, %rbx
leaq 0x7bf1d(%rip), %rax # 0x16b1d8
movq %rax, (%rdi)
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0xef2cc
callq 0x14af0
movq $0x0, 0x40(%rbx)
leaq 0x7bfc5(%rip), %rax # 0x16b2a0
movq %rax, (%rbx)
movq 0x20(%rbx), %rdi
addq $0x30, %rbx
cmpq %rbx, %rdi
je 0xef2f1
popq %rbx
jmp 0x14760
pop... | /embree[P]embree/tutorials/common/image/image.h |
embree::ImageT<embree::Col3<unsigned char>>::set(unsigned long, unsigned long, embree::Color4 const&) | __forceinline void set(size_t x, size_t y, const Color4& c) {
c.set(data[y*width+x]);
} | imulq 0x10(%rdi), %rdx
leaq (%rdx,%rdx,2), %rax
addq 0x40(%rdi), %rax
leaq (%rsi,%rsi,2), %rdx
movaps (%rcx), %xmm0
minps 0x2a92b(%rip), %xmm0 # 0x119ca0
xorps %xmm1, %xmm1
maxps %xmm1, %xmm0
mulps 0x324be(%rip), %xmm0 # 0x121840
cvttss2si %xmm0, %ecx
movb %cl, (%rax,%rdx)
movaps %xmm0, %xmm1
shufps $0x55, %xmm0,... | /embree[P]embree/tutorials/common/image/image.h |
embree::ImageT<embree::Col3<float>>::ImageT(unsigned long, unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | ImageT (size_t width = 0, size_t height = 0, const std::string& name = "")
: Image(width,height,name)
{
data = new T[width*height];
memset((void*)data,0,width*height*sizeof(T));
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq $0x0, 0x8(%rdi)
leaq 0x7bec7(%rip), %r12 # 0x16b2a0
movq %r12, (%rdi)
movq %rsi, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
addq $0x20, %rdi
leaq 0x30(%rbx), %r13
movq %r13, 0x20(%rbx)
movq (%rcx), %rsi
movq 0x8(%rcx),... | /embree[P]embree/tutorials/common/image/image.h |
embree::ImageT<embree::Col3<float>>::ImageT(unsigned long, unsigned long, embree::Col3<float>*, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | ImageT (size_t width, size_t height, T* color, const bool copy = true, const std::string& name = "", const bool flip_y = false)
: Image(width,height,name)
{
if (copy)
{
data = new T[width*height];
if (flip_y)
{
const T* in = color + (height-1) * width;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq $0x0, 0x8(%rdi)
leaq 0x7bd37(%rip), %r13 # 0x16b2a0
movq %r13, (%rdi)
movq %rsi, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
addq $0x20, %rdi
leaq 0x30(%r12), %rax
m... | /embree[P]embree/tutorials/common/image/image.h |
embree::loadPFM(embree::FileName const&) | Ref<Image> loadPFM(const FileName& fileName)
{
/* open file for reading */
std::fstream file;
file.exceptions (std::fstream::failbit | std::fstream::badbit);
file.open (fileName.c_str(), std::fstream::in | std::fstream::binary);
/* read file type */
char cty[2]; file.read(cty,2);
skipSpac... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2a8, %rsp # imm = 0x2A8
movq %rsi, %r15
movq %rdi, 0x18(%rsp)
leaq 0x98(%rsp), %rbx
movq %rbx, %rdi
callq 0x149a0
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %rdi
addq $0x98, %rdi
movl $0x5, 0x1c(%rdi)
movl 0x20(%rdi), %... | /embree[P]embree/tutorials/common/image/pfm.cpp |
embree::storePFM(embree::Ref<embree::Image> const&, embree::FileName const&) | void storePFM(const Ref<Image>& img, const FileName& fileName)
{
/* open file for writing */
std::fstream file;
file.exceptions (std::fstream::failbit | std::fstream::badbit);
file.open (fileName.c_str(), std::fstream::out | std::fstream::binary);
/* write file header */
file << "PF" << std::... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x220, %rsp # imm = 0x220
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x149a0
movq (%r15), %rax
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %rdi
addq $0x10, %rdi
movl $0x5, 0x1c(%rdi)
movl 0x20(%rdi), %esi
callq 0x14f50... | /embree[P]embree/tutorials/common/image/pfm.cpp |
embree::ImageT<embree::Col4<float>>::ImageT(unsigned long, unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | ImageT (size_t width = 0, size_t height = 0, const std::string& name = "")
: Image(width,height,name)
{
data = new T[width*height];
memset((void*)data,0,width*height*sizeof(T));
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq $0x0, 0x8(%rdi)
leaq 0x7b077(%rip), %r12 # 0x16b2a0
movq %r12, (%rdi)
movq %rsi, 0x10(%rdi)
movq %rdx, 0x18(%rdi)
addq $0x20, %rdi
leaq 0x30(%rbx), %r13
movq %r13, 0x20(%rbx)
movq (%rcx), %rsi
movq 0x8(%rcx),... | /embree[P]embree/tutorials/common/image/image.h |
embree::ImageT<embree::Col4<float>>::~ImageT() | virtual ~ImageT() {
delete[] data; data = nullptr;
} | pushq %rbx
movq %rdi, %rbx
leaq 0x7b027(%rip), %rax # 0x16b2e0
movq %rax, (%rdi)
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0xf02ca
callq 0x14af0
movq $0x0, 0x40(%rbx)
leaq 0x7afc7(%rip), %rax # 0x16b2a0
movq %rax, (%rbx)
movq 0x20(%rbx), %rdi
addq $0x30, %rbx
cmpq %rbx, %rdi
je 0xf02ef
popq %rbx
jmp 0x14760
pop... | /embree[P]embree/tutorials/common/image/image.h |
embree::loadPPM(embree::FileName const&) | Ref<Image> loadPPM(const FileName& fileName)
{
/* open file for reading */
std::fstream file;
file.exceptions (std::fstream::failbit | std::fstream::badbit);
file.open (fileName.c_str(), std::fstream::in | std::fstream::binary);
/* read file type */
char cty[2]; file.read(cty,2);
skipSpac... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2a8, %rsp # imm = 0x2A8
movq %rsi, %r15
movq %rdi, 0x48(%rsp)
leaq 0x98(%rsp), %rbx
movq %rbx, %rdi
callq 0x149a0
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %rdi
addq $0x98, %rdi
movl $0x5, 0x1c(%rdi)
movl 0x20(%rdi), %... | /embree[P]embree/tutorials/common/image/ppm.cpp |
embree::loadTGA(embree::FileName const&) | Ref<Image> loadTGA(const FileName& fileName)
{
/* open file for reading */
std::fstream file;
file.exceptions (std::fstream::failbit | std::fstream::badbit);
file.open (fileName.c_str(), std::fstream::in | std::fstream::binary);
unsigned char idlength = fread_uchar(file);
if (idlength != 0) T... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp # imm = 0x258
movq %rsi, %r14
movq %rdi, 0x40(%rsp)
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
callq 0x149a0
movq (%rbx), %rax
movq -0x18(%rax), %rax
leaq (%rsp,%rax), %rdi
addq $0x48, %rdi
movl $0x5, 0x1c(%rdi)
movl 0x20(%rdi), %... | /embree[P]embree/tutorials/common/image/tga.cpp |
stbi_load_from_file | STBIDEF stbi_uc *stbi_load_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
{
unsigned char *result;
stbi__context s;
stbi__start_file(&s,f);
result = stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
if (result) {
// need to 'unget' all the characters in the IO buffer
fseek(f... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x79e13(%rip), %rax # 0x16b390
leaq 0x40(%rsp), %rcx
movq %rax, -0x18(%rcx)
movups 0x79df3(%rip), %xmm0 # 0x16b380
movups %xmm0, -0x28(%rcx)
movq... | /embree[P]embree/tutorials/common/image/stb_image.h |
stbi__load_and_postprocess_8bit(stbi__context*, int*, int*, int*, int) | static unsigned char *stbi__load_and_postprocess_8bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)
{
stbi__result_info ri;
void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 8);
if (result == NULL)
return NULL;
// it is the responsibility of the loaders to make sure we get ei... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebx
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %r15
movl $0x8, (%rsp)
leaq 0x1c(%rsp), %r9
callq 0xf6b49
testq %rax, %rax
je 0xf1669
movq %rax, %rbp
cmpl $0x8, 0x1c(%rsp)
movq %r13, 0x10(%rsp)
jne 0xf1671
movq %rbp, %r13
jmp ... | /embree[P]embree/tutorials/common/image/stb_image.h |
stbi_load_from_file_16 | STBIDEF stbi__uint16 *stbi_load_from_file_16(FILE *f, int *x, int *y, int *comp, int req_comp)
{
stbi__uint16 *result;
stbi__context s;
stbi__start_file(&s,f);
result = stbi__load_and_postprocess_16bit(&s,x,y,comp,req_comp);
if (result) {
// need to 'unget' all the characters in the IO buffer
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x79c32(%rip), %rax # 0x16b390
leaq 0x40(%rsp), %rcx
movq %rax, -0x18(%rcx)
movups 0x79c12(%rip), %xmm0 # 0x16b380
movups %xmm0, -0x28(%rcx)
movq... | /embree[P]embree/tutorials/common/image/stb_image.h |
stbi__load_and_postprocess_16bit(stbi__context*, int*, int*, int*, int) | static stbi__uint16 *stbi__load_and_postprocess_16bit(stbi__context *s, int *x, int *y, int *comp, int req_comp)
{
stbi__result_info ri;
void *result = stbi__load_main(s, x, y, comp, req_comp, &ri, 16);
if (result == NULL)
return NULL;
// it is the responsibility of the loaders to make sure we get e... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebx
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %r15
movl $0x10, (%rsp)
leaq 0x1c(%rsp), %r9
callq 0xf6b49
testq %rax, %rax
je 0xf184d
movq %rax, %rbp
cmpl $0x10, 0x1c(%rsp)
movq %r13, 0x10(%rsp)
jne 0xf1855
movq %rbp, %r13
jm... | /embree[P]embree/tutorials/common/image/stb_image.h |
stbi_load_16_from_memory | STBIDEF stbi_us *stbi_load_16_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *channels_in_file, int desired_channels)
{
stbi__context s;
stbi__start_mem(&s,buffer,len);
return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels);
} | subq $0xe8, %rsp
leaq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
xorl %r10d, %r10d
movl %r10d, 0x30(%rax)
movl %r10d, 0xb8(%rax)
movq %rdi, 0xd0(%rax)
movq %rdi, 0xc0(%rax)
movslq %esi, %rsi
addq %rdi, %rsi
movq %rsi, 0xd8(%rax)
movq %rsi, 0xc8(%rax)
movq %rax, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
movl %r9d, ... | /embree[P]embree/tutorials/common/image/stb_image.h |
stbi_load_16_from_callbacks | STBIDEF stbi_us *stbi_load_16_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *channels_in_file, int desired_channels)
{
stbi__context s;
stbi__start_callbacks(&s, (stbi_io_callbacks *)clbk, user);
return stbi__load_and_postprocess_16bit(&s,x,y,channels_in_file,desired_channels);
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movl %r9d, %ebx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq 0x10(%rdi), %rax
leaq 0x38(%rsp), %rcx
movq %rax, -0x18(%rcx)
movups (%rdi), %xmm0
movups %xmm0, -0x28(%rcx)
movq %rsi, -0x10(%rcx)
movabsq $0x8000000001, %rax # imm = 0x800000... | /embree[P]embree/tutorials/common/image/stb_image.h |
stbi_load_from_memory | STBIDEF stbi_uc *stbi_load_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp, int req_comp)
{
stbi__context s;
stbi__start_mem(&s,buffer,len);
return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
} | subq $0xe8, %rsp
leaq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
xorl %r10d, %r10d
movl %r10d, 0x30(%rax)
movl %r10d, 0xb8(%rax)
movq %rdi, 0xd0(%rax)
movq %rdi, 0xc0(%rax)
movslq %esi, %rsi
addq %rdi, %rsi
movq %rsi, 0xd8(%rax)
movq %rsi, 0xc8(%rax)
movq %rax, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
movl %r9d, ... | /embree[P]embree/tutorials/common/image/stb_image.h |
stbi_load_from_callbacks | STBIDEF stbi_uc *stbi_load_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)
{
stbi__context s;
stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
return stbi__load_and_postprocess_8bit(&s,x,y,comp,req_comp);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movl %r9d, %ebx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq 0x10(%rdi), %rax
leaq 0x38(%rsp), %rcx
movq %rax, -0x18(%rcx)
movups (%rdi), %xmm0
movups %xmm0, -0x28(%rcx)
movq %rsi, -0x10(%rcx)
movabsq $0x8000000001, %rax # imm = 0x800000... | /embree[P]embree/tutorials/common/image/stb_image.h |
stbi_load_gif_from_memory | STBIDEF stbi_uc *stbi_load_gif_from_memory(stbi_uc const *buffer, int len, int **delays, int *x, int *y, int *z, int *comp, int req_comp)
{
unsigned char *result;
stbi__context s;
stbi__start_mem(&s,buffer,len);
result = (unsigned char*) stbi__load_gif_main(&s, delays, x, y, z, comp, req_comp);
if (stbi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x8988, %rsp # imm = 0x8988
movq %r9, %r15
movq %r8, 0x20(%rsp)
movq %rcx, 0x30(%rsp)
movq %rdx, %rbx
leaq 0x38(%rsp), %rcx
movq $0x0, 0x10(%rcx)
xorl %eax, %eax
movl %eax, 0x30(%rcx)
movl %eax, 0xb8(%rcx)
movq %rdi, 0xd0(%rcx)
movq %rdi,... | /embree[P]embree/tutorials/common/image/stb_image.h |
stbi__loadf_main(stbi__context*, int*, int*, int*, int) | static float *stbi__loadf_main(stbi__context *s, int *x, int *y, int *comp, int req_comp)
{
unsigned char *data;
#ifndef STBI_NO_HDR
if (stbi__hdr_test(s)) {
stbi__result_info ri;
float *hdr_data = stbi__hdr_load(s,x,y,comp,req_comp, &ri);
if (hdr_data)
stbi__float_postprocess(hdr_da... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebx
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
callq 0xf236e
movq %r14, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r12, %rcx
movl %ebx, %r8d
testl %eax, %eax
je 0xf2001
callq 0xfc326
testq %rax, %rax
je 0... | /embree[P]embree/tutorials/common/image/stb_image.h |
stbi_loadf_from_callbacks | STBIDEF float *stbi_loadf_from_callbacks(stbi_io_callbacks const *clbk, void *user, int *x, int *y, int *comp, int req_comp)
{
stbi__context s;
stbi__start_callbacks(&s, (stbi_io_callbacks *) clbk, user);
return stbi__loadf_main(&s,x,y,comp,req_comp);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movl %r9d, %ebx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq 0x10(%rdi), %rax
leaq 0x38(%rsp), %rcx
movq %rax, -0x18(%rcx)
movups (%rdi), %xmm0
movups %xmm0, -0x28(%rcx)
movq %rsi, -0x10(%rcx)
movabsq $0x8000000001, %rax # imm = 0x800000... | /embree[P]embree/tutorials/common/image/stb_image.h |
stbi_loadf | STBIDEF float *stbi_loadf(char const *filename, int *x, int *y, int *comp, int req_comp)
{
float *result;
FILE *f = stbi__fopen(filename, "rb");
if (!f) return stbi__errpf("can't fopen", "Unable to open file");
result = stbi_loadf_from_file(f,x,y,comp,req_comp);
fclose(f);
return result;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
leaq 0x2e772(%rip), %rsi # 0x120999
callq 0x14980
testq %rax, %rax
je 0xf2258
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movl %ebx, %r8d
callq 0xf227e
movq %rax... | /embree[P]embree/tutorials/common/image/stb_image.h |
stbi_loadf_from_file | STBIDEF float *stbi_loadf_from_file(FILE *f, int *x, int *y, int *comp, int req_comp)
{
stbi__context s;
stbi__start_file(&s,f);
return stbi__loadf_main(&s,x,y,comp,req_comp);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq 0x790ef(%rip), %rax # 0x16b390
leaq 0x38(%rsp), %rcx
movq %rax, -0x18(%rcx)
movups 0x790cf(%rip), %xmm0 # 0x16b380
movups %xmm0, -0x28(%rcx)
movq %rdi, -0x10(%rcx)
movabsq ... | /embree[P]embree/tutorials/common/image/stb_image.h |
stbi_is_hdr_from_memory | STBIDEF int stbi_is_hdr_from_memory(stbi_uc const *buffer, int len)
{
#ifndef STBI_NO_HDR
stbi__context s;
stbi__start_mem(&s,buffer,len);
return stbi__hdr_test(&s);
#else
STBI_NOTUSED(buffer);
STBI_NOTUSED(len);
return 0;
#endif
} | subq $0xe8, %rsp
leaq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
xorl %ecx, %ecx
movl %ecx, 0x30(%rax)
movl %ecx, 0xb8(%rax)
movq %rdi, 0xd0(%rax)
movq %rdi, 0xc0(%rax)
movslq %esi, %rcx
addq %rdi, %rcx
movq %rcx, 0xd8(%rax)
movq %rcx, 0xc8(%rax)
movq %rax, %rdi
callq 0xf236e
addq $0xe8, %rsp
retq
| /embree[P]embree/tutorials/common/image/stb_image.h |
stbi_is_16_bit_from_file | STBIDEF int stbi_is_16_bit_from_file(FILE *f)
{
int r;
stbi__context s;
long pos = ftell(f);
stbi__start_file(&s, f);
r = stbi__is_16_main(&s);
fseek(f,pos,SEEK_SET);
return r;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xe8, %rsp
movq %rdi, %rbx
callq 0x14030
movq %rax, %r14
movups 0x77da8(%rip), %xmm0 # 0x16b380
leaq 0x40(%rsp), %rax
movups %xmm0, -0x28(%rax)
movq 0x77da8(%rip), %rcx # 0x16b390
movq %rcx, -0x18(%rax)
movq %rbx, -0x10(%rax)
movabsq $0x8000000001, %rcx # imm... | /embree[P]embree/tutorials/common/image/stb_image.h |
stbi__is_16_main(stbi__context*) | static int stbi__is_16_main(stbi__context *s)
{
#ifndef STBI_NO_PNG
if (stbi__png_is16(s)) return 1;
#endif
#ifndef STBI_NO_PSD
if (stbi__psd_is16(s)) return 1;
#endif
#ifndef STBI_NO_PNM
if (stbi__pnm_is16(s)) return 1;
#endif
return 0;
} | pushq %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rsp, %rdi
movq %rbx, (%rdi)
movl $0x2, %esi
xorl %edx, %edx
callq 0xfd6ee
testl %eax, %eax
je 0xf3688
cmpl $0x10, 0x20(%rsp)
jne 0xf3688
movl $0x1, %eax
jmp 0xf3753
movq (%rsp), %rax
movups 0xd0(%rax), %xmm0
movups %xmm0, 0xc0(%rax)
movq %rbx, %rdi
callq 0xfe... | /embree[P]embree/tutorials/common/image/stb_image.h |
stbi_info_from_memory | STBIDEF int stbi_info_from_memory(stbi_uc const *buffer, int len, int *x, int *y, int *comp)
{
stbi__context s;
stbi__start_mem(&s,buffer,len);
return stbi__info_main(&s,x,y,comp);
} | subq $0xe8, %rsp
leaq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
xorl %r9d, %r9d
movl %r9d, 0x30(%rax)
movl %r9d, 0xb8(%rax)
movq %rdi, 0xd0(%rax)
movq %rdi, 0xc0(%rax)
movslq %esi, %rsi
addq %rdi, %rsi
movq %rsi, 0xd8(%rax)
movq %rsi, 0xc8(%rax)
movq %rax, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
callq 0xf32e6
a... | /embree[P]embree/tutorials/common/image/stb_image.h |
stbi_info_from_callbacks | STBIDEF int stbi_info_from_callbacks(stbi_io_callbacks const *c, void *user, int *x, int *y, int *comp)
{
stbi__context s;
stbi__start_callbacks(&s, (stbi_io_callbacks *) c, user);
return stbi__info_main(&s,x,y,comp);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq 0x10(%rdi), %rax
leaq 0x40(%rsp), %rcx
movq %rax, -0x18(%rcx)
movups (%rdi), %xmm0
movups %xmm0, -0x28(%rcx)
movq %rsi, -0x10(%rcx)
movabsq $0x8000000001, %rax # imm = 0x8000000001
movq %rax, -0x8(%rcx)
... | /embree[P]embree/tutorials/common/image/stb_image.h |
stbi_is_16_bit_from_memory | STBIDEF int stbi_is_16_bit_from_memory(stbi_uc const *buffer, int len)
{
stbi__context s;
stbi__start_mem(&s,buffer,len);
return stbi__is_16_main(&s);
} | subq $0xe8, %rsp
leaq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
xorl %ecx, %ecx
movl %ecx, 0x30(%rax)
movl %ecx, 0xb8(%rax)
movq %rdi, 0xd0(%rax)
movq %rdi, 0xc0(%rax)
movslq %esi, %rcx
addq %rdi, %rcx
movq %rcx, 0xd8(%rax)
movq %rcx, 0xc8(%rax)
movq %rax, %rdi
callq 0xf3658
addq $0xe8, %rsp
retq
| /embree[P]embree/tutorials/common/image/stb_image.h |
stbi_write_bmp_core(stbi__write_context*, int, int, int, void const*) | static int stbi_write_bmp_core(stbi__write_context *s, int x, int y, int comp, const void *data)
{
if (comp != 4) {
// write RGB bitmap
int pad = (-x*3) & 3;
return stbiw__outfile(s,-1,-1,x,y,comp,1,(void *) data,0,pad,
"11 4 22 4" "4 44 22 444444",
'B', 'M', 14+40+(x*3+... | pushq %r15
pushq %r14
pushq %rbx
movq %r8, %r10
movl %ecx, %r9d
movl %esi, %ecx
cmpl $0x4, %r9d
jne 0xf39f5
movl %ecx, %eax
imull %edx, %eax
leal 0x7a(,%rax,4), %r14d
subq $0x8, %rsp
xorl %r11d, %r11d
movl $0x1, %esi
leaq 0x30871(%rip), %rbx # 0x1241f9
movl %edx, %r8d
movl $0x4, %r9d
xorl %eax, %eax
pushq %r11
push... | /embree[P]embree/tutorials/common/image/stb_image_write.h |
stbi_write_bmp | STBIWDEF int stbi_write_bmp(char const *filename, int x, int y, int comp, const void *data)
{
stbi__write_context s = { 0 };
if (stbi__start_write_file(&s,filename)) {
int r = stbi_write_bmp_core(&s, x, y, comp, data);
stbi__end_write_file(&s);
return r;
} else
return 0;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %r8, %rbx
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rsp)
movups %xmm0, 0x38(%rsp)
movups %xmm0, 0x28(%rsp)
movups %xmm0, 0x18(%rsp)
movq $0x0, 0x58(%rsp)
leaq 0x301c7(%rip), %rsi # 0x123c54
ca... | /embree[P]embree/tutorials/common/image/stb_image_write.h |
stbi_write_tga | STBIWDEF int stbi_write_tga(char const *filename, int x, int y, int comp, const void *data)
{
stbi__write_context s = { 0 };
if (stbi__start_write_file(&s,filename)) {
int r = stbi_write_tga_core(&s, x, y, comp, (void *) data);
stbi__end_write_file(&s);
return r;
} else
return 0;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %r8, %rbx
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rsp)
movups %xmm0, 0x38(%rsp)
movups %xmm0, 0x28(%rsp)
movups %xmm0, 0x18(%rsp)
movq $0x0, 0x58(%rsp)
leaq 0x2fcf6(%rip), %rsi # 0x123c54
ca... | /embree[P]embree/tutorials/common/image/stb_image_write.h |
stbi_zlib_compress | STBIWDEF unsigned char * stbi_zlib_compress(unsigned char *data, int data_len, int *out_len, int quality)
{
#ifdef STBIW_ZLIB_COMPRESS
// user provided a zlib compress implementation, use that
return STBIW_ZLIB_COMPRESS(data, data_len, out_len, quality);
#else // use builtin
static unsigned short lengthc[] = {... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
movq $0x0, 0x8(%rsp)
movl $0x20000, %edi # imm = 0x20000
callq 0x14b30
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0xf4bb0
movq %r14, 0x28(%rsp)
cmpl $0x6, %ebx... | /embree[P]embree/tutorials/common/image/stb_image_write.h |
stbiw__sbgrowf(void**, int, int) | static void *stbiw__sbgrowf(void **arr, int increment, int itemsize)
{
int m = *arr ? 2*stbiw__sbm(*arr)+increment : increment+1;
void *p = STBIW_REALLOC_SIZED(*arr ? stbiw__sbraw(*arr) : 0, *arr ? (stbiw__sbm(*arr)*itemsize + sizeof(int)*2) : 0, itemsize * m + sizeof(int)*2);
STBIW_ASSERT(p);
if (p) {
... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0xf4f18
movl -0x8(%rax), %ecx
leal 0x1(,%rcx,2), %ebp
jmp 0xf4f1d
movl $0x2, %ebp
leaq -0x8(%rax), %rdi
testq %rax, %rax
cmoveq %rax, %rdi
imull %ebp, %esi
movslq %esi, %rsi
addq $0x8, %rsi
callq 0x14ec0
testq %rax, %rax
je 0xf4f55
c... | /embree[P]embree/tutorials/common/image/stb_image_write.h |
stbi_write_png_to_func | STBIWDEF int stbi_write_png_to_func(stbi_write_func *func, void *context, int x, int y, int comp, const void *data, int stride_bytes)
{
int len;
unsigned char *png = stbi_write_png_to_mem((const unsigned char *) data, stride_bytes, x, y, comp, &len);
if (png == NULL) return 0;
func(context, png, len);
ST... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %r9, %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x30(%rsp), %esi
leaq 0xc(%rsp), %r9
movq %rax, %rdi
callq 0xf4fd1
testq %rax, %rax
je 0xf56cb
movq %rax, %r15
movl 0xc(%rsp), %edx
movq %r14, %rdi
movq %rax, %rsi
callq *%rbx
movq %r15, %rdi
callq 0x149b0
movl $0x1, %... | /embree[P]embree/tutorials/common/image/stb_image_write.h |
stbi_write_jpg_core(stbi__write_context*, int, int, int, void const*, int) | static int stbi_write_jpg_core(stbi__write_context *s, int width, int height, int comp, const void* data, int quality) {
// Constants that don't pollute global namespace
static const unsigned char std_dc_luminance_nrcodes[] = {0,0,1,5,1,1,1,1,1,1,0,0,0,0,0,0,0};
static const unsigned char std_dc_luminance_valu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10d8, %rsp # imm = 0x10D8
movl %ecx, %r15d
movq %rdi, 0x10(%rsp)
leal -0x5(%r15), %eax
xorl %ebp, %ebp
cmpl $-0x4, %eax
jb 0xf63c2
testl %edx, %edx
je 0xf63c2
movl %esi, %ebx
testl %esi, %esi
je 0xf63c2
testq %r8, %r8
je 0xf63c2
movq %r... | /embree[P]embree/tutorials/common/image/stb_image_write.h |
embree::storeSTB(embree::Ref<embree::Image> const&, embree::FileName const&) | void storeSTB(const Ref<Image>& img, const FileName& fileName)
{
std::string ext = toLowerCase(fileName.ext());
if (ext != "bmp" && ext != "png" && ext != "jpg") {
THROW_RUNTIME_ERROR("Could not store image")
return;
}
int width = int(img->width);
int height = int(img->height);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %r12
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x7cafc
leaq 0x58(%rsp), %rdi
movq %rbx, %rsi
callq 0x117ac8
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf6771
callq 0x14760
leaq 0x2b0d8(%... | /embree[P]embree/tutorials/common/image/stb.cpp |
stbi__pic_test(stbi__context*) | static int stbi__pic_test(stbi__context *s)
{
int r = stbi__pic_test_core(s);
stbi__rewind(s);
return r;
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2a507(%rip), %rsi # 0x123f29
callq 0x1012d8
testl %eax, %eax
je 0xf9a74
movq 0xc0(%rbx), %rax
movl $0x54, %ebp
cmpq 0xc8(%rbx), %rax
jb 0xf9a55
cmpl $0x0, 0x30(%rbx)
je 0xf9a5f
movq %rbx, %rdi
callq 0xfd694
movq 0xc0(%rbx), %rax
incq %rax
movq %rax, 0xc0(%rbx)... | /embree[P]embree/tutorials/common/image/stb_image.h |
stbi__pnm_load(stbi__context*, int*, int*, int*, int, stbi__result_info*) | static void *stbi__pnm_load(stbi__context *s, int *x, int *y, int *comp, int req_comp, stbi__result_info *ri)
{
stbi_uc *out;
STBI_NOTUSED(ri);
ri->bits_per_channel = stbi__pnm_info(s, (int *)&s->img_x, (int *)&s->img_y, (int *)&s->img_n);
if (ri->bits_per_channel == 0)
return 0;
if (s->img_y > S... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r12
movl %r8d, 0x4(%rsp)
movq %rcx, 0x10(%rsp)
movq %rdx, %rbp
movq %rsi, %r13
movq %rdi, %r14
leaq 0x4(%rdi), %rbx
leaq 0x8(%rdi), %rcx
movq %rdi, %rsi
movq %rbx, %rdx
movq %rcx, %r15
callq 0x103c6e
movl %eax, (%r12)
testl %e... | /embree[P]embree/tutorials/common/image/stb_image.h |
stbi__get8(stbi__context*) | stbi_inline static stbi_uc stbi__get8(stbi__context *s)
{
if (s->img_buffer < s->img_buffer_end)
return *s->img_buffer++;
if (s->read_from_callbacks) {
stbi__refill_buffer(s);
return *s->img_buffer++;
}
return 0;
} | pushq %rbx
movq %rdi, %rbx
movq 0xc0(%rdi), %rax
cmpq 0xc8(%rdi), %rax
jb 0xfd681
cmpl $0x0, 0x30(%rbx)
je 0xfd690
movq %rbx, %rdi
callq 0xfd694
movq 0xc0(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0xc0(%rbx)
movb (%rax), %al
popq %rbx
retq
xorl %eax, %eax
jmp 0xfd68e
| /embree[P]embree/tutorials/common/image/stb_image.h |
stbi__getn(stbi__context*, unsigned char*, int) | static int stbi__getn(stbi__context *s, stbi_uc *buffer, int n)
{
if (s->io.read) {
int blen = (int) (s->img_buffer_end - s->img_buffer);
if (blen < n) {
int res, count;
memcpy(buffer, s->img_buffer, blen);
count = (s->io.read)(s->io_user_data, (char*) buffer + blen, n - blen... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x10(%rdi)
je 0xfef24
movq 0xc0(%rbx), %rsi
movq 0xc8(%rbx), %rcx
movq %rcx, %rax
subq %rsi, %rax
movl %edx, %ebp
subl %eax, %ebp
jle 0xfef32
movslq %eax, %r15
movq %r14, %rdi
movq %r15, %rdx
callq 0x14690
movq 0x28(%rbx),... | /embree[P]embree/tutorials/common/image/stb_image.h |
stbi__compute_transparency16(stbi__png*, unsigned short*, int) | static int stbi__compute_transparency16(stbi__png *z, stbi__uint16 tc[3], int out_n)
{
stbi__context *s = z->s;
stbi__uint32 i, pixel_count = s->img_x * s->img_y;
stbi__uint16 *p = (stbi__uint16*) z->out;
// compute color-based transparency, assuming we've
// already got 65535 as the alpha value in the ... | imull %esi, %edi
cmpl $0x2, %r8d
jne 0xfef93
testl %edi, %edi
je 0xfefc8
movl %edi, %eax
xorl %esi, %esi
movzwl (%rdx,%rsi,4), %edi
xorl %r8d, %r8d
cmpw (%rcx), %di
setne %r8b
negl %r8d
movw %r8w, 0x2(%rdx,%rsi,4)
incq %rsi
cmpl %esi, %eax
jne 0xfef73
jmp 0xfefc8
testl %edi, %edi
je 0xfefc8
movl %edi, %eax
xorl %esi, %... | /embree[P]embree/tutorials/common/image/stb_image.h |
stbi__compute_transparency(stbi__png*, unsigned char*, int) | static int stbi__compute_transparency(stbi__png *z, stbi_uc tc[3], int out_n)
{
stbi__context *s = z->s;
stbi__uint32 i, pixel_count = s->img_x * s->img_y;
stbi_uc *p = z->out;
// compute color-based transparency, assuming we've
// already got 255 as the alpha value in the output
STBI_ASSERT(out_n ==... | imull %esi, %edi
cmpl $0x2, %r8d
jne 0xfeff6
testl %edi, %edi
je 0xff029
movl %edi, %eax
xorl %esi, %esi
movb (%rdx,%rsi,2), %dil
cmpb (%rcx), %dil
setne %dil
negb %dil
movb %dil, 0x1(%rdx,%rsi,2)
incq %rsi
cmpl %esi, %eax
jne 0xfefda
jmp 0xff029
testl %edi, %edi
je 0xff029
movl %edi, %eax
xorl %esi, %esi
movb (%rdx,%r... | /embree[P]embree/tutorials/common/image/stb_image.h |
stbi__de_iphone(stbi__png*) | static void stbi__de_iphone(stbi__png *z)
{
stbi__context *s = z->s;
stbi__uint32 i, pixel_count = s->img_x * s->img_y;
stbi_uc *p = z->out;
if (s->img_out_n == 3) { // convert bgr to rgb
for (i=0; i < pixel_count; ++i) {
stbi_uc t = p[0];
p[0] = p[2];
p[2] = t;
p... | pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x4(%rdi), %ebp
imull (%rdi), %ebp
cmpl $0x3, 0xc(%rdi)
jne 0xff05b
testl %ebp, %ebp
je 0xff120
movb (%rbx), %al
movb 0x2(%rbx), %cl
movb %cl, (%rbx)
movb %al, 0x2(%rbx)
addq $0x3, %rbx
decl %ebp
jne 0xff044
jmp 0xff120
movq %fs:0x0, %rax
cmpl $0x0, -0xc(%rax)
leaq ... | /embree[P]embree/tutorials/common/image/stb_image.h |
InitEXRImage | void InitEXRImage(EXRImage *exr_image) {
if (exr_image == NULL) {
return;
}
exr_image->width = 0;
exr_image->height = 0;
exr_image->num_channels = 0;
exr_image->images = NULL;
exr_image->tiles = NULL;
exr_image->next_level = NULL;
exr_image->level_x = 0;
exr_image->level_y = 0;
exr_image->n... | testq %rdi, %rdi
je 0x1072b8
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
retq
| /embree[P]embree/tutorials/common/image/tinyexr.h |
ParseEXRVersionFromMemory | int ParseEXRVersionFromMemory(EXRVersion *version, const unsigned char *memory,
size_t size) {
if (version == NULL || memory == NULL) {
return TINYEXR_ERROR_INVALID_ARGUMENT;
}
if (size < tinyexr::kEXRVersionSize) {
return TINYEXR_ERROR_INVALID_DATA;
}
const unsigned ch... | testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
movl $0xfffffffd, %eax # imm = 0xFFFFFFFD
jne 0x1076eb
movl $0xfffffffc, %eax # imm = 0xFFFFFFFC
cmpq $0x8, %rdx
jb 0x1076eb
cmpl $0x1312f76, (%rsi) # imm = 0x1312F76
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
je 0x1076ec
retq
xorps ... | /embree[P]embree/tutorials/common/image/tinyexr.h |
tinyexr::ConvertHeader(TEXRHeader*, tinyexr::HeaderInfo const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | static bool ConvertHeader(EXRHeader *exr_header, const HeaderInfo &info, std::string *warn, std::string *err) {
exr_header->pixel_aspect_ratio = info.pixel_aspect_ratio;
exr_header->screen_window_center[0] = info.screen_window_center[0];
exr_header->screen_window_center[1] = info.screen_window_center[1];
exr_he... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movss 0x60(%rsi), %xmm0
movss %xmm0, (%rdi)
movss 0x54(%rsi), %xmm0
movss %xmm0, 0x28(%rdi)
movss 0x58(%rsi), %xmm0
movss %xmm0, 0x2c(%rdi)
movss 0... | /embree[P]embree/tutorials/common/image/tinyexr.h |
SaveEXRImageToFile | int SaveEXRImageToFile(const EXRImage *exr_image, const EXRHeader *exr_header,
const char *filename, const char **err) {
if (exr_image == NULL || filename == NULL ||
exr_header->compression_type < 0) {
tinyexr::SetErrorMessage("Invalid argument for SaveEXRImageToFile", err);
retur... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rcx, %rbx
testq %rdi, %rdi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
jne 0x10b47d
movq %rsi, %r13
movl 0x7c(%rsi), %eax
testl %eax, %eax
js 0x10b47d
cmpl $0x80, %eax
jne 0x10b4d8
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x19152... | /embree[P]embree/tutorials/common/image/tinyexr.h |
EXRNumLevels | int EXRNumLevels(const EXRImage* exr_image) {
if (exr_image == NULL) return 0;
if(exr_image->images) return 1; // scanlines
int levels = 1;
const EXRImage* level_image = exr_image;
while((level_image = level_image->next_level)) ++levels;
return levels;
} | testq %rdi, %rdi
je 0x10cdee
movl $0x1, %eax
cmpq $0x0, 0x18(%rdi)
je 0x10cdf1
retq
xorl %eax, %eax
retq
xorl %eax, %eax
movq 0x8(%rdi), %rdi
incl %eax
testq %rdi, %rdi
jne 0x10cdf3
jmp 0x10cded
| /embree[P]embree/tutorials/common/image/tinyexr.h |
ParseEXRMultipartHeaderFromMemory | int ParseEXRMultipartHeaderFromMemory(EXRHeader ***exr_headers,
int *num_headers,
const EXRVersion *exr_version,
const unsigned char *memory, size_t size,
const char **... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %r9, %r15
movq %rcx, %xmm0
movq %rdi, %xmm1
punpcklqdq %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movq %rdx, %xmm0
movq %rsi, %xmm2
punpcklqdq %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0]
pxor %xmm0, %xmm0
pcmpeq... | /embree[P]embree/tutorials/common/image/tinyexr.h |
ParseEXRMultipartHeaderFromFile | int ParseEXRMultipartHeaderFromFile(EXRHeader ***exr_headers, int *num_headers,
const EXRVersion *exr_version,
const char *filename, const char **err) {
if (exr_headers == NULL || num_headers == NULL || exr_version == NULL ||
filename == NU... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %rbp
movq %rsi, %xmm0
movq %rdi, %xmm1
punpcklqdq %xmm0, %xmm1 # xmm1 = xmm1[0],xmm0[0]
movq %rcx, %xmm0
movq %rdx, %xmm2
punpcklqdq %xmm0, %xmm2 # xmm2 = xmm2[0],xmm0[0]
pxor %xmm0, %xmm0
pcmpeqd %xmm0, %xmm2
pcmpeqd %xm... | /embree[P]embree/tutorials/common/image/tinyexr.h |
tinyexr::InitSingleResolutionOffsets(tinyexr::OffsetData&, unsigned long) | static void InitSingleResolutionOffsets(OffsetData& offset_data, size_t num_blocks) {
offset_data.offsets.resize(1);
offset_data.offsets[0].resize(1);
offset_data.offsets[0][0].resize(num_blocks);
offset_data.num_x_levels = 1;
offset_data.num_y_levels = 1;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %esi
callq 0x116d46
movq (%r14), %rdi
movl $0x1, %esi
callq 0x116dc2
movq (%r14), %rax
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x7e18a
movabsq $0x100000001, %rax # imm = 0x100000001
movq %rax, 0x18(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14... | /embree[P]embree/tutorials/common/image/tinyexr.h |
tinyexr::PrecalculateTileInfo(std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&, TEXRHeader const*) | static void PrecalculateTileInfo(std::vector<int>& num_x_tiles,
std::vector<int>& num_y_tiles,
const EXRHeader* exr_header) {
int min_x = exr_header->data_window.min_x;
int max_x = exr_header->data_window.max_x;
int min_y = exr_header->data_window.min_y;
int max_y = exr_header->data_window.max_y;
int num... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl 0x8(%rdx), %ebx
movl 0xc(%rdx), %r9d
movl 0x10(%rdx), %r12d
movl 0x14(%rdx), %ebp
movl 0x44(%rdx), %ecx
movl $0x1, %r13d
testl %ecx, %ecx
movl %r9d, 0x4(%rsp)
movl %ebp, (%rsp)
je 0x10de69
cmpl $0x2, %ecx
je 0x10de2e
xorl ... | /embree[P]embree/tutorials/common/image/tinyexr.h |
tinyexr::InitTileOffsets(tinyexr::OffsetData&, TEXRHeader const*, std::vector<int, std::allocator<int>> const&, std::vector<int, std::allocator<int>> const&) | static int InitTileOffsets(OffsetData& offset_data,
const EXRHeader* exr_header,
const std::vector<int>& num_x_tiles,
const std::vector<int>& num_y_tiles) {
int num_tile_blocks = 0;
offset_data.num_x_levels = static_cast<int>(num_x_tiles.size());
offset_data.num_y_levels = static_cast<int>(num_y_tiles.size(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, 0x10(%rsp)
movq %rdi, %r15
movq 0x8(%rdx), %rax
subq (%rdx), %rax
shrq $0x2, %rax
movl %eax, 0x18(%rdi)
movq 0x8(%rcx), %rdx
movq %rcx, 0x18(%rsp)
subq (%rcx), %rdx
shrq $0x2, %rdx
movl %edx, 0x1c(%rdi)
xorl %ebp, %ebp
cmpl $0... | /embree[P]embree/tutorials/common/image/tinyexr.h |
tinyexr::DecodeChunk(TEXRImage*, TEXRHeader const*, tinyexr::OffsetData const&, unsigned char const*, unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | static int DecodeChunk(EXRImage *exr_image, const EXRHeader *exr_header,
const OffsetData& offset_data,
const unsigned char *head, const size_t size,
std::string *err) {
int num_channels = exr_header->num_channels;
int num_scanline_blocks = 1;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %r9, %r13
movq %rsi, %r14
movl 0x7c(%rsi), %eax
movl $0x10, %r15d
cmpl $0x3, %eax
je 0x10e275
cmpl $0x80, %eax
je 0x10e275
cmpl $0x4, %eax
jne 0x10e26f
movl $0x20, %r15d
jmp 0x10e275
movl $0x1, %r15d
movl 0... | /embree[P]embree/tutorials/common/image/tinyexr.h |
SaveEXRToMemory | int SaveEXRToMemory(const float *data, int width, int height, int components,
const int save_as_fp16, const unsigned char **outbuf, const char **err) {
if ((components == 1) || components == 3 || components == 4) {
// OK
} else {
std::stringstream ss;
ss << "Unsupported component value : " ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp # imm = 0x268
movl %ecx, %ebp
movl %edx, 0xc(%rsp)
movq 0x2a0(%rsp), %r12
cmpl $0x4, %ecx
ja 0x10f236
movl $0x1a, %eax
btl %ebp, %eax
jae 0x10f236
movl %r8d, %r15d
movl %esi, %ebx
movq %rdi, %r14
movq %r9, 0x90(%rsp)
leaq 0xe... | /embree[P]embree/tutorials/common/image/tinyexr.h |
SaveEXR | int SaveEXR(const float *data, int width, int height, int components,
const int save_as_fp16, const char *outfilename, const char **err) {
if ((components == 1) || components == 3 || components == 4) {
// OK
} else {
std::stringstream ss;
ss << "Unsupported component value : " << components ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp # imm = 0x258
movl %ecx, %ebp
movl %edx, 0xc(%rsp)
movq 0x290(%rsp), %r14
cmpl $0x4, %ecx
ja 0x10f814
movl $0x1a, %eax
btl %ebp, %eax
jae 0x10f814
movl %r8d, %r15d
movl %esi, %r13d
movq %rdi, %rbx
movq %r9, 0x98(%rsp)
leaq 0x... | /embree[P]embree/tutorials/common/image/tinyexr.h |
embree::loadEXR(embree::FileName const&) | Ref<Image> loadEXR(const FileName& fileName)
{
float* rgba; // width * height * RGBA
int width;
int height;
const char* err = NULL; // or nullptr in C++11
int ret = LoadEXR(&rgba, &width, &height, fileName.str().c_str(), &err);
if (ret != TINYEXR_SUCCESS) {
if (err) {
std::cerr ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r13
movq %rdi, 0x48(%rsp)
leaq 0x10(%rsp), %rbx
movq $0x0, (%rbx)
leaq 0x30(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rsi), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x621de
movq (%... | /embree[P]embree/tutorials/common/image/exr.cpp |
embree::storeEXR(embree::Ref<embree::Image> const&, embree::FileName const&) | void storeEXR(const Ref<Image>& img, const FileName& fileName)
{
std::vector<Col3f> rgb(img->width * img->height);
for (size_t y=0; y<img->height; ++y) {
for (size_t x=0; x<img->width; ++x) {
Color4 c = img->get(x, y);
rgb[y * img->width + x] = Col3f(c.r, c.g, c.b);
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x18(%rax), %rsi
imulq 0x10(%rax), %rsi
leaq 0x40(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x114e7c
movq (%r14), %rsi
cmpq $0x0, 0x18(%rsi)
je 0x10ff2a
movq %rbx, 0x38(%rsp)
xorl %ebp... | /embree[P]embree/tutorials/common/image/exr.cpp |
tinyexr::ReconstructTileOffsets(tinyexr::OffsetData&, TEXRHeader const*, unsigned char const*, unsigned char const*, unsigned long, bool, bool) | static void ReconstructTileOffsets(OffsetData& offset_data,
const EXRHeader* exr_header,
const unsigned char* head, const unsigned char* marker, const size_t /*size*/,
bool isMultiPartFile,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %r9d, -0x24(%rsp)
movq %rdx, -0x10(%rsp)
movq %rsi, -0x8(%rsp)
movq (%rdi), %r10
movq 0x8(%rdi), %rdx
cmpq %r10, %rdx
je 0x1105c2
movl 0x18(%rdi), %eax
movl %eax, -0x28(%rsp)
movzbl %r8b, %r8d
shll $0x2, %r8d
movq $0x0, -0x30(%rsp)
movq -0x30(%rsp),... | /embree[P]embree/tutorials/common/image/tinyexr.h |
tinyexr::WriteAttributeToMemory(std::vector<unsigned char, std::allocator<unsigned char>>*, char const*, char const*, unsigned char const*, int) | static void WriteAttributeToMemory(std::vector<unsigned char> *out,
const char *name, const char *type,
const unsigned char *data, int len) {
out->insert(out->end(), name, name + strlen(name) + 1);
out->insert(out->end(), type, type + strlen(type... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq 0x8(%rdi), %r13
movq %rsi, %rdi
callq 0x14390
leaq (%r12,%rax), %rcx
incq %rcx
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x11582c
movq 0x8(%r14), ... | /embree[P]embree/tutorials/common/image/tinyexr.h |
tinyexr::EncodePixelData(std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned char const* const*, int, int, int, int, int, int, int, unsigned long, std::vector<tinyexr::TChannelInfo, std::allocator<tinyexr::TChannelInfo>> const&, std::vector<unsigned long, std::allocator<unsigned long>> const&, std::__c... | static bool EncodePixelData(/* out */ std::vector<unsigned char>& out_data,
const unsigned char* const* images,
int compression_type,
int /*line_order*/,
int width, // for tiled : til... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movl %r9d, 0x18(%rsp)
movl %r8d, 0x8(%rsp)
movl %ecx, %r14d
movl %edx, 0xb8(%rsp)
movq %rsi, %r12
movq %rdi, 0xc8(%rsp)
movslq 0x180(%rsp), %rsi
movq 0x1a0(%rsp), %rbp
movq 0x190(%rsp), %rbx
movq 0x188(%rsp), %r... | /embree[P]embree/tutorials/common/image/tinyexr.h |
tinyexr::hufCanonicalCodeTable(long long*) | static void hufCanonicalCodeTable(long long hcode[HUF_ENCSIZE]) {
long long n[59];
//
// For each i from 0 through 58, count the
// number of different codes of length i, and
// store the count in n[i].
//
for (int i = 0; i <= 58; ++i) n[i] = 0;
for (int i = 0; i < HUF_ENCSIZE; ++i) n[hcode[i]] += 1;... | pushq %r14
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rdi, %rbx
movq %rsp, %rdi
xorl %r14d, %r14d
movl $0x1d8, %edx # imm = 0x1D8
xorl %esi, %esi
callq 0x14470
movq (%rbx,%r14,8), %rax
incq (%rsp,%rax,8)
incq %r14
cmpq $0x10001, %r14 # imm = 0x10001
jne 0x112442
movl $0x3b, %eax
xor... | /embree[P]embree/tutorials/common/image/tinyexr.h |
tinyexr::DecodeTiledLevel(TEXRImage*, TEXRHeader const*, tinyexr::OffsetData const&, std::vector<unsigned long, std::allocator<unsigned long>> const&, int, unsigned char const*, unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | static int DecodeTiledLevel(EXRImage* exr_image, const EXRHeader* exr_header,
const OffsetData& offset_data,
const std::vector<size_t>& channel_offset_list,
int pixel_data_size,
const unsigned char* head, const size_t size,
std::string* err) {
int num_channels = exr_header->num_channels;
int level_index ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r9, %r12
movl %r8d, 0x20(%rsp)
movq %rcx, %r15
movq %rdx, 0x28(%rsp)
movq %rsi, %rbp
movq %rdi, %rbx
movl 0x44(%rsi), %edx
movl 0x10(%rdi), %ecx
cmpl $0x2, %edx
je 0x112582
xorl %eax, %eax
cmpl $0x1, %edx
jne 0x112590
movl %ecx, %e... | /embree[P]embree/tutorials/common/image/tinyexr.h |
tinyexr::AllocateImage(int, TEXRChannelInfo const*, int const*, int, int) | static unsigned char **AllocateImage(int num_channels,
const EXRChannelInfo *channels,
const int *requested_pixel_types,
int data_width, int data_height) {
unsigned char **images =
reinterpret_cast<uns... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movl %ecx, %r12d
movq %rdx, (%rsp)
movq %rsi, %r14
movslq %edi, %r13
leaq (,%r13,8), %rdi
callq 0x14b30
movq %rax, %r15
testl %r13d, %r13d
je 0x11293c
movslq %r12d, %rax
movslq %ebp, %r12
imulq %rax, %r12
leaq (,%r12,4), %rbp
a... | /embree[P]embree/tutorials/common/image/tinyexr.h |
embree::toUpperCase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string toUpperCase(const std::string& s) { std::string dst(s); std::transform(dst.begin(), dst.end(), dst.begin(), to_upper); return dst; } | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x621de
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x117b69
movq (%rbx), %r15
xorl %r12d, %r12d
movsbl (%r15,%r12), %edi
callq 0x150e0... | /embree[P]embree/common/sys/estring.cpp |
embree::string_to_Vec3f(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | Vec3f string_to_Vec3f ( std::string str )
{
size_t next = 0;
const float x = std::stof(str,&next); str = str.substr(next+1);
const float y = std::stof(str,&next); str = str.substr(next+1);
const float z = std::stof(str,&next);
return Vec3f(x,y,z);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %r12
callq 0x14080
movq %rax, %rbx
movl (%rax), %ebp
movl $0x0, (%rax)
leaq 0x18(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x14b60
movq (%r13), %rdx
subq %r12, %rdx
je 0x117e13
movl (%... | /embree[P]embree/common/sys/estring.cpp |
embree::string_to_Vec4f(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | Vec4f string_to_Vec4f ( std::string str )
{
size_t next = 0;
const float x = std::stof(str,&next); str = str.substr(next+1);
const float y = std::stof(str,&next); str = str.substr(next+1);
const float z = std::stof(str,&next); str = str.substr(next+1);
const float w = std::stof(str,&next);
ret... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq (%rsi), %r12
callq 0x14080
movq %rax, %rbx
movl (%rax), %ebp
movl $0x0, (%rax)
leaq 0x18(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x14b60
movq (%r13), %rdx
subq %r12, %rdx
je 0x118067
movl (%... | /embree[P]embree/common/sys/estring.cpp |
spectest::JSONParser::SkipWhitespace() | void JSONParser::SkipWhitespace() {
while (1) {
switch (ReadChar()) {
case -1:
return;
case ' ':
case '\t':
case '\n':
case '\r':
break;
default:
PutbackChar();
return;
}
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c1c50
movl %eax, %ecx
movl %ecx, -0x14(%rbp)
subl $-0x1, %eax
je 0x1c1d5a
jmp 0x1c1d39
movl -0x14(%rbp), %eax
addl $-0x9, %eax
subl $0x2, %eax
jb 0x1c1d5c
jmp 0x1c1d46
movl -0x1... | /dcodeIO[P]wabt/src/tools/spectest-interp.cc |
spectest::JSONParser::ExpectKey(char const*) | wabt::Result JSONParser::ExpectKey(const char* key) {
size_t keylen = strlen(key);
size_t quoted_len = keylen + 2 + 1;
char* quoted = static_cast<char*>(alloca(quoted_len));
snprintf(quoted, quoted_len, "\"%s\"", key);
EXPECT(quoted);
EXPECT(":");
return wabt::Result::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1a6190
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
addq $0xf, %rcx
andq $-0x10, %rcx
movq... | /dcodeIO[P]wabt/src/tools/spectest-interp.cc |
spectest::JSONParser::ParseUint32(unsigned int*) | wabt::Result JSONParser::ParseUint32(uint32_t* out_int) {
uint32_t result = 0;
SkipWhitespace();
while (1) {
int c = ReadChar();
if (c >= '0' && c <= '9') {
uint32_t last_result = result;
result = result * 10 + static_cast<uint32_t>(c - '0');
if (result < last_result) {
PrintErro... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
callq 0x1c1d10
movq -0x30(%rbp), %rdi
callq 0x1c1c50
movl %eax, -0x20(%rbp)
cmpl $0x30, -0x20(%rbp)
jl 0x1c202d
cmpl $0x39, -0x20(%rbp)
jg 0x1c202d
movl -0x1c(%r... | /dcodeIO[P]wabt/src/tools/spectest-interp.cc |
spectest::JSONParser::ParseOptNameStringValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | wabt::Result JSONParser::ParseOptNameStringValue(std::string* out_string) {
out_string->clear();
if (Match("\"name\"")) {
EXPECT(":");
CHECK_RESULT(ParseString(out_string));
EXPECT(",");
}
return wabt::Result::Ok;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1a6510
movq -0x30(%rbp), %rdi
leaq 0x13f31d(%rip), %rsi # 0x3015e9
callq 0x1c1d80
testb $0x1, %al
jne 0x1c22da
jmp 0x1c2378
jmp 0x1c22dc
movq -0x30(%r... | /dcodeIO[P]wabt/src/tools/spectest-interp.cc |
spectest::JSONParser::ParseConstVector(std::vector<wabt::Type, std::allocator<wabt::Type>>*, std::vector<wabt::interp::Value, std::allocator<wabt::interp::Value>>*) | wabt::Result JSONParser::ParseConstVector(ValueTypes* out_types, Values* out_values) {
out_values->clear();
EXPECT("[");
bool first = true;
while (!Match("]")) {
if (!first) {
EXPECT(",");
}
TypedValue tv;
CHECK_RESULT(ParseConst(&tv));
out_types->push_back(tv.type);
out_values->pu... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1cc030
movq -0x60(%rbp), %rdi
leaq 0x14d75d(%rip), %rsi # 0x3114dd
callq 0x1c1e60
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %edi... | /dcodeIO[P]wabt/src/tools/spectest-interp.cc |
spectest::JSONParser::ParseCommand(std::unique_ptr<spectest::Command, std::default_delete<spectest::Command>>*) | wabt::Result JSONParser::ParseCommand(CommandPtr* out_command) {
EXPECT("{");
EXPECT_KEY("type");
if (Match("\"module\"")) {
auto command = MakeUnique<ModuleCommand>();
EXPECT(",");
CHECK_RESULT(ParseLine(&command->line));
EXPECT(",");
CHECK_RESULT(ParseOptNameStringValue(&command->name));
... | pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1a8(%rbp)
movq -0x1a8(%rbp), %rdi
leaq 0x13cfb3(%rip), %rsi # 0x30162f
callq 0x1c1e60
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %edi
callq 0x1cba60
testb $0x1, %al
j... | /dcodeIO[P]wabt/src/tools/spectest-interp.cc |
spectest::CommandRunner::CommandRunner() | CommandRunner::CommandRunner() : store_(s_features) {
auto&& spectest = registry_["spectest"];
// Initialize print functions for the spec test.
struct {
const char* name;
interp::FuncType type;
} const print_funcs[] = {
{"print", interp::FuncType{{}, {}}},
{"print_i32", interp::FuncType{{Va... | pushq %rbp
movq %rsp, %rbp
subq $0x880, %rsp # imm = 0x880
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x810(%rbp)
leaq 0x1ee09f(%rip), %rsi # 0x3b4390
callq 0x26c2f0
movq -0x810(%rbp), %rdi
addq $0xe8, %rdi
callq 0x1cce20
movq -0x810(%rbp), %rdi
addq $0x118, %rdi # imm = 0x118
call... | /dcodeIO[P]wabt/src/tools/spectest-interp.cc |
spectest::CommandRunner::OnRegisterCommand(spectest::RegisterCommand const*) | wabt::Result CommandRunner::OnRegisterCommand(const RegisterCommand* command) {
if (!command->name.empty()) {
auto instance_iter = instances_.find(command->name);
if (instance_iter == instances_.end()) {
PrintError(command->line, "unknown module in register");
return wabt::Result::Error;
}
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
addq $0x30, %rdi
callq 0x1a6610
testb $0x1, %al
jne 0x1c7910
movq -0x30(%rbp), %rdi
addq $0x118, %rdi # imm = 0x118
movq -0x18(%rbp), %rsi
addq $0x30,... | /dcodeIO[P]wabt/src/tools/spectest-interp.cc |
spectest::CommandRunner::OnAssertMalformedCommand(spectest::AssertModuleCommand<(wabt::CommandType)3> const*) | wabt::Result CommandRunner::OnAssertMalformedCommand(
const AssertMalformedCommand* command) {
wabt::Result result = ReadInvalidModule(command->line, command->filename,
command->type, "assert_malformed");
if (Succeeded(result)) {
PrintError(command->line, "expected module... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x38(%rbp)
movq -0x18(%rbp), %rsi
addq $0x18, %rsi
leaq -0x30(%rbp), %rdi
callq 0x1cbf50
movq -0x40(%rbp), %rdi
movl -0x38(%rbp)... | /dcodeIO[P]wabt/src/tools/spectest-interp.cc |
spectest::CommandRunner::OnAssertInvalidCommand(spectest::AssertModuleCommand<(wabt::CommandType)4> const*) | wabt::Result CommandRunner::OnAssertInvalidCommand(
const AssertInvalidCommand* command) {
wabt::Result result = ReadInvalidModule(command->line, command->filename,
command->type, "assert_invalid");
if (Succeeded(result)) {
PrintError(command->line, "expected module to be... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x38(%rbp)
movq -0x18(%rbp), %rsi
addq $0x18, %rsi
leaq -0x30(%rbp), %rdi
callq 0x1cbf50
movq -0x40(%rbp), %rdi
movl -0x38(%rbp)... | /dcodeIO[P]wabt/src/tools/spectest-interp.cc |
spectest::CommandRunner::OnAssertUnlinkableCommand(spectest::AssertModuleCommand<(wabt::CommandType)5> const*) | wabt::Result CommandRunner::OnAssertUnlinkableCommand(
const AssertUnlinkableCommand* command) {
Errors errors;
auto module = ReadModule(command->filename, &errors);
if (!module) {
PrintError(command->line, "unable to compile unlinkable module: \"%s\"",
command->filename.c_str());
retu... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1ce5a0
movq -0x18(%rbp), %rsi
addq $0x18, %rsi
leaq -0x58(%rbp), %rdi
callq 0x1cbf50
movq -0xd8(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq -0x50(%rbp), %rcx... | /dcodeIO[P]wabt/src/tools/spectest-interp.cc |
spectest::CommandRunner::OnAssertUninstantiableCommand(spectest::AssertModuleCommand<(wabt::CommandType)6> const*) | wabt::Result CommandRunner::OnAssertUninstantiableCommand(
const AssertUninstantiableCommand* command) {
Errors errors;
auto module = ReadModule(command->filename, &errors);
if (!module) {
PrintError(command->line, "unable to compile uninstantiable module: \"%s\"",
command->filename.c_str(... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x1ce5a0
movq -0x18(%rbp), %rsi
addq $0x18, %rsi
leaq -0x58(%rbp), %rdi
callq 0x1cbf50
movq -0xb8(%rbp), %rsi
movq -0x58(%rbp), %rdx
movq -0x50(%rbp), %rcx... | /dcodeIO[P]wabt/src/tools/spectest-interp.cc |
spectest::CommandRunner::OnAssertReturnCommand(spectest::AssertReturnCommand const*) | wabt::Result CommandRunner::OnAssertReturnCommand(
const AssertReturnCommand* command) {
ActionResult action_result =
RunAction(command->line, &command->action, RunVerbosity::Quiet);
if (action_result.trap) {
PrintError(command->line, "unexpected trap: %s",
action_result.trap->message(... | pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x120(%rbp)
movq -0x18(%rbp), %rax
movl 0xc(%rax), %edx
movq -0x18(%rbp), %rcx
addq $0x10, %rcx
leaq -0x60(%rbp), %rdi
xorl %r8d, %r8d
callq 0x1c85e0
leaq -0x60(%rbp), %... | /dcodeIO[P]wabt/src/tools/spectest-interp.cc |
spectest::CommandRunner::RunAction(int, spectest::Action const*, RunVerbosity) | ActionResult CommandRunner::RunAction(int line_number,
const Action* action,
RunVerbosity verbose) {
ExportMap& module = !action->module_name.empty()
? instances_[action->module_name]
: last... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
callq 0x1a6610
... | /dcodeIO[P]wabt/src/tools/spectest-interp.cc |
spectest::CommandRunner::ReadInvalidTextModule(wabt::string_view, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | wabt::Result CommandRunner::ReadInvalidTextModule(string_view module_filename,
const std::string& header) {
std::vector<uint8_t> file_data;
wabt::Result result = ReadFile(module_filename, &file_data);
std::unique_ptr<WastLexer> lexer = WastLexer::CreateBufferLexer(
... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1ce560
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
leaq -0x... | /dcodeIO[P]wabt/src/tools/spectest-interp.cc |
spectest::CommandRunner::ReadModule(wabt::string_view, std::vector<wabt::Error, std::allocator<wabt::Error>>*) | interp::Module::Ptr CommandRunner::ReadModule(string_view module_filename,
Errors* errors) {
std::vector<uint8_t> file_data;
if (Failed(ReadFile(module_filename, &file_data))) {
return {};
}
const bool kReadDebugNames = true;
const bool kStopOnFirstError = ... | pushq %rbp
movq %rsp, %rbp
subq $0x2f0, %rsp # imm = 0x2F0
movq %rdi, -0x2e0(%rbp)
movq %rdi, %rax
movq %rax, -0x2d8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x10(%rbp)
movq %rsi, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x2d0(%rbp)
leaq -0x40(%rbp), %rdi
cal... | /dcodeIO[P]wabt/src/tools/spectest-interp.cc |
spectest::CommandRunner::ReadInvalidModule(int, wabt::string_view, spectest::ModuleType, char const*) | wabt::Result CommandRunner::ReadInvalidModule(int line_number,
string_view module_filename,
ModuleType module_type,
const char* desc) {
std::string header = StringPrintf(
"%s:%d: %s passed", s... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdx, -0x18(%rbp)
movq %rcx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movl %esi, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
addq $0x180, %rdi # imm = 0x180
callq 0x1a6170
movq %rax, %rdx
movl -0x24(%rbp), %... | /dcodeIO[P]wabt/src/tools/spectest-interp.cc |
spectest::CommandRunner::GetImport(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&) | Extern::Ptr CommandRunner::GetImport(const std::string& module,
const std::string& name) {
auto mod_iter = registry_.find(module);
if (mod_iter != registry_.end()) {
auto extern_iter = mod_iter->second.find(name);
if (extern_iter != mod_iter->second.end()) {
return... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0xe8, %rdi
movq -0x18(%rbp), %rsi
callq 0x1cec90
movq -0x48(%rbp), %rdi... | /dcodeIO[P]wabt/src/tools/spectest-interp.cc |
spectest::CommandRunner::PopulateExports(wabt::interp::RefPtr<wabt::interp::Instance> const&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, wabt::interp::RefPtr<wabt::interp::Extern>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, st... | void CommandRunner::PopulateExports(const Instance::Ptr& instance,
ExportMap* map) {
map->clear();
interp::Module::Ptr module{store_, instance->module()};
for (size_t i = 0; i < module->export_types().size(); ++i) {
const ExportType& export_type = module->export_types()[i];... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1cf010
movq -0x10(%rbp), %rdi
callq 0x1cf030
movq %rax, %rdi
callq 0x1cf050
movq -0x70(%rbp), %rsi
movq %rax, -0x38(%rbp)
movq -0x38... | /dcodeIO[P]wabt/src/tools/spectest-interp.cc |
spectest::CommandRunner::CheckAssertReturnResult(spectest::AssertReturnCommand const*, int, spectest::ExpectedValue, wabt::interp::TypedValue, bool) | wabt::Result CommandRunner::CheckAssertReturnResult(
const AssertReturnCommand* command,
int index,
ExpectedValue expected,
TypedValue actual,
bool print_error) {
assert(expected.value.type == actual.type ||
IsReference(expected.value.type));
bool ok = true;
switch (expected.value.typ... | pushq %rbp
movq %rsp, %rbp
subq $0x270, %rsp # imm = 0x270
movl %ecx, %eax
movq %rdi, %rcx
leaq 0x48(%rbp), %rdi
movq %rdi, -0x1a0(%rbp)
leaq 0x10(%rbp), %rdi
movq %rdi, -0x1b0(%rbp)
movq %rcx, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
andb $0x1, %al
movb %al, -0x1d(%rbp)
movq -0x10(%rbp), %r... | /dcodeIO[P]wabt/src/tools/spectest-interp.cc |
spectest::ExpectedValueToString[abi:cxx11](spectest::ExpectedValue const&) | static std::string ExpectedValueToString(const ExpectedValue& ev) {
// Extend TypedValueToString to print expected nan values too.
switch (ev.value.type) {
case Type::F32:
case Type::F64:
switch (ev.nan[0]) {
case ExpectedNan::None:
return TypedValueToString(ev.value);
case ... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1cb6e0
movl %eax, %ecx
movl %ecx, -0x7c(%rbp)
subl $-0x5, %eax
je 0x1c9981
jmp 0x1c98dd
movl -0x7c(%rbp), %eax
addl $0x4, %eax
subl $0x1, ... | /dcodeIO[P]wabt/src/tools/spectest-interp.cc |
ParseOptions(int, char**) | static void ParseOptions(int argc, char** argv) {
OptionParser parser("spectest-interp", s_description);
parser.AddOption('v', "verbose", "Use multiple times for more info", []() {
s_verbose++;
s_log_stream = FileStream::CreateStderr();
});
s_features.AddOptions(&parser);
parser.AddOption('V', "value... | pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0xa0(%rbp), %rdi
leaq 0x138ab1(%rip), %rsi # 0x302591
leaq 0x1376a9(%rip), %rdx # 0x301190
callq 0x1f9250
leaq -0xc0(%rbp), %rdi
leaq -0xc1(%rbp), %rsi
callq 0x1c9eb0
leaq -0xa0(%rbp), %rdi
mov... | /dcodeIO[P]wabt/src/tools/spectest-interp.cc |
spectest::ReadAndRunSpecJSON(wabt::string_view) | static int ReadAndRunSpecJSON(string_view spec_json_filename) {
JSONParser parser;
if (parser.ReadFile(spec_json_filename) == wabt::Result::Error) {
return 1;
}
Script script;
if (parser.ParseScript(&script) == wabt::Result::Error) {
return 1;
}
CommandRunner runner;
if (runner.Run(script) == ... | pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp # imm = 0x290
movq %rdi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x1e1230
movq -0x18(%rbp), %rax
movq %rax, -0x98(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x98(%rbp), %rsi
movq -0x90(%rbp), %rdx
leaq -0x80(%rbp), %rdi
callq... | /dcodeIO[P]wabt/src/tools/spectest-interp.cc |
wabt::Type::GetName() const | const char* GetName() const {
switch (enum_) {
case Type::I32: return "i32";
case Type::I64: return "i64";
case Type::F32: return "f32";
case Type::F64: return "f64";
case Type::V128: return "v128";
case Type::I8: return "i8";
case Type::... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
addl $0x40, %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x40, %eax
ja 0x1cbe49
movq -0x18(%rbp), %rax
leaq 0x135545(%rip), %rcx # 0x3012d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x13a100(%rip), %rax ... | /dcodeIO[P]wabt/src/type.h |
wabt::StringPrintf[abi:cxx11](char const*, ...) | StringPrintf(const char* format, ...) {
va_list args;
va_list args_copy;
va_start(args, format);
va_copy(args_copy, args);
size_t len = wabt_vsnprintf(nullptr, 0, format, args) + 1; // For \0.
std::vector<char> buffer(len);
va_end(args);
wabt_vsnprintf(buffer.data(), len, format, args_copy);
va_end(a... | pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
movq %rdi, -0x160(%rbp)
movq %rdi, %r10
movq %r10, -0x138(%rbp)
testb %al, %al
je 0x1cd0a8
movaps %xmm0, -0x100(%rbp)
movaps %xmm1, -0xf0(%rbp)
movaps %xmm2, -0xe0(%rbp)
movaps %xmm3, -0xd0(%rbp)
movaps %xmm4, -0xc0(%rbp)
movaps %xmm5, -0xb0(%rbp)
mo... | /dcodeIO[P]wabt/src/common.h |
wabt::interp::RefPtr<wabt::interp::Extern>& wabt::interp::RefPtr<wabt::interp::Extern>::operator=<wabt::interp::Table>(wabt::interp::RefPtr<wabt::interp::Table> const&) | RefPtr<T>& RefPtr<T>::operator=(const RefPtr<U>& other){
obj_ = other.obj_;
store_ = other.store_;
root_index_ = store_ ? store_->CopyRoot(other.root_index_) : 0;
return *this;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
cmpq $0x0, 0x8(%rax)
je 0x1cd5d0
movq -0x18(%rbp), %rax
movq 0... | /dcodeIO[P]wabt/src/interp/interp-inl.h |
wabt::interp::RefPtr<wabt::interp::Extern>& wabt::interp::RefPtr<wabt::interp::Extern>::operator=<wabt::interp::Memory>(wabt::interp::RefPtr<wabt::interp::Memory> const&) | RefPtr<T>& RefPtr<T>::operator=(const RefPtr<U>& other){
obj_ = other.obj_;
store_ = other.store_;
root_index_ = store_ ? store_->CopyRoot(other.root_index_) : 0;
return *this;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
cmpq $0x0, 0x8(%rax)
je 0x1cd730
movq -0x18(%rbp), %rax
movq 0... | /dcodeIO[P]wabt/src/interp/interp-inl.h |
wabt::interp::RefPtr<wabt::interp::Extern>& wabt::interp::RefPtr<wabt::interp::Extern>::operator=<wabt::interp::Global>(wabt::interp::RefPtr<wabt::interp::Global> const&) | RefPtr<T>& RefPtr<T>::operator=(const RefPtr<U>& other){
obj_ = other.obj_;
store_ = other.store_;
root_index_ = store_ ? store_->CopyRoot(other.root_index_) : 0;
return *this;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
cmpq $0x0, 0x8(%rax)
je 0x1cd8c0
movq -0x18(%rbp), %rax
movq 0... | /dcodeIO[P]wabt/src/interp/interp-inl.h |
wabt::interp::RefPtr<wabt::interp::Module>::RefPtr(wabt::interp::Store&, wabt::interp::Ref) | RefPtr<T>::RefPtr(Store& store, Ref ref) {
#ifndef NDEBUG
if (!store.Is<T>(ref)) {
ObjectKind ref_kind;
if (ref == Ref::Null) {
ref_kind = ObjectKind::Null;
} else {
ref_kind = store.objects_.Get(ref.index)->kind();
}
fprintf(stderr, "Invalid conversion from Ref (%s) to RefPtr<%s>!\n",... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdx, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
callq 0x1edeb0
testb $0x1, %al
jne 0x1cf13c
movq -0x8(%rbp), %rax
movq ... | /dcodeIO[P]wabt/src/interp/interp-inl.h |
unsigned long wabt::interp::FreeList<std::unique_ptr<wabt::interp::Object, std::default_delete<wabt::interp::Object>>>::New<wabt::interp::HostFunc*>(wabt::interp::HostFunc*&&) | auto FreeList<T>::New(Args&&... args) -> Index {
if (!free_.empty()) {
Index index = free_.back();
assert(is_free_[index]);
free_.pop_back();
is_free_[index] = false;
list_[index] = T(std::forward<Args>(args)...);
return index;
}
assert(list_.size() == is_free_.size());
is_free_.push_bac... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x18, %rdi
callq 0x1d1690
testb $0x1, %al
jne 0x1d1433
movq -0x50(%rbp), %rdi
addq $0x18, %rdi
callq 0x1d16d0
movq -0x50(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x20(%rbp)
addq... | /dcodeIO[P]wabt/src/interp/interp-inl.h |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.