name string | code string | asm string | file string |
|---|---|---|---|
testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::CreateKey() | static pthread_key_t CreateKey() {
pthread_key_t key;
// When a thread exits, DeleteThreadLocalValue() will be called on
// the object managed for that thread.
GTEST_CHECK_POSIX_SUCCESS_(
pthread_key_create(&key, &DeleteThreadLocalValue));
return key;
} | subq $0x38, %rsp
leaq 0x34(%rsp), %rdi
leaq -0x40(%rip), %rsi # 0x570550
callq 0x3281f0
movl %eax, 0x30(%rsp)
cmpl $0x0, 0x30(%rsp)
je 0x570630
leaq 0x2f329b(%rip), %rdx # 0x863846
leaq 0x2c(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x3, %esi
movl $0xa3f, %ecx # imm = 0xA3F
callq 0x55b020
movq 0x8(%rsp... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest.h |
lodepng_load_file(unsigned char**, unsigned long*, char const*) | unsigned lodepng_load_file(unsigned char** out, size_t* outsize, const char* filename)
{
long size = lodepng_filesize(filename);
if (size < 0) return 78;
*outsize = (size_t)size;
*out = (unsigned char*)lodepng_malloc((size_t)size);
if(!(*out) && size > 0) return 83; /*the above malloc failed*/
return lode... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x572260
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jge 0x5721f2
movl $0x4e, 0x24(%rsp)
jmp 0x572248
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rdi
callq 0x572310
movq %rax, %rcx
movq 0x18(... | /anderslanglands[P]pbrt-v4/src/ext/lodepng/lodepng.cpp |
lodepng_buffer_file(unsigned char*, unsigned long, char const*) | static unsigned lodepng_buffer_file(unsigned char* out, size_t size, const char* filename)
{
FILE* file;
size_t readsize;
file = fopen(filename, "rb");
if(!file) return 78;
readsize = fread(out, 1, size, file);
fclose(file);
if (readsize != size) return 78;
return 0;
} | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x2e0e18(%rip), %rsi # 0x853157
callq 0x328910
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x57235b
movl $0x4e, 0x34(%rsp)
jmp 0x5723a1
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rdx
movq 0x10(%rsp), %rcx
m... | /anderslanglands[P]pbrt-v4/src/ext/lodepng/lodepng.cpp |
lodepng_inflate(unsigned char**, unsigned long*, unsigned char const*, unsigned long, LodePNGDecompressSettings const*) | unsigned lodepng_inflate(unsigned char** out, size_t* outsize,
const unsigned char* in, size_t insize,
const LodePNGDecompressSettings* settings)
{
unsigned error;
ucvector v;
ucvector_init_buffer(&v, *out, *outsize);
error = lodepng_inflatev(&v, in, insize, set... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rsi
movq 0x38(%rsp), %rax
movq (%rax), %rdx
movq %rsp, %rdi
callq 0x572f80
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq %rsp, %rdi
c... | /anderslanglands[P]pbrt-v4/src/ext/lodepng/lodepng.cpp |
lodepng_zlib_compress(unsigned char**, unsigned long*, unsigned char const*, unsigned long, LodePNGCompressSettings const*) | unsigned lodepng_zlib_compress(unsigned char** out, size_t* outsize, const unsigned char* in,
size_t insize, const LodePNGCompressSettings* settings)
{
/*initially, *out must be NULL and outsize 0, if you just give some random *out
that's pointing to a non allocated buffer, this'll cr... | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movl $0x78, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0x14(%rsp), %eax
shll $0x8, %eax
movl 0xc(%rsp), %ecx
shll $0x5, %ecx
addl %ecx... | /anderslanglands[P]pbrt-v4/src/ext/lodepng/lodepng.cpp |
lodepng_color_mode_copy(LodePNGColorMode*, LodePNGColorMode const*) | unsigned lodepng_color_mode_copy(LodePNGColorMode* dest, const LodePNGColorMode* source)
{
size_t i;
lodepng_color_mode_cleanup(dest);
*dest = *source;
if(source->palette)
{
dest->palette = (unsigned char*)lodepng_malloc(1024);
if(!dest->palette && source->palettesize) return 83; /*alloc fail*/
fo... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x5740e0
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdi
movl $0x28, %edx
callq 0x327170
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x5741f8
movl $0x400, %edi # imm = 0x400
callq 0x572310
movq %rax, %rcx
movq 0x18(%rsp), ... | /anderslanglands[P]pbrt-v4/src/ext/lodepng/lodepng.cpp |
getNumColorChannels(LodePNGColorType) | static unsigned getNumColorChannels(LodePNGColorType colortype)
{
switch(colortype)
{
case 0: return 1; /*grey*/
case 2: return 3; /*RGB*/
case 3: return 1; /*palette*/
case 4: return 2; /*grey + alpha*/
case 6: return 4; /*RGBA*/
}
return 0; /*unexisting color type*/
} | movl %edi, -0x8(%rsp)
movl -0x8(%rsp), %eax
movq %rax, -0x10(%rsp)
subq $0x6, %rax
ja 0x5743ca
movq -0x10(%rsp), %rax
leaq 0x2f0091(%rip), %rcx # 0x864420
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, -0x4(%rsp)
jmp 0x5743d2
movl $0x3, -0x4(%rsp)
jmp 0x5743d2
movl $0x1, -0x4(%rsp)
jmp 0x5743d2
mov... | /anderslanglands[P]pbrt-v4/src/ext/lodepng/lodepng.cpp |
lodepng_add_text(LodePNGInfo*, char const*, char const*) | unsigned lodepng_add_text(LodePNGInfo* info, const char* key, const char* str)
{
char** new_keys = (char**)(lodepng_realloc(info->text_keys, sizeof(char*) * (info->text_num + 1)));
char** new_strings = (char**)(lodepng_realloc(info->text_strings, sizeof(char*) * (info->text_num + 1)));
if(!new_keys || !new_string... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq 0x50(%rax), %rdi
movq 0x28(%rsp), %rax
movq 0x48(%rax), %rsi
addq $0x1, %rsi
shlq $0x3, %rsi
callq 0x573ed0
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x58(%rax), %rdi
movq 0x28(%rsp), %rax
movq 0x48(%rax... | /anderslanglands[P]pbrt-v4/src/ext/lodepng/lodepng.cpp |
LodePNGUnknownChunks_copy(LodePNGInfo*, LodePNGInfo const*) | static unsigned LodePNGUnknownChunks_copy(LodePNGInfo* dest, const LodePNGInfo* src)
{
unsigned i;
LodePNGUnknownChunks_cleanup(dest);
for(i = 0; i != 3; ++i)
{
size_t j;
dest->unknown_chunks_size[i] = src->unknown_chunks_size[i];
dest->unknown_chunks_data[i] = (unsigned char*)lodepng_malloc(src->... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x574dd0
movl $0x0, 0xc(%rsp)
cmpl $0x3, 0xc(%rsp)
je 0x5751e8
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
movq 0xd0(%rax,%rcx,8), %rdx
movq 0x18(%rsp), %rax
movl 0xc(%rsp), %ecx
movq %rdx, 0xd0(%rax,%rcx,8)
movq 0x10(%rsp), %rax
mo... | /anderslanglands[P]pbrt-v4/src/ext/lodepng/lodepng.cpp |
lodepng_color_mode_equal(LodePNGColorMode const*, LodePNGColorMode const*) | static int lodepng_color_mode_equal(const LodePNGColorMode* a, const LodePNGColorMode* b)
{
size_t i;
if(a->colortype != b->colortype) return 0;
if(a->bitdepth != b->bitdepth) return 0;
if(a->key_defined != b->key_defined) return 0;
if(a->key_defined)
{
if(a->key_r != b->key_r) return 0;
if(a->key_g... | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movl (%rax), %eax
movq -0x18(%rsp), %rcx
cmpl (%rcx), %eax
je 0x575747
movl $0x0, -0x4(%rsp)
jmp 0x575879
movq -0x10(%rsp), %rax
movl 0x4(%rax), %eax
movq -0x18(%rsp), %rcx
cmpl 0x4(%rcx), %eax
je 0x575766
movl $0x0, -0x4(%rsp)
jmp 0x575879
movq -0x10... | /anderslanglands[P]pbrt-v4/src/ext/lodepng/lodepng.cpp |
getPixelColorRGBA16(unsigned short*, unsigned short*, unsigned short*, unsigned short*, unsigned char const*, unsigned long, LodePNGColorMode const*) | static void getPixelColorRGBA16(unsigned short* r, unsigned short* g, unsigned short* b, unsigned short* a,
const unsigned char* in, size_t i, const LodePNGColorMode* mode)
{
if(mode->colortype == LCT_GREY)
{
*r = *g = *b = 256 * in[i * 2 + 0] + in[i * 2 + 1];
if(mode->key_de... | movq 0x8(%rsp), %rax
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq %r8, -0x28(%rsp)
movq %r9, -0x30(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x575a9c
movq -0x28(%rsp), %rax
movq -0x30(%rsp), %rcx
shlq %rcx
movzbl (%rax,%rcx), %eax
shll $0x8, %eax
movq -0x28(%rsp... | /anderslanglands[P]pbrt-v4/src/ext/lodepng/lodepng.cpp |
getPixelColorsRGBA8(unsigned char*, unsigned long, unsigned int, unsigned char const*, LodePNGColorMode const*) | static void getPixelColorsRGBA8(unsigned char* buffer, size_t numpixels,
unsigned has_alpha, const unsigned char* in,
const LodePNGColorMode* mode)
{
unsigned num_channels = has_alpha ? 4 : 3;
size_t i;
if(mode->colortype == LCT_GREY)
{
if(mode... | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movl 0x54(%rsp), %edx
movl $0x3, %eax
movl $0x4, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, 0x3c(%rsp)
movq 0x40(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x576374
movq 0x40(%rsp), %rax
cmpl $0x... | /anderslanglands[P]pbrt-v4/src/ext/lodepng/lodepng.cpp |
lodepng_get_color_profile(LodePNGColorProfile*, unsigned char const*, unsigned int, unsigned int, LodePNGColorMode const*) | unsigned lodepng_get_color_profile(LodePNGColorProfile* profile,
const unsigned char* in, unsigned w, unsigned h,
const LodePNGColorMode* mode)
{
unsigned error = 0;
size_t i;
ColorTree tree;
size_t numpixels = w * h;
unsigned colored_done... | subq $0x128, %rsp # imm = 0x128
movq %rdi, 0x120(%rsp)
movq %rsi, 0x118(%rsp)
movl %edx, 0x114(%rsp)
movl %ecx, 0x110(%rsp)
movq %r8, 0x108(%rsp)
movl $0x0, 0x104(%rsp)
movl 0x114(%rsp), %eax
imull 0x110(%rsp), %eax
movl %eax, %eax
movq %rax, 0x68(%rsp)
movq 0x108(%rsp), %rdi
callq 0x5743e0
movl %eax, %edx
x... | /anderslanglands[P]pbrt-v4/src/ext/lodepng/lodepng.cpp |
lodepng_inspect(unsigned int*, unsigned int*, LodePNGState*, unsigned char const*, unsigned long) | unsigned lodepng_inspect(unsigned* w, unsigned* h, LodePNGState* state,
const unsigned char* in, size_t insize)
{
LodePNGInfo* info = &state->info_png;
if(insize == 0 || in == 0)
{
CERROR_RETURN_ERROR(state->error, 48); /*error: the given data is empty*/
}
if(insize < 33)
{
... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq 0x28(%rsp), %rax
addq $0xb8, %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x5785bd
cmpq $0x0, 0x20(%rsp)
jne 0x5785d9
movq 0x28(%rsp), %rax
movl $0x30, 0x1a0(%rax)
movl $0x30, 0x44(%... | /anderslanglands[P]pbrt-v4/src/ext/lodepng/lodepng.cpp |
addChunk_IDAT(ucvector*, unsigned char const*, unsigned long, LodePNGCompressSettings*) | static unsigned addChunk_IDAT(ucvector* out, const unsigned char* data, size_t datasize,
LodePNGCompressSettings* zlibsettings)
{
ucvector zlibdata;
unsigned error = 0;
/*compress with the Zlib compressor*/
ucvector_init(&zlibdata);
error = zlib_compress(&zlibdata.data, &zlibdat... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movl $0x0, 0xc(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x57abc0
leaq 0x10(%rsp), %rdi
leaq 0x10(%rsp), %rsi
addq $0x8, %rsi
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
callq 0x57c700
movl %eax, 0xc(%r... | /anderslanglands[P]pbrt-v4/src/ext/lodepng/lodepng.cpp |
addChunk_tEXt(ucvector*, char const*, char const*) | static unsigned addChunk_tEXt(ucvector* out, const char* keyword, const char* textstring)
{
unsigned error = 0;
size_t i;
ucvector text;
ucvector_init(&text);
for(i = 0; keyword[i] != 0; ++i) ucvector_push_back(&text, (unsigned char)keyword[i]);
if(i < 1 || i > 79) return 89; /*error: invalid keyword size*/... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movq %rsp, %rdi
callq 0x57abc0
movq $0x0, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x18(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x57b785
movq 0x30(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rsp, %rdi
movzb... | /anderslanglands[P]pbrt-v4/src/ext/lodepng/lodepng.cpp |
lodepng::encode(std::vector<unsigned char, std::allocator<unsigned char>>&, unsigned char const*, unsigned int, unsigned int, lodepng::State&) | unsigned encode(std::vector<unsigned char>& out,
const unsigned char* in, unsigned w, unsigned h,
State& state)
{
unsigned char* buffer;
size_t buffersize;
unsigned error = lodepng_encode(&buffer, &buffersize, in, w, h, &state);
if(buffer)
{
out.insert(out.end(), &buffer[0]... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movl %ecx, 0x40(%rsp)
movq %r8, 0x38(%rsp)
movq 0x48(%rsp), %rdx
movl 0x44(%rsp), %ecx
movl 0x40(%rsp), %r8d
movq 0x38(%rsp), %r9
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x579d30
movl %eax, 0x24(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0... | /anderslanglands[P]pbrt-v4/src/ext/lodepng/lodepng.cpp |
readChunk_iTXt(LodePNGInfo*, LodePNGDecompressSettings const*, unsigned char const*, unsigned long) | static unsigned readChunk_iTXt(LodePNGInfo* info, const LodePNGDecompressSettings* zlibsettings,
const unsigned char* data, size_t chunkLength)
{
unsigned error = 0;
unsigned i;
unsigned length, begin, compressed;
char *key = 0, *langtag = 0, *transkey = 0;
ucvector decoded;
... | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movl $0x0, 0x54(%rsp)
movq $0x0, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movq $0x0, 0x28(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x57abc0
cmpl $0x0, 0x54(%rsp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x582148
jmp 0x582576
... | /anderslanglands[P]pbrt-v4/src/ext/lodepng/lodepng.cpp |
readChunk_tIME(LodePNGInfo*, unsigned char const*, unsigned long) | static unsigned readChunk_tIME(LodePNGInfo* info, const unsigned char* data, size_t chunkLength)
{
if(chunkLength != 7) return 73; /*invalid tIME chunk size*/
info->time_defined = 1;
info->time.year = 256u * data[0] + data[1];
info->time.month = data[2];
info->time.day = data[3];
info->time.hour = data[4];... | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
cmpq $0x7, -0x20(%rsp)
je 0x5825d4
movl $0x49, -0x4(%rsp)
jmp 0x582670
movq -0x10(%rsp), %rax
movl $0x1, 0x88(%rax)
movq -0x18(%rsp), %rax
movzbl (%rax), %ecx
shll $0x8, %ecx
movq -0x18(%rsp), %rax
movzbl 0x1(%rax), %eax
addl %eax, %ecx
movq -0x10(%rs... | /anderslanglands[P]pbrt-v4/src/ext/lodepng/lodepng.cpp |
addPaddingBits(unsigned char*, unsigned char const*, unsigned long, unsigned long, unsigned int) | static void addPaddingBits(unsigned char* out, const unsigned char* in,
size_t olinebits, size_t ilinebits, unsigned h)
{
/*The opposite of the removePaddingBits function
olinebits must be >= ilinebits*/
unsigned y;
size_t diff = olinebits - ilinebits;
size_t obp = 0, ibp = 0; /*bit... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movl %r8d, 0x34(%rsp)
movq 0x40(%rsp), %rax
subq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movl $0x0, 0x30(%rsp)
movl 0x30(%rsp), %eax
cmpl 0x34(%rsp), %eax
je 0x583ac8
movq ... | /anderslanglands[P]pbrt-v4/src/ext/lodepng/lodepng.cpp |
ply_read_header_magic(t_ply_*) | static int ply_read_header_magic(p_ply ply) {
char *magic = ply->buffer;
if (!BREFILL(ply)) {
ply->error_cb(ply, "Unable to read magic number from file");
return 0;
}
/* check if it is ply */
if (magic[0] != 'p' || magic[1] != 'l' || magic[2] != 'y' ||
!isspace(magic[3])) {
... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
addq $0x4c, %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x587220
cmpl $0x0, %eax
jne 0x586a1d
movq 0x18(%rsp), %rax
movq 0x20e0(%rax), %rax
movq 0x18(%rsp), %rdi
leaq 0x2df024(%rip), %rsi # 0x865a32
callq *%rax
movl $0x0, 0x24(%rsp)
jmp 0x586ad4... | /anderslanglands[P]pbrt-v4/src/ext/rply/rply.cpp |
ply_write_header(t_ply_*) | int ply_write_header(p_ply ply) {
long i, j;
assert(ply && ply->fp && ply->io_mode == PLY_WRITE);
assert(ply->element || ply->nelements == 0);
assert(!ply->element || ply->nelements > 0);
if (fprintf(ply->fp, "ply\nformat %s 1.0\n",
ply_storage_mode_list[ply->storage_mode]) <= 0)
... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x38(%rax), %rdi
movq 0x28(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, %ecx
leaq 0x2e85edd(%rip), %rax # 0x340de50
movq (%rax,%rcx,8), %rdx
leaq 0x2dd9f9(%rip), %rsi # 0x865977
movb $0x0, %al
callq 0x327460
cmpl $0x0, %eax
jg 0x587f8f
jmp 0x5881ec
m... | /anderslanglands[P]pbrt-v4/src/ext/rply/rply.cpp |
ply_read_scalar_property(t_ply_*, t_ply_element_*, t_ply_property_*, t_ply_argument_*) | static int ply_read_scalar_property(p_ply ply, p_ply_element element,
p_ply_property property,
p_ply_argument argument) {
p_ply_read_cb read_cb = property->read_cb;
p_ply_ihandler *driver = ply->idriver->ihandler;
p_ply_ihandler handler... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq 0x110(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq 0x2068(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movl 0x100(%rcx), %ecx
movq (%rax,%r... | /anderslanglands[P]pbrt-v4/src/ext/rply/rply.cpp |
ply_property_init(t_ply_property_*) | static void ply_property_init(p_ply_property property) {
property->name[0] = '\0';
property->type = (e_ply_type)-1;
property->length_type = (e_ply_type)-1;
property->value_type = (e_ply_type)-1;
property->read_cb = (p_ply_read_cb)NULL;
property->pdata = NULL;
property->idata = 0;
} | movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movb $0x0, (%rax)
movq -0x8(%rsp), %rax
movl $0xffffffff, 0x100(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rsp), %rax
movl $0xffffffff, 0x108(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rsp), %rax
movl $0xffffffff, 0x104(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rsp), %rax
movq $0x0, 0x110(%rax)
... | /anderslanglands[P]pbrt-v4/src/ext/rply/rply.cpp |
ply_reverse(void*, unsigned long) | static void ply_reverse(void *anydata, size_t size) {
char *data = (char *)anydata;
char temp;
size_t i;
for (i = 0; i < size / 2; i++) {
temp = data[i];
data[i] = data[size - i - 1];
data[size - i - 1] = temp;
}
} | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movq $0x0, -0x28(%rsp)
movq -0x28(%rsp), %rax
movq -0x10(%rsp), %rcx
shrq %rcx
cmpq %rcx, %rax
jae 0x589d0d
movq -0x18(%rsp), %rax
movq -0x28(%rsp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x19(%rsp)
movq -0x18(%rsp), %rax
movq -0x1... | /anderslanglands[P]pbrt-v4/src/ext/rply/rply.cpp |
ply_read_header_property(t_ply_*) | static int ply_read_header_property(p_ply ply) {
p_ply_element element = NULL;
p_ply_property property = NULL;
/* make sure it is a property */
if (strcmp(BWORD(ply), "property")) return 0;
element = &ply->element[ply->nelements - 1];
property = ply_grow_property(ply, element);
if (!property... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x18(%rsp), %rdi
addq $0x4c, %rdi
movq 0x18(%rsp), %rax
addq 0x2058(%rax), %rdi
leaq 0x2dbc3f(%rip), %rsi # 0x865bd6
callq 0x3280f0
cmpl $0x0, %eax
je 0x589fae
movl $0x0, 0x24(%rsp)
jmp 0x58a195
movq 0x18(%rsp), %rax
movq 0x8(%rax... | /anderslanglands[P]pbrt-v4/src/ext/rply/rply.cpp |
pbrt::RealisticCamera::Create(pbrt::ParameterDictionary const&, pbrt::CameraTransform const&, pbrt::FilmHandle, pbrt::MediumHandle, pbrt::FileLoc const*, pstd::pmr::polymorphic_allocator<std::byte>) | RealisticCamera *RealisticCamera::Create(const ParameterDictionary ¶meters,
const CameraTransform &cameraTransform,
FilmHandle film, MediumHandle medium,
const FileLoc *loc, Allocator alloc) {
... | subq $0x15a8, %rsp # imm = 0x15A8
movq %rdx, 0x358(%rsp)
movq %rsi, %rax
movq 0x358(%rsp), %rsi
movq %rcx, 0x360(%rsp)
movq %r9, 0x1598(%rsp)
movq %rdi, 0x1590(%rsp)
movq %rax, 0x1588(%rsp)
movq %rsi, 0x1580(%rsp)
movq %rcx, 0x1578(%rsp)
movq %r8, 0x1570(%rsp)
movq 0x1588(%rsp), %rax
movq %rax, 0x368(%rsp)
le... | /anderslanglands[P]pbrt-v4/src/pbrt/cameras.cpp |
pbrt::RealisticCamera::BoundExitPupil(float, float) const | Bounds2f RealisticCamera::BoundExitPupil(Float filmX0, Float filmX1) const {
Bounds2f pupilBounds;
// Sample a collection of points on the rear lens to find exit pupil
const int nSamples = 1024 * 1024;
int nExitingRays = 0;
// Compute bounding box of projection of rear element on sampling plane
... | subq $0x138, %rsp # imm = 0x138
movq %rdi, 0x120(%rsp)
vmovss %xmm0, 0x11c(%rsp)
vmovss %xmm1, 0x118(%rsp)
movq 0x120(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x108(%rsp), %rdi
callq 0x59dc00
movq 0x28(%rsp), %rdi
movl $0x100000, 0x104(%rsp) # imm = 0x100000
movl $0x0, 0x100(%rsp)
callq 0x59f9d0
vmovss %xmm0, ... | /anderslanglands[P]pbrt-v4/src/pbrt/cameras.cpp |
pbrt::SampledWavelengths::SampleXYZ(float) | SampleXYZ(Float u) {
SampledWavelengths swl;
for (int i = 0; i < NSpectrumSamples; ++i) {
// Compute _up_ for $i$th wavelength sample
Float up = u + Float(i) / NSpectrumSamples;
if (up > 1)
up -= 1;
swl.lambda[i] = SampleXYZMatching(up);
... | subq $0x28, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
vmovss %xmm0, 0x24(%rsp)
callq 0x5a11f0
movl $0x0, 0x20(%rsp)
cmpl $0x4, 0x20(%rsp)
jge 0x59d2f0
vmovss 0x24(%rsp), %xmm0
vcvtsi2ssl 0x20(%rsp), %xmm1, %xmm1
vmovss 0x2b1175(%rip), %xmm2 # 0x84e3b8
vdivss %xmm2, %xmm1, %xmm1
vaddss %xmm1, %xm... | /anderslanglands[P]pbrt-v4/src/pbrt/util/spectrum.h |
void pbrt::detail::stringPrintfRecursive<pbrt::FilmHandle const&, char const*, pbrt::Vector3<float> const&, pbrt::Vector3<float> const&, pbrt::Vector3<float> const&, pbrt::Vector3<float> const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, pbrt::FilmHandle const&, char c... | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x268, %rsp # imm = 0x268
movq 0x278(%rsp), %rax
movq 0x270(%rsp), %rax
movq %rdi, 0x260(%rsp)
movq %rsi, 0x258(%rsp)
movq %rdx, 0x250(%rsp)
movq %rcx, 0x248(%rsp)
movq %r8, 0x240(%rsp)
movq %r9, 0x238(%rsp)
movq 0x260(%rsp), %rdx
leaq 0x218(%rsp), %rdi
leaq 0x258(%rsp), %rsi
callq 0x4ccc90
leaq 0x218(... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<pbrt::Transform const&, pbrt::Transform const&, pbrt::Transform const&, pbrt::Transform const&, float const&, float const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, pbrt::Transform const&, pbrt::Transform const&, pbrt::Transfo... | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x268, %rsp # imm = 0x268
movq 0x278(%rsp), %rax
movq 0x270(%rsp), %rax
movq %rdi, 0x260(%rsp)
movq %rsi, 0x258(%rsp)
movq %rdx, 0x250(%rsp)
movq %rcx, 0x248(%rsp)
movq %r8, 0x240(%rsp)
movq %r9, 0x238(%rsp)
movq 0x260(%rsp), %rdx
leaq 0x218(%rsp), %rdi
leaq 0x258(%rsp), %rsi
callq 0x4ccc90
leaq 0x218(... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<char const (&) [25], char const (&) [6], unsigned long&, char const (&) [25], unsigned long&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [25], char const (&) [6], unsigned long&, char const (&) [25], unsigned long... | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x268, %rsp # imm = 0x268
movq 0x270(%rsp), %rax
movq %rdi, 0x260(%rsp)
movq %rsi, 0x258(%rsp)
movq %rdx, 0x250(%rsp)
movq %rcx, 0x248(%rsp)
movq %r8, 0x240(%rsp)
movq %r9, 0x238(%rsp)
movq 0x260(%rsp), %rdx
leaq 0x218(%rsp), %rdi
leaq 0x258(%rsp), %rsi
callq 0x4ccc90
leaq 0x218(%rsp), %rdi
movl $0x2a,... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<char const (&) [2], char const (&) [19], int&, char const (&) [2], int&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [2], char const (&) [19], int&, char const (&) [2], int&) | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x268, %rsp # imm = 0x268
movq 0x270(%rsp), %rax
movq %rdi, 0x260(%rsp)
movq %rsi, 0x258(%rsp)
movq %rdx, 0x250(%rsp)
movq %rcx, 0x248(%rsp)
movq %r8, 0x240(%rsp)
movq %r9, 0x238(%rsp)
movq 0x260(%rsp), %rdx
leaq 0x218(%rsp), %rdi
leaq 0x258(%rsp), %rsi
callq 0x4ccc90
leaq 0x218(%rsp), %rdi
movl $0x2a,... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<int&, char const (&) [17], int&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, int&, char const (&) [17], int&) | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x288, %rsp # imm = 0x288
movq %rdi, 0x280(%rsp)
movq %rsi, 0x278(%rsp)
movq %rdx, 0x270(%rsp)
movq %rcx, 0x268(%rsp)
movq %r8, 0x260(%rsp)
movq 0x280(%rsp), %rdx
leaq 0x240(%rsp), %rdi
leaq 0x278(%rsp), %rsi
callq 0x4ccc90
leaq 0x240(%rsp), %rdi
movl $0x2a, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
auto pbrt::detail::DispatchSplit<5>::operator()<pbrt::FilterHandle::Integral() const::'lambda'(auto), pbrt::TaggedPointer<pbrt::BoxFilter, pbrt::GaussianFilter, pbrt::MitchellFilter, pbrt::LanczosSincFilter, pbrt::TriangleFilter>, pbrt::BoxFilter, pbrt::GaussianFilter, pbrt::MitchellFilter, pbrt::LanczosSincFilter, pbr... | PBRT_CPU_GPU inline auto operator()(F func, Tp tp, int tag, TypePack<Ts...> types) {
constexpr int mid = n / 2;
if (tag - 1 < mid) // 0-based indexing here to be more traditional
return DispatchSplit<mid>()(
func, tp, tag, typename TakeFirstN<mid, TypePack<Ts...>>::type());... | subq $0x58, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movl %edx, 0x3c(%rsp)
movl $0x2, 0x38(%rsp)
movl 0x3c(%rsp), %eax
subl $0x1, %eax
cmpl $0x2, %eax
jge 0x5bbcd5
movq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x41cb10
movl 0x3c(%rsp), %edx
leaq 0x37(%rsp), %rdi
leaq 0x28(%rsp), %rsi
cal... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
pbrt::RGBFilm::GetPixelRGB(pbrt::Point2<int> const&, float) const | PBRT_CPU_GPU
RGB GetPixelRGB(const Point2i &p, Float splatScale = 1) const {
const Pixel &pixel = pixels[p];
RGB rgb(pixel.rgbSum[0], pixel.rgbSum[1], pixel.rgbSum[2]);
// Normalize _rgb_ with weight sum
Float weightSum = pixel.weightSum;
if (weightSum != 0)
rgb /... | subq $0x88, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
vmovss %xmm0, 0x64(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x88, %rdi
movq 0x68(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rsi
callq 0x5c1740
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
vmovsd (%rax), %xmm1
vcvtsd2ss... | /anderslanglands[P]pbrt-v4/src/pbrt/film.h |
pbrt::SurfaceInteraction::ToString[abi:cxx11]() const | std::string SurfaceInteraction::ToString() const {
return StringPrintf(
"[ SurfaceInteraction pi: %s n: %s uv: %s wo: %s time: %s "
"medium: %s mediumInterface: %s dpdu: %s dpdv: %s dndu: %s dndv: %s "
"shading.n: %s shading.dpdu: %s shading.dpdv: %s "
"shading.dndu: %s shading.dndv:... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp # imm = 0x238
movq %rdi, 0x128(%rsp)
movq %rdi, %rax
movq %rax, 0x130(%rsp)
movq %rdi, 0x230(%rsp)
movq %rsi, 0x228(%rsp)
movq 0x228(%rsp), %rdi
movq %rdi, 0x138(%rsp)
movq %rdi, %rax
addq $0x28, %rax
movq %rax, 0x140(%rsp)
m... | /anderslanglands[P]pbrt-v4/src/pbrt/interaction.cpp |
auto pbrt::detail::DispatchSplit<11>::operator()<pbrt::MaterialHandle::GetDisplacement() const::'lambda'(auto), pbrt::TaggedPointer<pbrt::CoatedDiffuseMaterial, pbrt::CoatedConductorMaterial, pbrt::ConductorMaterial, pbrt::DielectricMaterial, pbrt::DiffuseMaterial, pbrt::DiffuseTransmissionMaterial, pbrt::HairMaterial,... | PBRT_CPU_GPU inline auto operator()(F func, Tp tp, int tag, TypePack<Ts...> types) {
constexpr int mid = n / 2;
if (tag - 1 < mid) // 0-based indexing here to be more traditional
return DispatchSplit<mid>()(
func, tp, tag, typename TakeFirstN<mid, TypePack<Ts...>>::type());... | subq $0x68, %rsp
movq %rdx, (%rsp)
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movl %ecx, 0x44(%rsp)
movl $0x5, 0x40(%rsp)
movl 0x44(%rsp), %eax
subl $0x1, %eax
cmpl $0x5, %eax
jge 0x5cf354
movq (%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x3... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
pbrt::ReverseBits32(unsigned int) | PBRT_CPU_GPU
inline uint32_t ReverseBits32(uint32_t n) {
#ifdef PBRT_IS_GPU_CODE
return __brev(n);
#else
n = (n << 16) | (n >> 16);
n = ((n & 0x00ff00ff) << 8) | ((n & 0xff00ff00) >> 8);
n = ((n & 0x0f0f0f0f) << 4) | ((n & 0xf0f0f0f0) >> 4);
n = ((n & 0x33333333) << 2) | ((n & 0xcccccccc) >> 2);
... | movl %edi, -0x4(%rsp)
movl -0x4(%rsp), %eax
shll $0x10, %eax
movl -0x4(%rsp), %ecx
shrl $0x10, %ecx
orl %ecx, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
andl $0xff00ff, %eax # imm = 0xFF00FF
shll $0x8, %eax
movl -0x4(%rsp), %ecx
andl $0xff00ff00, %ecx # imm = 0xFF00FF00
shrl $0x8, %ecx
orl %ecx, %ea... | /anderslanglands[P]pbrt-v4/src/pbrt/util/bits.h |
void pbrt::LogFatal<char const (&) [10], char const (&) [17], char const (&) [10], int&, char const (&) [17], int&>(pbrt::LogLevel, char const*, int, char const*, char const (&) [10], char const (&) [17], char const (&) [10], int&, char const (&) [17], int&) | inline void LogFatal(LogLevel level, const char *file, int line, const char *fmt,
Args &&... args) {
#ifdef PBRT_IS_GPU_CODE
LogFatal(level, file, line, fmt); // just the format string #yolo
#else
std::string s = StringPrintf(fmt, std::forward<Args>(args)...);
LogFatal(level, file, lin... | subq $0x88, %rsp
movq 0xa8(%rsp), %rax
movq 0xa0(%rsp), %rax
movq 0x98(%rsp), %rax
movq 0x90(%rsp), %rax
movl %edi, 0x84(%rsp)
movq %rsi, 0x78(%rsp)
movl %edx, 0x74(%rsp)
movq %rcx, 0x68(%rsp)
movq %r8, 0x60(%rsp)
movq %r9, 0x58(%rsp)
movq 0x68(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq 0x58(%rsp), %rcx
movq 0x90(%rsp), %r... | /anderslanglands[P]pbrt-v4/src/pbrt/util/log.h |
auto pbrt::detail::DispatchSplit<4>::operator()<pbrt::SamplerHandle::Get2D()::'lambda'(auto), pbrt::TaggedPointer<pbrt::HaltonSampler, pbrt::PaddedSobolSampler, pbrt::PMJ02BNSampler, pbrt::RandomSampler, pbrt::SobolSampler, pbrt::StratifiedSampler, pbrt::MLTSampler, pbrt::DebugMLTSampler>, pbrt::HaltonSampler, pbrt::Pa... | PBRT_CPU_GPU inline auto operator()(F func, Tp tp, int tag, TypePack<Ts...> types) {
constexpr int mid = n / 2;
if (tag - 1 < mid) // 0-based indexing here to be more traditional
return DispatchSplit<mid>()(
func, tp, tag, typename TakeFirstN<mid, TypePack<Ts...>>::type());... | subq $0x68, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movl $0x2, 0x40(%rsp)
movl 0x44(%rsp), %eax
subl $0x1, %eax
cmpl $0x2, %eax
jge 0x5d2d6a
movq 0x10(%rsp), %rsi
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x420fb0
movq 0x8(%rsp), %rsi
movl 0x44(%rsp), %edx
lea... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
pbrt::HaltonSampler::Get2D() | PBRT_CPU_GPU
Point2f Get2D() {
if (dimension == 0) {
dimension += 2;
return haltonPixelIndexer.SampleFirst2D();
} else {
if (dimension + 1 >= PrimeTableSize)
dimension = 2;
int dim = dimension;
dimension += 2;
r... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpl $0x0, 0x44(%rax)
jne 0x5d309b
movq 0x28(%rsp), %rdi
movl 0x44(%rdi), %eax
addl $0x2, %eax
movl %eax, 0x44(%rdi)
addq $0x10, %rdi
callq 0x5d3180
vmovlpd %xmm0, 0x40(%rsp)
jmp 0x5d316d
movq 0x28(%rsp), %rax
movl 0x44(%rax), %eax
addl ... | /anderslanglands[P]pbrt-v4/src/pbrt/samplers.h |
auto pbrt::detail::DispatchSplit<2>::operator()<pbrt::SamplerHandle::Get2D()::'lambda'(auto), pbrt::TaggedPointer<pbrt::HaltonSampler, pbrt::PaddedSobolSampler, pbrt::PMJ02BNSampler, pbrt::RandomSampler, pbrt::SobolSampler, pbrt::StratifiedSampler, pbrt::MLTSampler, pbrt::DebugMLTSampler>, pbrt::MLTSampler, pbrt::Debug... | PBRT_CPU_GPU inline auto operator()(F func, Tp tp, int tag, TypePack<Ts...> types) {
constexpr int mid = n / 2;
if (tag - 1 < mid) // 0-based indexing here to be more traditional
return DispatchSplit<mid>()(
func, tp, tag, typename TakeFirstN<mid, TypePack<Ts...>>::type());... | subq $0x68, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movl $0x1, 0x40(%rsp)
movl 0x44(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x5d39da
movq 0x10(%rsp), %rsi
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x420fb0
movq 0x8(%rsp), %rsi
movl 0x44(%rsp), %edx
lea... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
pbrt::StratifiedSampler::Get2D() | PBRT_CPU_GPU
Point2f Get2D() {
uint64_t hash = MixBits(((uint64_t)pixel.x << 48) ^ ((uint64_t)pixel.y << 32) ^
((uint64_t)dimension << 16) ^ GetOptions().seed);
dimension += 2;
int stratum = PermutationElement(sampleIndex, SamplesPerPixel(), hash);
in... | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rcx
movq %rcx, 0x20(%rsp)
movslq 0x20(%rcx), %rax
shlq $0x30, %rax
movslq 0x24(%rcx), %rdx
shlq $0x20, %rdx
xorq %rdx, %rax
movslq 0x2c(%rcx), %rcx
shlq $0x10, %rcx
xorq %rcx, %rax
movq %rax, 0x10(%rsp)
callq 0x5ce710
movq 0x10(%rsp), %rdi
movslq 0x4(%rax), %rax
... | /anderslanglands[P]pbrt-v4/src/pbrt/samplers.h |
auto pbrt::detail::DispatchSplit<9>::operator()<pbrt::LightHandle::Type() const::'lambda'(auto), pbrt::TaggedPointer<pbrt::PointLight, pbrt::DistantLight, pbrt::ProjectionLight, pbrt::GoniometricLight, pbrt::SpotLight, pbrt::DiffuseAreaLight, pbrt::UniformInfiniteLight, pbrt::ImageInfiniteLight, pbrt::PortalImageInfini... | PBRT_CPU_GPU inline auto operator()(F func, Tp tp, int tag, TypePack<Ts...> types) {
constexpr int mid = n / 2;
if (tag - 1 < mid) // 0-based indexing here to be more traditional
return DispatchSplit<mid>()(
func, tp, tag, typename TakeFirstN<mid, TypePack<Ts...>>::type());... | subq $0x58, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movl %edx, 0x3c(%rsp)
movl $0x4, 0x38(%rsp)
movl 0x3c(%rsp), %eax
subl $0x1, %eax
cmpl $0x4, %eax
jge 0x5d4553
movq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x3d1410
movl 0x3c(%rsp), %edx
leaq 0x37(%rsp), %rdi
leaq 0x28(%rsp), %rsi
cal... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplit<2>::operator()<pbrt::LightHandle::Type() const::'lambda'(auto), pbrt::TaggedPointer<pbrt::PointLight, pbrt::DistantLight, pbrt::ProjectionLight, pbrt::GoniometricLight, pbrt::SpotLight, pbrt::DiffuseAreaLight, pbrt::UniformInfiniteLight, pbrt::ImageInfiniteLight, pbrt::PortalImageInfini... | PBRT_CPU_GPU inline auto operator()(F func, Tp tp, int tag, TypePack<Ts...> types) {
constexpr int mid = n / 2;
if (tag - 1 < mid) // 0-based indexing here to be more traditional
return DispatchSplit<mid>()(
func, tp, tag, typename TakeFirstN<mid, TypePack<Ts...>>::type());... | subq $0x58, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movl %edx, 0x3c(%rsp)
movl $0x1, 0x38(%rsp)
movl 0x3c(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x5d4c73
movq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x3d1410
movl 0x3c(%rsp), %edx
leaq 0x37(%rsp), %rdi
leaq 0x28(%rsp), %rsi
cal... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplit<2>::operator()<pbrt::LightHandle::L(pbrt::Point3<float> const&, pbrt::Normal3<float> const&, pbrt::Point2<float> const&, pbrt::Vector3<float> const&, pbrt::SampledWavelengths const&) const::'lambda'(auto), pbrt::TaggedPointer<pbrt::PointLight, pbrt::DistantLight, pbrt::ProjectionLight, ... | PBRT_CPU_GPU inline auto operator()(F func, Tp tp, int tag, TypePack<Ts...> types) {
constexpr int mid = n / 2;
if (tag - 1 < mid) // 0-based indexing here to be more traditional
return DispatchSplit<mid>()(
func, tp, tag, typename TakeFirstN<mid, TypePack<Ts...>>::type());... | subq $0x108, %rsp # imm = 0x108
movq %rsi, 0x40(%rsp)
leaq 0x110(%rsp), %rax
movq %rax, 0x48(%rsp)
movq %rdi, 0xe8(%rsp)
movq %rsi, 0xe0(%rsp)
movl %edx, 0xdc(%rsp)
movl $0x1, 0xd8(%rsp)
movl 0xdc(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x5d52e2
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rax
movq 0x20(%... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplit<2>::operator()<pbrt::LightHandle::L(pbrt::Point3<float> const&, pbrt::Normal3<float> const&, pbrt::Point2<float> const&, pbrt::Vector3<float> const&, pbrt::SampledWavelengths const&) const::'lambda'(auto), pbrt::TaggedPointer<pbrt::PointLight, pbrt::DistantLight, pbrt::ProjectionLight, ... | PBRT_CPU_GPU inline auto operator()(F func, Tp tp, int tag, TypePack<Ts...> types) {
constexpr int mid = n / 2;
if (tag - 1 < mid) // 0-based indexing here to be more traditional
return DispatchSplit<mid>()(
func, tp, tag, typename TakeFirstN<mid, TypePack<Ts...>>::type());... | subq $0x108, %rsp # imm = 0x108
movq %rsi, 0x40(%rsp)
leaq 0x110(%rsp), %rax
movq %rax, 0x48(%rsp)
movq %rdi, 0xe8(%rsp)
movq %rsi, 0xe0(%rsp)
movl %edx, 0xdc(%rsp)
movl $0x1, 0xd8(%rsp)
movl 0xdc(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x5d58d2
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rax
movq 0x20(%... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
void pbrt::detail::stringPrintfRecursive<pbrt::Normal3<float> const&, pbrt::Point2<float> const&, pbrt::Vector3<float> const&, float const&, pbrt::SampledSpectrum const&, pbrt::SampledSpectrum const&, pbrt::SampledSpectrum const&, pbrt::SampledSpectrum const&, char const*, char const*, char const*>(std::__cxx11::basic_... | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x298, %rsp # imm = 0x298
movq 0x2f0(%rsp), %rax
movq 0x2e8(%rsp), %rax
movq 0x2e0(%rsp), %rax
movq 0x2d8(%rsp), %rax
movq 0x2d0(%rsp), %rax
movq 0x2c8(%rsp), %rax
movq 0x2c0(%rsp), %rax
movq %rdi, 0x290(%rsp)
movq %rsi, 0x288(%rsp)
movq %rdx, 0x280(%rsp)
mov... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<char const*, char const*, char const*>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const*&&, char const*&&, char const*&&) | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x258, %rsp # imm = 0x258
movq %rdi, 0x250(%rsp)
movq %rsi, 0x248(%rsp)
movq %rdx, 0x240(%rsp)
movq %rcx, 0x238(%rsp)
movq %r8, 0x230(%rsp)
movq 0x250(%rsp), %rdx
leaq 0x210(%rsp), %rdi
leaq 0x248(%rsp), %rsi
callq 0x4ccc90
leaq 0x210(%rsp), %rdi
movl $0x2a, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
auto pbrt::detail::DispatchSplit<5>::operator()<pbrt::BSDF pbrt::MaterialHandle::GetBSDF<pbrt::UniversalTextureEvaluator>(pbrt::UniversalTextureEvaluator, pbrt::MaterialEvalContext, pbrt::SampledWavelengths&, pbrt::ScratchBuffer&) const::'lambda'(pbrt::UniversalTextureEvaluator), pbrt::TaggedPointer<pbrt::CoatedDiffuse... | PBRT_CPU_GPU inline auto operator()(F func, Tp tp, int tag, TypePack<Ts...> types) {
constexpr int mid = n / 2;
if (tag - 1 < mid) // 0-based indexing here to be more traditional
return DispatchSplit<mid>()(
func, tp, tag, typename TakeFirstN<mid, TypePack<Ts...>>::type());... | subq $0xd8, %rsp
movq %rdx, 0x28(%rsp)
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x38(%rsp)
leaq 0xe0(%rsp), %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc0(%rsp)
movq %rdx, 0xb8(%rsp)
movl %ecx, 0xb4(%rsp)
movl $0x2, 0xb0(%rsp)
movl 0xb4(%rsp), %eax
subl $0x1, %eax
cmpl $0x2, %eax
jge 0x5da286
... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
pbrt::BSDF pbrt::CoatedDiffuseMaterial::GetBSDF<pbrt::UniversalTextureEvaluator>(pbrt::UniversalTextureEvaluator, pbrt::MaterialEvalContext const&, pbrt::SampledWavelengths&, pbrt::CoatedDiffuseBxDF*) const | PBRT_CPU_GPU BSDF GetBSDF(TextureEvaluator texEval, const MaterialEvalContext &ctx,
SampledWavelengths &lambda, CoatedDiffuseBxDF *bxdf) const {
// Initialize diffuse component of plastic material
SampledSpectrum r = Clamp(texEval(reflectance, ctx, lambda), 0, 1);
... | subq $0x438, %rsp # imm = 0x438
movq %rdi, 0xb8(%rsp)
movq %rdi, %rax
movq %rax, 0xc0(%rsp)
movq %rdi, 0x430(%rsp)
movq %rsi, 0x420(%rsp)
movq %rdx, 0x418(%rsp)
movq %rcx, 0x410(%rsp)
movq %r8, 0x408(%rsp)
movq 0x420(%rsp), %rsi
movq %rsi, 0xd0(%rsp)
addq $0x8, %rsi
leaq 0x3e0(%rsp), %rdi
movq %rdi, 0xc8(%rs... | /anderslanglands[P]pbrt-v4/src/pbrt/materials.h |
void pbrt::detail::stringPrintfRecursive<unsigned long&, char const (&) [15], int&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, unsigned long&, char const (&) [15], int&) | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x288, %rsp # imm = 0x288
movq %rdi, 0x280(%rsp)
movq %rsi, 0x278(%rsp)
movq %rdx, 0x270(%rsp)
movq %rcx, 0x268(%rsp)
movq %r8, 0x260(%rsp)
movq 0x280(%rsp), %rdx
leaq 0x240(%rsp), %rdi
leaq 0x278(%rsp), %rsi
callq 0x4ccc90
leaq 0x240(%rsp), %rdi
movl $0x2a, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
auto pbrt::detail::DispatchSplit<2>::operator()<pbrt::BSDF pbrt::MaterialHandle::GetBSDF<pbrt::UniversalTextureEvaluator>(pbrt::UniversalTextureEvaluator, pbrt::MaterialEvalContext, pbrt::SampledWavelengths&, pbrt::ScratchBuffer&) const::'lambda'(pbrt::UniversalTextureEvaluator), pbrt::TaggedPointer<pbrt::CoatedDiffuse... | PBRT_CPU_GPU inline auto operator()(F func, Tp tp, int tag, TypePack<Ts...> types) {
constexpr int mid = n / 2;
if (tag - 1 < mid) // 0-based indexing here to be more traditional
return DispatchSplit<mid>()(
func, tp, tag, typename TakeFirstN<mid, TypePack<Ts...>>::type());... | subq $0xd8, %rsp
movq %rdx, 0x28(%rsp)
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x38(%rsp)
leaq 0xe0(%rsp), %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc0(%rsp)
movq %rdx, 0xb8(%rsp)
movl %ecx, 0xb4(%rsp)
movl $0x1, 0xb0(%rsp)
movl 0xb4(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x5dd116
... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
pbrt::SampledWavelengths::SecondaryTerminated() const | PBRT_CPU_GPU
bool SecondaryTerminated() const {
for (int i = 1; i < NSpectrumSamples; ++i)
if (pdf[i] != 0)
return false;
return true;
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x1, 0x14(%rsp)
cmpl $0x4, 0x14(%rsp)
jge 0x5ddccd
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movslq 0x14(%rsp), %rsi
callq 0x402dc0
vmovss (%rax), %xmm0
vpxor %xmm1, %xmm1, %xmm1
vucomiss %xmm1, %xmm0
jne 0x5ddcb7
jp 0x5ddcb7
jmp 0x5ddc... | /anderslanglands[P]pbrt-v4/src/pbrt/util/spectrum.h |
auto pbrt::detail::DispatchSplit<2>::operator()<pbrt::BSDF pbrt::MaterialHandle::GetBSDF<pbrt::UniversalTextureEvaluator>(pbrt::UniversalTextureEvaluator, pbrt::MaterialEvalContext, pbrt::SampledWavelengths&, pbrt::ScratchBuffer&) const::'lambda'(pbrt::UniversalTextureEvaluator), pbrt::TaggedPointer<pbrt::CoatedDiffuse... | PBRT_CPU_GPU inline auto operator()(F func, Tp tp, int tag, TypePack<Ts...> types) {
constexpr int mid = n / 2;
if (tag - 1 < mid) // 0-based indexing here to be more traditional
return DispatchSplit<mid>()(
func, tp, tag, typename TakeFirstN<mid, TypePack<Ts...>>::type());... | subq $0xd8, %rsp
movq %rdx, 0x28(%rsp)
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x38(%rsp)
leaq 0xe0(%rsp), %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc0(%rsp)
movq %rdx, 0xb8(%rsp)
movl %ecx, 0xb4(%rsp)
movl $0x1, 0xb0(%rsp)
movl 0xb4(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x5de606
... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
pbrt::BSDF pbrt::SubsurfaceMaterial::GetBSDF<pbrt::UniversalTextureEvaluator>(pbrt::UniversalTextureEvaluator, pbrt::MaterialEvalContext const&, pbrt::SampledWavelengths&, pbrt::DielectricInterfaceBxDF*) const | PBRT_CPU_GPU BSDF GetBSDF(TextureEvaluator texEval, const MaterialEvalContext &ctx,
SampledWavelengths &lambda,
DielectricInterfaceBxDF *bxdf) const {
// Initialize BSDF for _SubsurfaceMaterial_
Float urough = texEval(uRoughness, ctx), vrough ... | subq $0x168, %rsp # imm = 0x168
movq %rdi, 0x60(%rsp)
movq %rdi, %rax
movq %rax, 0x68(%rsp)
movq %rdi, 0x160(%rsp)
movq %rsi, 0x150(%rsp)
movq %rdx, 0x148(%rsp)
movq %rcx, 0x140(%rsp)
movq %r8, 0x138(%rsp)
movq 0x150(%rsp), %rsi
movq %rsi, 0x70(%rsp)
addq $0x30, %rsi
leaq 0x128(%rsp), %rdi
callq 0x40c840
mov... | /anderslanglands[P]pbrt-v4/src/pbrt/materials.h |
auto pbrt::detail::DispatchSplit<6>::operator()<pbrt::BSSRDFHandle pbrt::MaterialHandle::GetBSSRDF<pbrt::UniversalTextureEvaluator>(pbrt::UniversalTextureEvaluator, pbrt::MaterialEvalContext, pbrt::SampledWavelengths&, pbrt::ScratchBuffer&) const::'lambda'(pbrt::UniversalTextureEvaluator), pbrt::TaggedPointer<pbrt::Coa... | PBRT_CPU_GPU inline auto operator()(F func, Tp tp, int tag, TypePack<Ts...> types) {
constexpr int mid = n / 2;
if (tag - 1 < mid) // 0-based indexing here to be more traditional
return DispatchSplit<mid>()(
func, tp, tag, typename TakeFirstN<mid, TypePack<Ts...>>::type());... | subq $0xd8, %rsp
movq %rdx, 0x28(%rsp)
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x38(%rsp)
leaq 0xe0(%rsp), %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc0(%rsp)
movq %rdx, 0xb8(%rsp)
movl %ecx, 0xb4(%rsp)
movl $0x3, 0xb0(%rsp)
movl 0xb4(%rsp), %eax
subl $0x1, %eax
cmpl $0x3, %eax
jge 0x5e0636
... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplit<3>::operator()<pbrt::BSSRDFHandle pbrt::MaterialHandle::GetBSSRDF<pbrt::UniversalTextureEvaluator>(pbrt::UniversalTextureEvaluator, pbrt::MaterialEvalContext, pbrt::SampledWavelengths&, pbrt::ScratchBuffer&) const::'lambda'(pbrt::UniversalTextureEvaluator), pbrt::TaggedPointer<pbrt::Coa... | PBRT_CPU_GPU inline auto operator()(F func, Tp tp, int tag, TypePack<Ts...> types) {
constexpr int mid = n / 2;
if (tag - 1 < mid) // 0-based indexing here to be more traditional
return DispatchSplit<mid>()(
func, tp, tag, typename TakeFirstN<mid, TypePack<Ts...>>::type());... | subq $0xd8, %rsp
movq %rdx, 0x28(%rsp)
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x38(%rsp)
leaq 0xe0(%rsp), %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc0(%rsp)
movq %rdx, 0xb8(%rsp)
movl %ecx, 0xb4(%rsp)
movl $0x1, 0xb0(%rsp)
movl 0xb4(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x5e10d6
... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
void pbrt::detail::stringPrintfRecursive<pbrt::Normal3<float> const&, pbrt::Point2<float> const&, pbrt::Vector3<float> const&, float const&, char const*, char const*, pbrt::Vector3<float> const&, pbrt::Vector3<float> const&, pbrt::Normal3<float> const&, pbrt::Normal3<float> const&, pbrt::Normal3<float> const&, pbrt::Ve... | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x358, %rsp # imm = 0x358
movq 0x428(%rsp), %rax
movq 0x420(%rsp), %rax
movq 0x418(%rsp), %rax
movq 0x410(%rsp), %rax
movq 0x408(%rsp), %rax
movq 0x400(%rsp), %rax
movq 0x3f8(%rsp), %rax
movq 0x3f0(%rsp), %rax
movq 0x3e8(%rsp), %rax
movq... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<char const*, pbrt::Vector3<float> const&, pbrt::Vector3<float> const&, pbrt::Normal3<float> const&, pbrt::Normal3<float> const&, pbrt::Normal3<float> const&, pbrt::Vector3<float> const&, pbrt::Vector3<float> const&, pbrt::Normal3<float> const&, pbrt::Normal3<float> const&, char ... | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x308, %rsp # imm = 0x308
movq 0x3b0(%rsp), %rax
movq 0x3a8(%rsp), %rax
movq 0x3a0(%rsp), %rax
movq 0x398(%rsp), %rax
movq 0x390(%rsp), %rax
movq 0x388(%rsp), %rax
movq 0x380(%rsp), %rax
movq 0x378(%rsp), %rax
movq 0x370(%rsp), %rax
movq... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<pbrt::Normal3<float> const&, pbrt::Vector3<float> const&, pbrt::Vector3<float> const&, pbrt::Normal3<float> const&, pbrt::Normal3<float> const&, char const*, char const*, pbrt::Vector3<float>&, pbrt::Vector3<float>&, float&, float&, float&, float&, int const&>(std::__cxx11::basi... | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2b8, %rsp # imm = 0x2B8
movq 0x338(%rsp), %rax
movq 0x330(%rsp), %rax
movq 0x328(%rsp), %rax
movq 0x320(%rsp), %rax
movq 0x318(%rsp), %rax
movq 0x310(%rsp), %rax
movq 0x308(%rsp), %rax
movq 0x300(%rsp), %rax
movq 0x2f8(%rsp), %rax
movq... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<char const*, char const*, pbrt::Vector3<float>&, pbrt::Vector3<float>&, float&, float&, float&, float&, int const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const*&&, char const*&&, pbrt::Vector3<float>&, pbrt::Vector3<fl... | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | pushq %r14
pushq %rbx
subq $0x288, %rsp # imm = 0x288
movq 0x2c0(%rsp), %rax
movq 0x2b8(%rsp), %rax
movq 0x2b0(%rsp), %rax
movq 0x2a8(%rsp), %rax
movq 0x2a0(%rsp), %rax
movq %rdi, 0x280(%rsp)
movq %rsi, 0x278(%rsp)
movq %rdx, 0x270(%rsp)
movq %rcx, 0x268(%rsp)
movq %r8, 0x260(%rsp)
movq %r9, 0x258(%rsp)
movq... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
pbrt::ProjectionLight::Phi(pbrt::SampledWavelengths const&) const | SampledSpectrum ProjectionLight::Phi(const SampledWavelengths &lambda) const {
SampledSpectrum sum(0.f);
for (int v = 0; v < image.Resolution().y; ++v)
for (int u = 0; u < image.Resolution().x; ++u) {
Point2f ps = screenBounds.Lerp(
{(u + .5f) / image.Resolution().x, (v + .5f... | subq $0x1c8, %rsp # imm = 0x1C8
movq %rdi, 0x1b0(%rsp)
movq %rsi, 0x1a8(%rsp)
movq 0x1b0(%rsp), %rax
movq %rax, 0x70(%rsp)
leaq 0x198(%rsp), %rdi
vpxor %xmm0, %xmm0, %xmm0
callq 0x3fea10
movl $0x0, 0x194(%rsp)
movq 0x70(%rsp), %rdi
movl 0x194(%rsp), %eax
movl %eax, 0x6c(%rsp)
addq $0x98, %rdi
callq 0x43c1b0
... | /anderslanglands[P]pbrt-v4/src/pbrt/lights.cpp |
pbrt::GoniometricLight::Bounds() const | LightBounds GoniometricLight::Bounds() const {
// Like Phi() method, but compute the weighted max component value of
// the image map.
Float weightedMaxImageSum = 0;
int width = image.Resolution().x, height = image.Resolution().y;
for (int v = 0; v < height; ++v) {
Float sinTheta = std::sin(... | subq $0x108, %rsp # imm = 0x108
movq %rdi, 0x38(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x100(%rsp)
movq 0x100(%rsp), %rdi
movq %rdi, 0x48(%rsp)
vpxor %xmm0, %xmm0, %xmm0
vmovss %xmm0, 0xfc(%rsp)
addq $0xc8, %rdi
callq 0x43c1b0
movq 0x48(%rsp), %rdi
movq %rax, 0xf0(%rsp)
movl 0xf0(%rsp), %eax
movl %eax, 0xf8(... | /anderslanglands[P]pbrt-v4/src/pbrt/lights.cpp |
pbrt::DiffuseAreaLight::DiffuseAreaLight(pbrt::Transform const&, pbrt::MediumInterface const&, pbrt::SpectrumHandle, float, pbrt::ShapeHandle, pbrt::Image, pbrt::RGBColorSpace const*, bool, pstd::pmr::polymorphic_allocator<std::byte>) | DiffuseAreaLight::DiffuseAreaLight(const Transform &renderFromLight,
const MediumInterface &mediumInterface,
SpectrumHandle Le, Float scale,
const ShapeHandle shape, Image im,
cons... | subq $0x238, %rsp # imm = 0x238
movq %r9, 0xd8(%rsp)
movq %r8, 0x100(%rsp)
movq %rcx, 0xe0(%rsp)
movq 0x250(%rsp), %r10
movb 0x248(%rsp), %al
movq 0x240(%rsp), %r11
movq %r10, 0x230(%rsp)
movq %rdi, 0x228(%rsp)
movq %rsi, 0x220(%rsp)
movq %rdx, 0x218(%rsp)
movq %rcx, 0x210(%rsp)
vmovss %xmm0, 0x20c(%rsp)
mov... | /anderslanglands[P]pbrt-v4/src/pbrt/lights.cpp |
pbrt::UniformInfiniteLight::SampleLe(pbrt::Point2<float> const&, pbrt::Point2<float> const&, pbrt::SampledWavelengths&, float) const | LightLeSample UniformInfiniteLight::SampleLe(const Point2f &u1, const Point2f &u2,
SampledWavelengths &lambda,
Float time) const {
Vector3f w = SampleUniformSphere(u1);
// Compute infinite light sample ray
Frame wFrame... | subq $0x248, %rsp # imm = 0x248
movq %rdi, 0x80(%rsp)
movq %rdi, %rax
movq %rax, 0x88(%rsp)
movq %rdi, 0x240(%rsp)
movq %rsi, 0x238(%rsp)
movq %rdx, 0x230(%rsp)
movq %rcx, 0x228(%rsp)
movq %r8, 0x220(%rsp)
vmovss %xmm0, 0x21c(%rsp)
movq 0x238(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x230(%rsp), %rdi
callq 0x3... | /anderslanglands[P]pbrt-v4/src/pbrt/lights.cpp |
pbrt::PortalImageInfiniteLight::PortalImageInfiniteLight(pbrt::Transform const&, pbrt::Image, pbrt::RGBColorSpace const*, float, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<pbrt::Point3<float>, std::allocator<pbrt::Point3<float>>>, pstd::pmr::polymorphic_allocator<... | PortalImageInfiniteLight::PortalImageInfiniteLight(
const Transform &renderFromLight, Image equiAreaImage,
const RGBColorSpace *imageColorSpace, Float scale, const std::string &filename,
std::vector<Point3f> p, Allocator alloc)
: LightBase(LightType::Infinite, renderFromLight, MediumInterface()),
... | subq $0x8a8, %rsp # imm = 0x8A8
movq %r9, 0x300(%rsp)
movq %rdx, 0x308(%rsp)
movq 0x8b0(%rsp), %rax
movq %rax, 0x8a0(%rsp)
movq %rdi, 0x898(%rsp)
movq %rsi, 0x890(%rsp)
movq %rdx, 0x888(%rsp)
movq %rcx, 0x880(%rsp)
vmovss %xmm0, 0x87c(%rsp)
movq %r8, 0x870(%rsp)
movq %r9, 0x868(%rsp)
movq 0x898(%rsp), %rax
m... | /anderslanglands[P]pbrt-v4/src/pbrt/lights.cpp |
pbrt::PortalImageInfiniteLight::Le(pbrt::Ray const&, pbrt::SampledWavelengths const&) const | SampledSpectrum PortalImageInfiniteLight::Le(const Ray &ray,
const SampledWavelengths &lambda) const {
// Ignore world to light...
Vector3f w = Normalize(ray.d);
Point2f st = ImageFromRender(w);
if (!Inside(st, ImageBounds(ray.o)))
return SampledSpec... | subq $0x68, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rdi
addq $0xc, %rdi
callq 0x361910
movq (%rsp), %rdi
vmovss %xmm1, 0x28(%rsp)
vmovlpd %xmm0, 0x20(%rsp)
movl 0x28(%rsp), %eax
movl %eax, 0x38(%rsp)
movq 0x20(%rsp), %rax
movq %rax... | /anderslanglands[P]pbrt-v4/src/pbrt/lights.cpp |
pbrt::PortalImageInfiniteLight::PDF_Le(pbrt::Ray const&, float*, float*) const | void PortalImageInfiniteLight::PDF_Le(const Ray &ray, Float *pdfPos,
Float *pdfDir) const {
// TODO: negate here or???
Vector3f w = -Normalize(ray.d);
Float duv_dw;
Point2f st = ImageFromRender(w, &duv_dw);
if (duv_dw == 0) {
*pdfPos = *pdfDir = 0;
... | subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
movq 0x90(%rsp), %rax
movq %rax, (%rsp)
movq 0x88(%rsp), %rdi
addq $0xc, %rdi
callq 0x361910
vmovss %xmm1, 0x50(%rsp)
vmovlpd %xmm0, 0x48(%rsp)
movl 0x50(%rsp), %eax
movl %eax, 0x60(%rsp)
movq 0x48(%rsp), %rax
movq ... | /anderslanglands[P]pbrt-v4/src/pbrt/lights.cpp |
pbrt::SpotLight::Phi(pbrt::SampledWavelengths const&) const | SampledSpectrum SpotLight::Phi(const SampledWavelengths &lambda) const {
// int_0^start sin theta dtheta = 1 - cosFalloffStart
// See notes/sample-spotlight.nb for the falloff part:
// int_start^end smoothstep(cost, end, start) sin theta dtheta =
// (cosStart - cosEnd) / 2
return scale * I.Sample(l... | subq $0x78, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x10(%rsp)
vmovss 0xc0(%rdi), %xmm0
vmovss %xmm0, 0xc(%rsp)
addq $0x98, %rdi
movq 0x58(%rsp), %rsi
callq 0x402b90
vmovaps %xmm0, %xmm2
vmovss 0xc(%rsp), %xmm0
vmovlpd %xmm2, 0x18(%rsp)
vmovlpd %xmm1, 0x20(%rsp)
leaq 0x18(%rsp)... | /anderslanglands[P]pbrt-v4/src/pbrt/lights.cpp |
pbrt::SpotLight::PDF_Le(pbrt::Ray const&, float*, float*) const | void SpotLight::PDF_Le(const Ray &ray, Float *pdfPos, Float *pdfDir) const {
*pdfPos = 0;
// Unnormalized probabilities of sampling each part.
Float p[2] = {1 - cosFalloffStart, (cosFalloffStart - cosFalloffEnd) / 2};
Float cosTheta = CosTheta(renderFromLight.ApplyInverse(ray.d));
if (cosTheta >= ... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x40(%rsp), %rax
movl $0x0, (%rax)
vmovss 0xc4(%rdi), %xmm1
vmovss 0x2529d7(%rip), %xmm0 # 0x84b154
vsubss %xmm1, %xmm0, %xmm0
vmovss %xmm0, 0x30(%rsp)
vmovss 0xc4(%... | /anderslanglands[P]pbrt-v4/src/pbrt/lights.cpp |
auto pbrt::detail::DispatchSplitCPU<4>::operator()<pbrt::LightHandle::Phi(pbrt::SampledWavelengths const&) const::$_0, pbrt::TaggedPointer<pbrt::PointLight, pbrt::DistantLight, pbrt::ProjectionLight, pbrt::GoniometricLight, pbrt::SpotLight, pbrt::DiffuseAreaLight, pbrt::UniformInfiniteLight, pbrt::ImageInfiniteLight, p... | inline auto operator()(F func, Tp tp, int tag, TypePack<Ts...> types) {
constexpr int mid = n / 2;
if (tag - 1 < mid) // 0-based indexing here to be more traditional
return DispatchSplitCPU<mid>()(
func, tp, tag, typename TakeFirstN<mid, TypePack<Ts...>>::type());
e... | subq $0x88, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, 0x70(%rsp)
movq %rdi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movl %ecx, 0x54(%rsp)
movl $0x2, 0x50(%rsp)
movl 0x54(%rsp), %eax
subl $0x1, %eax
cmpl $0x2, %eax
jge 0x5fc51a
movq 0x10(%rsp), %rsi
movq 0x70(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplitCPU<3>::operator()<pbrt::LightHandle::Phi(pbrt::SampledWavelengths const&) const::$_0, pbrt::TaggedPointer<pbrt::PointLight, pbrt::DistantLight, pbrt::ProjectionLight, pbrt::GoniometricLight, pbrt::SpotLight, pbrt::DiffuseAreaLight, pbrt::UniformInfiniteLight, pbrt::ImageInfiniteLight, p... | inline auto operator()(F func, Tp tp, int tag, TypePack<Ts...> types) {
constexpr int mid = n / 2;
if (tag - 1 < mid) // 0-based indexing here to be more traditional
return DispatchSplitCPU<mid>()(
func, tp, tag, typename TakeFirstN<mid, TypePack<Ts...>>::type());
e... | subq $0x88, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, 0x70(%rsp)
movq %rdi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movl %ecx, 0x54(%rsp)
movl $0x1, 0x50(%rsp)
movl 0x54(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x5fcbfa
movq 0x10(%rsp), %rsi
movq 0x70(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplitCPU<9>::operator()<pbrt::LightHandle::Preprocess(pbrt::Bounds3<float> const&)::$_0, pbrt::TaggedPointer<pbrt::PointLight, pbrt::DistantLight, pbrt::ProjectionLight, pbrt::GoniometricLight, pbrt::SpotLight, pbrt::DiffuseAreaLight, pbrt::UniformInfiniteLight, pbrt::ImageInfiniteLight, pbrt... | inline auto operator()(F func, Tp tp, int tag, TypePack<Ts...> types) {
constexpr int mid = n / 2;
if (tag - 1 < mid) // 0-based indexing here to be more traditional
return DispatchSplitCPU<mid>()(
func, tp, tag, typename TakeFirstN<mid, TypePack<Ts...>>::type());
e... | subq $0x68, %rsp
movq %rdx, (%rsp)
movq %rsi, 0x60(%rsp)
movq %rdi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movl %ecx, 0x44(%rsp)
movl $0x4, 0x40(%rsp)
movl 0x44(%rsp), %eax
subl $0x1, %eax
cmpl $0x4, %eax
jge 0x5fd0c1
movq (%rsp), %rsi
movq 0x60(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x3d1410
movl 0x44... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplitCPU<2>::operator()<pbrt::LightHandle::Preprocess(pbrt::Bounds3<float> const&)::$_0, pbrt::TaggedPointer<pbrt::PointLight, pbrt::DistantLight, pbrt::ProjectionLight, pbrt::GoniometricLight, pbrt::SpotLight, pbrt::DiffuseAreaLight, pbrt::UniformInfiniteLight, pbrt::ImageInfiniteLight, pbrt... | inline auto operator()(F func, Tp tp, int tag, TypePack<Ts...> types) {
constexpr int mid = n / 2;
if (tag - 1 < mid) // 0-based indexing here to be more traditional
return DispatchSplitCPU<mid>()(
func, tp, tag, typename TakeFirstN<mid, TypePack<Ts...>>::type());
e... | subq $0x68, %rsp
movq %rdx, (%rsp)
movq %rsi, 0x60(%rsp)
movq %rdi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movl %ecx, 0x44(%rsp)
movl $0x1, 0x40(%rsp)
movl 0x44(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x5fd801
movq (%rsp), %rsi
movq 0x60(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x3d1410
movl 0x44... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplit<2>::operator()<pbrt::LightHandle::SampleLe(pbrt::Point2<float> const&, pbrt::Point2<float> const&, pbrt::SampledWavelengths&, float) const::$_0, pbrt::TaggedPointer<pbrt::PointLight, pbrt::DistantLight, pbrt::ProjectionLight, pbrt::GoniometricLight, pbrt::SpotLight, pbrt::DiffuseAreaLig... | PBRT_CPU_GPU inline auto operator()(F func, Tp tp, int tag, TypePack<Ts...> types) {
constexpr int mid = n / 2;
if (tag - 1 < mid) // 0-based indexing here to be more traditional
return DispatchSplit<mid>()(
func, tp, tag, typename TakeFirstN<mid, TypePack<Ts...>>::type());... | subq $0xd8, %rsp
movq %rdx, 0x28(%rsp)
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x38(%rsp)
leaq 0xe0(%rsp), %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc0(%rsp)
movq %rdx, 0xb8(%rsp)
movl %ecx, 0xb4(%rsp)
movl $0x1, 0xb0(%rsp)
movl 0xb4(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x5fe486
... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplit<3>::operator()<pbrt::LightHandle::SampleLe(pbrt::Point2<float> const&, pbrt::Point2<float> const&, pbrt::SampledWavelengths&, float) const::$_0, pbrt::TaggedPointer<pbrt::PointLight, pbrt::DistantLight, pbrt::ProjectionLight, pbrt::GoniometricLight, pbrt::SpotLight, pbrt::DiffuseAreaLig... | PBRT_CPU_GPU inline auto operator()(F func, Tp tp, int tag, TypePack<Ts...> types) {
constexpr int mid = n / 2;
if (tag - 1 < mid) // 0-based indexing here to be more traditional
return DispatchSplit<mid>()(
func, tp, tag, typename TakeFirstN<mid, TypePack<Ts...>>::type());... | subq $0xd8, %rsp
movq %rdx, 0x28(%rsp)
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x38(%rsp)
leaq 0xe0(%rsp), %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc0(%rsp)
movq %rdx, 0xb8(%rsp)
movl %ecx, 0xb4(%rsp)
movl $0x1, 0xb0(%rsp)
movl 0xb4(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x5fe606
... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplit<5>::operator()<pbrt::LightHandle::PDF_Le(pbrt::Ray const&, float*, float*) const::$_0, pbrt::TaggedPointer<pbrt::PointLight, pbrt::DistantLight, pbrt::ProjectionLight, pbrt::GoniometricLight, pbrt::SpotLight, pbrt::DiffuseAreaLight, pbrt::UniformInfiniteLight, pbrt::ImageInfiniteLight, ... | PBRT_CPU_GPU inline auto operator()(F func, Tp tp, int tag, TypePack<Ts...> types) {
constexpr int mid = n / 2;
if (tag - 1 < mid) // 0-based indexing here to be more traditional
return DispatchSplit<mid>()(
func, tp, tag, typename TakeFirstN<mid, TypePack<Ts...>>::type());... | subq $0xa8, %rsp
movq %rsi, 0x20(%rsp)
leaq 0xb0(%rsp), %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
movl %edx, 0x8c(%rsp)
movl $0x2, 0x88(%rsp)
movl 0x8c(%rsp), %eax
subl $0x1, %eax
cmpl $0x2, %eax
jge 0x5fee71
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x68(%rsp... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplit<3>::operator()<pbrt::LightHandle::PDF_Le(pbrt::Ray const&, float*, float*) const::$_0, pbrt::TaggedPointer<pbrt::PointLight, pbrt::DistantLight, pbrt::ProjectionLight, pbrt::GoniometricLight, pbrt::SpotLight, pbrt::DiffuseAreaLight, pbrt::UniformInfiniteLight, pbrt::ImageInfiniteLight, ... | PBRT_CPU_GPU inline auto operator()(F func, Tp tp, int tag, TypePack<Ts...> types) {
constexpr int mid = n / 2;
if (tag - 1 < mid) // 0-based indexing here to be more traditional
return DispatchSplit<mid>()(
func, tp, tag, typename TakeFirstN<mid, TypePack<Ts...>>::type());... | subq $0xa8, %rsp
movq %rsi, 0x20(%rsp)
leaq 0xb0(%rsp), %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
movl %edx, 0x8c(%rsp)
movl $0x1, 0x88(%rsp)
movl 0x8c(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x5ff4f1
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x68(%rsp... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplitCPU<9>::operator()<pbrt::LightHandle::Bounds() const::$_0, pbrt::TaggedPointer<pbrt::PointLight, pbrt::DistantLight, pbrt::ProjectionLight, pbrt::GoniometricLight, pbrt::SpotLight, pbrt::DiffuseAreaLight, pbrt::UniformInfiniteLight, pbrt::ImageInfiniteLight, pbrt::PortalImageInfiniteLigh... | inline auto operator()(F func, Tp tp, int tag, TypePack<Ts...> types) {
constexpr int mid = n / 2;
if (tag - 1 < mid) // 0-based indexing here to be more traditional
return DispatchSplitCPU<mid>()(
func, tp, tag, typename TakeFirstN<mid, TypePack<Ts...>>::type());
e... | subq $0x68, %rsp
movq %rdx, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movq %rdi, 0x18(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movl %ecx, 0x4c(%rsp)
movl $0x4, 0x48(%rsp)
movl 0x4c(%rsp), %eax
subl $0x1, %eax
cmpl $0x4, %eax
jge 0x5ff95e
movq 0x8(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x3d1410
movq 0x10(%rsp), %rdi
mov... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplit<2>::operator()<pbrt::LightHandle::PDF_Le(pbrt::Interaction const&, pbrt::Vector3<float>&, float*, float*) const::$_0, pbrt::TaggedPointer<pbrt::PointLight, pbrt::DistantLight, pbrt::ProjectionLight, pbrt::GoniometricLight, pbrt::SpotLight, pbrt::DiffuseAreaLight, pbrt::UniformInfiniteLi... | PBRT_CPU_GPU inline auto operator()(F func, Tp tp, int tag, TypePack<Ts...> types) {
constexpr int mid = n / 2;
if (tag - 1 < mid) // 0-based indexing here to be more traditional
return DispatchSplit<mid>()(
func, tp, tag, typename TakeFirstN<mid, TypePack<Ts...>>::type());... | subq $0xb8, %rsp
movq %rsi, 0x20(%rsp)
leaq 0xc0(%rsp), %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0xa8(%rsp)
movq %rsi, 0xa0(%rsp)
movl %edx, 0x9c(%rsp)
movl $0x1, 0x98(%rsp)
movl 0x9c(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x601299
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x70(%rsp... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
pbrt::PiecewiseConstant2D::BytesUsed() const | PBRT_CPU_GPU
size_t BytesUsed() const {
return pConditionalY.size() *
(pConditionalY[0].BytesUsed() + sizeof(pConditionalY[0])) +
pMarginal.BytesUsed();
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x10, %rdi
callq 0x4d7670
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3d43b0
movq %rax, %rdi
callq 0x607050
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movq 0x10(%rsp), %rax
addq $0x5... | /anderslanglands[P]pbrt-v4/src/pbrt/util/sampling.h |
auto pbrt::detail::DispatchSplit<2>::operator()<pbrt::ShapeHandle::Area() const::'lambda'(auto), pbrt::TaggedPointer<pbrt::Sphere, pbrt::Cylinder, pbrt::Disk, pbrt::Triangle, pbrt::BilinearPatch, pbrt::Curve>, pbrt::BilinearPatch, pbrt::Curve>(auto, pbrt::TaggedPointer<pbrt::Sphere, pbrt::Cylinder, pbrt::Disk, pbrt::Tr... | PBRT_CPU_GPU inline auto operator()(F func, Tp tp, int tag, TypePack<Ts...> types) {
constexpr int mid = n / 2;
if (tag - 1 < mid) // 0-based indexing here to be more traditional
return DispatchSplit<mid>()(
func, tp, tag, typename TakeFirstN<mid, TypePack<Ts...>>::type());... | subq $0x58, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movl %edx, 0x3c(%rsp)
movl $0x1, 0x38(%rsp)
movl 0x3c(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x607995
movq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x3d5290
movl 0x3c(%rsp), %edx
leaq 0x37(%rsp), %rdi
leaq 0x28(%rsp), %rsi
cal... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplit<2>::operator()<pbrt::ShapeHandle::Sample(pbrt::Point2<float> const&) const::'lambda'(auto), pbrt::TaggedPointer<pbrt::Sphere, pbrt::Cylinder, pbrt::Disk, pbrt::Triangle, pbrt::BilinearPatch, pbrt::Curve>, pbrt::BilinearPatch, pbrt::Curve>(auto, pbrt::TaggedPointer<pbrt::Sphere, pbrt::Cy... | PBRT_CPU_GPU inline auto operator()(F func, Tp tp, int tag, TypePack<Ts...> types) {
constexpr int mid = n / 2;
if (tag - 1 < mid) // 0-based indexing here to be more traditional
return DispatchSplit<mid>()(
func, tp, tag, typename TakeFirstN<mid, TypePack<Ts...>>::type());... | subq $0x88, %rsp
movq %rcx, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movq %rsi, 0x68(%rsp)
movq %rcx, 0x60(%rsp)
movl %r8d, 0x5c(%rsp)
movl $0x1, 0x58(%rsp)
movl 0x5c(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x609662
movq 0x8(%rsp), %rsi
mo... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplit<3>::operator()<pbrt::ShapeHandle::PDF(pbrt::Interaction const&) const::'lambda'(auto), pbrt::TaggedPointer<pbrt::Sphere, pbrt::Cylinder, pbrt::Disk, pbrt::Triangle, pbrt::BilinearPatch, pbrt::Curve>, pbrt::Triangle, pbrt::BilinearPatch, pbrt::Curve>(auto, pbrt::TaggedPointer<pbrt::Spher... | PBRT_CPU_GPU inline auto operator()(F func, Tp tp, int tag, TypePack<Ts...> types) {
constexpr int mid = n / 2;
if (tag - 1 < mid) // 0-based indexing here to be more traditional
return DispatchSplit<mid>()(
func, tp, tag, typename TakeFirstN<mid, TypePack<Ts...>>::type());... | subq $0x78, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movl %ecx, 0x4c(%rsp)
movl $0x1, 0x48(%rsp)
movl 0x4c(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x60a6b9
movq 0x8(%rsp), %rsi
movq 0x68(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x3d5290
mov... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
pbrt::SummedAreaTable::integrate(pbrt::Array2D<float> const&, pstd::pmr::polymorphic_allocator<std::byte>) | Array2D<double> integrate(const Array2D<Float> &values, Allocator alloc) {
auto f = [&values](int x, int y) {
return values(x, y) / (values.xSize() * values.ySize());
};
Array2D<double> result(values.xSize(), values.ySize(), alloc);
result(0, 0) = f(0, 0);
// Compute ... | subq $0x138, %rsp # imm = 0x138
movq %rdi, 0xd0(%rsp)
movq %rdi, %rax
movq %rax, 0xc8(%rsp)
movq %rdi, 0x130(%rsp)
movq %rcx, 0x128(%rsp)
movq %rsi, 0x120(%rsp)
movq %rdx, 0x118(%rsp)
movq 0x118(%rsp), %rax
movq %rax, 0x110(%rsp)
movb $0x0, 0x10f(%rsp)
movq 0x118(%rsp), %rdi
callq 0x3e8690
movl %eax, 0xdc(%r... | /anderslanglands[P]pbrt-v4/src/pbrt/util/sampling.h |
float pbrt::WindowedPiecewiseConstant2D::sample<pbrt::WindowedPiecewiseConstant2D::Sample(pbrt::Point2<float> const&, pbrt::Bounds2<float> const&, float*) const::'lambda'(float)>(pbrt::WindowedPiecewiseConstant2D::Sample(pbrt::Point2<float> const&, pbrt::Bounds2<float> const&, float*) const::'lambda'(float), float, flo... | PBRT_CPU_GPU static Float sample(F func, Float u, Float min, Float max, int n) {
// Apply bisection to bracket _u_
while (std::ceil(n * max) - std::floor(n * min) > 1) {
DCHECK_LE(func(min), u);
DCHECK_GE(func(max), u);
Float mid = (min + max) / 2;
if (fun... | subq $0x38, %rsp
leaq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
vmovss %xmm0, 0x34(%rsp)
vmovss %xmm1, 0x30(%rsp)
vmovss %xmm2, 0x2c(%rsp)
movl %edi, 0x28(%rsp)
vcvtsi2ssl 0x28(%rsp), %xmm0, %xmm0
vmulss 0x2c(%rsp), %xmm0, %xmm0
callq 0x4c58a0
vmovss %xmm0, 0x14(%rsp)
vcvtsi2ssl 0x28(%rsp), %xmm0, %xmm0
vmulss 0x30(%rsp),... | /anderslanglands[P]pbrt-v4/src/pbrt/util/sampling.h |
pbrt::TaggedPointer<pbrt::PointLight, pbrt::DistantLight, pbrt::ProjectionLight, pbrt::GoniometricLight, pbrt::SpotLight, pbrt::DiffuseAreaLight, pbrt::UniformInfiniteLight, pbrt::ImageInfiniteLight, pbrt::PortalImageInfiniteLight>::TaggedPointer<pbrt::ProjectionLight>(pbrt::ProjectionLight*) | PBRT_CPU_GPU TaggedPointer(T *ptr) {
uintptr_t iptr = reinterpret_cast<uintptr_t>(ptr);
// Reminder: if this CHECK hits, it's likely that the class
// involved needs an alignas(8).
DCHECK_EQ(iptr & ptrMask, iptr);
constexpr uint16_t type = TypeIndex<T>();
bits = iptr | ((... | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq $0x0, (%rax)
movq -0x10(%rsp), %rcx
movq %rcx, -0x18(%rsp)
movw $0x3, -0x1a(%rsp)
movabsq $0x3000000000000, %rcx # imm = 0x3000000000000
orq -0x18(%rsp), %rcx
movq %rcx, (%rax)
retq
nopw (%rax,%rax)
| /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
void pbrt::detail::stringPrintfRecursive<float const&, float const&, float const&, float const&, float const&, bool const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, float const&, float const&, float const&, float const&, float const&, bool const&) | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x288, %rsp # imm = 0x288
movq 0x298(%rsp), %rax
movq 0x290(%rsp), %rax
movq %rdi, 0x280(%rsp)
movq %rsi, 0x278(%rsp)
movq %rdx, 0x270(%rsp)
movq %rcx, 0x268(%rsp)
movq %r8, 0x260(%rsp)
movq %r9, 0x258(%rsp)
movq 0x280(%rsp), %rdx
leaq 0x238(%rsp), %rdi
leaq 0x278(%rsp), %rsi
callq 0x4ccc90
leaq 0x238(... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<char const (&) [9], char const (&) [2], char const (&) [9], float&, char const (&) [2], int&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [9], char const (&) [2], char const (&) [9], float&, char const (&) [2], int... | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x268, %rsp # imm = 0x268
movq 0x278(%rsp), %rax
movq 0x270(%rsp), %rax
movq %rdi, 0x260(%rsp)
movq %rsi, 0x258(%rsp)
movq %rdx, 0x250(%rsp)
movq %rcx, 0x248(%rsp)
movq %r8, 0x240(%rsp)
movq %r9, 0x238(%rsp)
movq 0x260(%rsp), %rdx
leaq 0x218(%rsp), %rdi
leaq 0x258(%rsp), %rsi
callq 0x4ccc90
leaq 0x218(... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<char const (&) [9], float&, char const (&) [2], int&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [9], float&, char const (&) [2], int&) | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x268, %rsp # imm = 0x268
movq %rdi, 0x260(%rsp)
movq %rsi, 0x258(%rsp)
movq %rdx, 0x250(%rsp)
movq %rcx, 0x248(%rsp)
movq %r8, 0x240(%rsp)
movq %r9, 0x238(%rsp)
movq 0x260(%rsp), %rdx
leaq 0x218(%rsp), %rdi
leaq 0x258(%rsp), %rsi
callq 0x4ccc90
leaq 0x218(%rsp), %rdi
movl $0x2a, %esi
xorl %eax, %eax
m... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<char const (&) [18], int&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [18], int&) | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x258, %rsp # imm = 0x258
movq %rdi, 0x250(%rsp)
movq %rsi, 0x248(%rsp)
movq %rdx, 0x240(%rsp)
movq %rcx, 0x238(%rsp)
movq 0x250(%rsp), %rdx
leaq 0x218(%rsp), %rdi
leaq 0x248(%rsp), %rsi
callq 0x4ccc90
leaq 0x218(%rsp), %rdi
movl $0x2a, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x328670
cmpq $-0x1, %r... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
std::enable_if<!std::is_class<std::decay<char const (&) [12]>::type>::value, void>::type pbrt::detail::stringPrintfRecursiveWithPrecision<char const (&) [12], unsigned long&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, std::__cxx11::basic_string<char, std::char_traits<c... | inline typename std::enable_if_t<!std::is_class<typename std::decay_t<T>>::value, void>
stringPrintfRecursiveWithPrecision(std::string *s, const char *fmt,
const std::string &nextFmt, int precision, T &&v,
Args &&... args) {
size_t size = snprint... | subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movl %ecx, 0x6c(%rsp)
movq %r8, 0x60(%rsp)
movq %r9, 0x58(%rsp)
movq 0x70(%rsp), %rdi
callq 0x327260
movq %rax, %rdx
movl 0x6c(%rsp), %ecx
movq 0x60(%rsp), %r8
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x327ad0
incl %eax
cltq... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<pbrt::ShapeHandle const&, char const*, float const&, pbrt::Image const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, pbrt::ShapeHandle const&, char const*&&, float const&, pbrt::Image const&) | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x268, %rsp # imm = 0x268
movq %rdi, 0x260(%rsp)
movq %rsi, 0x258(%rsp)
movq %rdx, 0x250(%rsp)
movq %rcx, 0x248(%rsp)
movq %r8, 0x240(%rsp)
movq %r9, 0x238(%rsp)
movq 0x260(%rsp), %rdx
leaq 0x218(%rsp), %rdi
leaq 0x258(%rsp), %rsi
callq 0x4ccc90
leaq 0x218(%rsp), %rdi
movl $0x2a, %esi
xorl %eax, %eax
m... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, float const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, std:... | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x258, %rsp # imm = 0x258
movq %rdi, 0x250(%rsp)
movq %rsi, 0x248(%rsp)
movq %rdx, 0x240(%rsp)
movq %rcx, 0x238(%rsp)
movq %r8, 0x230(%rsp)
movq 0x250(%rsp), %rdx
leaq 0x210(%rsp), %rdi
leaq 0x248(%rsp), %rsi
callq 0x4ccc90
leaq 0x210(%rsp), %rdi
movl $0x2a, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, float const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const... | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x258, %rsp # imm = 0x258
movq %rdi, 0x250(%rsp)
movq %rsi, 0x248(%rsp)
movq %rdx, 0x240(%rsp)
movq %rcx, 0x238(%rsp)
movq 0x250(%rsp), %rdx
leaq 0x218(%rsp), %rdi
leaq 0x248(%rsp), %rsi
callq 0x4ccc90
leaq 0x218(%rsp), %rdi
movl $0x2a, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x328670
cmpq $-0x1, %r... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<pstd::array<pbrt::Point3<float>, 4> const&, pbrt::Frame const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, pstd::array<pbrt::Point3<float>, 4> const&, pbrt::Frame const&) | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x258, %rsp # imm = 0x258
movq %rdi, 0x250(%rsp)
movq %rsi, 0x248(%rsp)
movq %rdx, 0x240(%rsp)
movq %rcx, 0x238(%rsp)
movq 0x250(%rsp), %rdx
leaq 0x218(%rsp), %rdi
leaq 0x248(%rsp), %rsi
callq 0x4ccc90
leaq 0x218(%rsp), %rdi
movl $0x2a, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x328670
cmpq $-0x1, %r... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<char const (&) [13], char const (&) [11], char const (&) [13], float&, char const (&) [11], float&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [13], char const (&) [11], char const (&) [13], float&, char const (&)... | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x268, %rsp # imm = 0x268
movq 0x278(%rsp), %rax
movq 0x270(%rsp), %rax
movq %rdi, 0x260(%rsp)
movq %rsi, 0x258(%rsp)
movq %rdx, 0x250(%rsp)
movq %rcx, 0x248(%rsp)
movq %r8, 0x240(%rsp)
movq %r9, 0x238(%rsp)
movq 0x260(%rsp), %rdx
leaq 0x218(%rsp), %rdi
leaq 0x258(%rsp), %rsi
callq 0x4ccc90
leaq 0x218(... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
pbrt::MixMaterial::Create(pbrt::MaterialHandle*, pbrt::TextureParameterDictionary const&, pbrt::FileLoc const*, pstd::pmr::polymorphic_allocator<std::byte>) | MixMaterial *MixMaterial::Create(MaterialHandle materials[2],
const TextureParameterDictionary ¶meters,
const FileLoc *loc, Allocator alloc) {
FloatTextureHandle amount = parameters.GetFloatTexture("amount", 0.5f, alloc);
if (Options->useGPU... | subq $0xa8, %rsp
movq %rcx, 0xa0(%rsp)
movq %rdi, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
movq %rdx, 0x88(%rsp)
movq 0x90(%rsp), %rax
movq %rax, (%rsp)
leaq 0x5f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x3283e0
movq 0x8(%rsp), %rdx
leaq 0x2312b3(%rip), %rsi # 0x84c811
leaq 0x60(%rsp), %rdi
callq 0x334140
jmp 0x61b56a
movq (... | /anderslanglands[P]pbrt-v4/src/pbrt/materials.cpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.