name string | code string | asm string | file string |
|---|---|---|---|
float pbrt::Clamp<float, float, float>(float, float, float) | PBRT_CPU_GPU inline constexpr T Clamp(T val, U low, V high) {
if (val < low)
return low;
else if (val > high)
return high;
else
return val;
} | vmovss %xmm0, -0x8(%rsp)
vmovss %xmm1, -0xc(%rsp)
vmovss %xmm2, -0x10(%rsp)
vmovss -0x8(%rsp), %xmm1
vmovss -0xc(%rsp), %xmm0
vucomiss %xmm1, %xmm0
jbe 0x3c7122
vmovss -0xc(%rsp), %xmm0
vmovss %xmm0, -0x4(%rsp)
jmp 0x3c714a
vmovss -0x8(%rsp), %xmm0
vucomiss -0x10(%rsp), %xmm0
jbe 0x3c713e
vmovss -0x10(%rsp), %xmm0
vmov... | /anderslanglands[P]pbrt-v4/src/pbrt/util/math.h |
float pbrt::Clamp<float, int, int>(float, int, int) | PBRT_CPU_GPU inline constexpr T Clamp(T val, U low, V high) {
if (val < low)
return low;
else if (val > high)
return high;
else
return val;
} | vmovss %xmm0, -0x8(%rsp)
movl %edi, -0xc(%rsp)
movl %esi, -0x10(%rsp)
vmovss -0x8(%rsp), %xmm1
vcvtsi2ssl -0xc(%rsp), %xmm0, %xmm0
vucomiss %xmm1, %xmm0
jbe 0x3c767e
vcvtsi2ssl -0xc(%rsp), %xmm0, %xmm0
vmovss %xmm0, -0x4(%rsp)
jmp 0x3c76aa
vmovss -0x8(%rsp), %xmm0
vcvtsi2ssl -0x10(%rsp), %xmm1, %xmm1
vucomiss %xmm1, %x... | /anderslanglands[P]pbrt-v4/src/pbrt/util/math.h |
pstd::vector<pbrt::BilinearPatchMesh const*, pstd::pmr::polymorphic_allocator<pbrt::BilinearPatchMesh const*>>::push_back(pbrt::BilinearPatchMesh const* const&) | void push_back(const T &value) {
if (nAlloc == nStored)
reserve(nAlloc == 0 ? 4 : 2 * nAlloc);
alloc.construct(ptr + nStored, value);
++nStored;
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movq 0x10(%rcx), %rax
cmpq 0x18(%rcx), %rax
jne 0x3c961a
movq 0x10(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x3c95fa
movl $0x4, %eax
movq %rax, 0x8(%rsp)
jmp 0x3c960b
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
shlq %r... | /anderslanglands[P]pbrt-v4/src/pbrt/util/pstd.h |
pbrt::Interval<decltype((float)() / (float)())> pbrt::Interval<float>::operator/<float>(pbrt::Interval<float>) const | PBRT_CPU_GPU auto operator/(Interval<F> i) const
-> Interval<decltype(Float() / F())> {
using FR = decltype(Float() / F());
if (Exactly(0))
// Not going to worry about NaN...
return Interval<FR>(0);
if (i.Exactly(1))
return Interval<FR>(*this);
... | subq $0x98, %rsp
vmovlpd %xmm0, 0x88(%rsp)
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x18(%rsp)
vpxor %xmm0, %xmm0, %xmm0
callq 0x3ce950
testb $0x1, %al
jne 0x3ce6f4
jmp 0x3ce70a
leaq 0x90(%rsp), %rdi
vpxor %xmm0, %xmm0, %xmm0
callq 0x3ce920
jmp 0x3ce90d
leaq 0x88(%rsp), %rdi
vmovss 0x47ca3a(%rip), %xmm0 ... | /anderslanglands[P]pbrt-v4/src/pbrt/util/math.h |
void pbrt::LogFatal<char const (&) [18], char const (&) [2], char const (&) [18], float&, char const (&) [2], int&>(pbrt::LogLevel, char const*, int, char const*, char const (&) [18], char const (&) [2], char const (&) [18], float&, char const (&) [2], 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 |
pbrt::Interval<decltype((float)() + (float)())> pbrt::Interval<float>::operator+<float>(pbrt::Interval<float>) const | PBRT_CPU_GPU auto operator+(Interval<F> i) const
-> Interval<decltype(Float() + F())> {
using FR = decltype(Float() + F());
if (Exactly(0))
return Interval<FR>(i);
else if (i.Exactly(0))
return Interval<FR>(*this);
return Interval<FR>(NextFloatDown(LowerB... | subq $0x38, %rsp
vmovlpd %xmm0, 0x28(%rsp)
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x18(%rsp)
vpxor %xmm0, %xmm0, %xmm0
callq 0x3ce950
testb $0x1, %al
jne 0x3d1738
jmp 0x3d1747
movq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x3d17e0
leaq 0x28(%rsp), %rdi
vpxor %xmm0, %xmm0, %xmm0
callq 0x3ce950
testb $0... | /anderslanglands[P]pbrt-v4/src/pbrt/util/math.h |
pbrt::Quadratic(float, float, float, float*, float*) | PBRT_CPU_GPU
inline bool Quadratic(float a, float b, float c, float *t0, float *t1) {
// Find quadratic discriminant
float discrim = DifferenceOfProducts(b, b, 4 * a, c);
if (discrim < 0)
return false;
float rootDiscrim = std::sqrt(discrim);
if (a == 0) {
*t0 = *t1 = -c / b;
... | subq $0x38, %rsp
vmovss %xmm0, 0x30(%rsp)
vmovss %xmm1, 0x2c(%rsp)
vmovss %xmm2, 0x28(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
vmovss 0x2c(%rsp), %xmm0
vmovss 0x2c(%rsp), %xmm1
vmovss 0x47bbb4(%rip), %xmm2 # 0x84e3b8
vmulss 0x30(%rsp), %xmm2, %xmm2
vmovss 0x28(%rsp), %xmm3
callq 0x360980
vmovss %xmm0, 0x14(%... | /anderslanglands[P]pbrt-v4/src/pbrt/util/math.h |
void pbrt::detail::stringPrintfRecursive<char const (&) [64], char const (&) [6], char const (&) [64], float&, char const (&) [6], double&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [64], char const (&) [6], char const (&) [64], 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 |
void pbrt::detail::stringPrintfRecursive<char const (&) [64], float&, char const (&) [6], double&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [64], float&, char const (&) [6], double&) | 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<float const&, float const&, float const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, float const&, float const&, float 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 %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 |
void pbrt::detail::stringPrintfRecursive<float const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, float 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 $0x278, %rsp # imm = 0x278
movq %rdi, 0x270(%rsp)
movq %rsi, 0x268(%rsp)
movq %rdx, 0x260(%rsp)
movq 0x270(%rsp), %rdx
leaq 0x240(%rsp), %rdi
leaq 0x268(%rsp), %rsi
callq 0x4ccc90
leaq 0x240(%rsp), %rdi
movl $0x2a, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x328670
cmpq $-0x1, %rax
setne %al
andb $0x1,... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
pbrt::Disk::Disk(pbrt::Transform const*, pbrt::Transform const*, bool, float, float, float, float) | Disk(const Transform *renderFromObject, const Transform *objectFromRender,
bool reverseOrientation, Float height, Float radius, Float innerRadius,
Float phiMax)
: renderFromObject(renderFromObject),
objectFromRender(objectFromRender),
reverseOrientation(reverseOrientation),... | subq $0x38, %rsp
movb %cl, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
vmovss %xmm0, 0x18(%rsp)
vmovss %xmm1, 0x14(%rsp)
vmovss %xmm2, 0x10(%rsp)
vmovss %xmm3, 0xc(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
movq 0x2... | /anderslanglands[P]pbrt-v4/src/pbrt/shapes.h |
pbrt::Tuple3<pbrt::Point3, float>::operator[](int) const | PBRT_CPU_GPU
T operator[](int i) const {
DCHECK(i >= 0 && i <= 2);
if (i == 0)
return x;
if (i == 1)
return y;
return z;
} | movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
cmpl $0x0, -0x14(%rsp)
jne 0x3d9d1b
movq -0x20(%rsp), %rax
vmovss (%rax), %xmm0
vmovss %xmm0, -0x4(%rsp)
jmp 0x3d9d44
cmpl $0x1, -0x14(%rsp)
jne 0x3d9d34
movq -0x20(%rsp), %rax
vmovss 0x4(%rax), %xmm0
vmovss %xmm0, -0x4(%rsp)
jm... | /anderslanglands[P]pbrt-v4/src/pbrt/util/vecmath.h |
pstd::vector<pbrt::TriangleMesh const*, pstd::pmr::polymorphic_allocator<pbrt::TriangleMesh const*>>::reserve(unsigned long) | void reserve(size_t n) {
if (nAlloc >= n)
return;
T *ra = alloc.template allocate_object<T>(n);
for (int i = 0; i < nStored; ++i) {
alloc.template construct<T>(ra + i, std::move(begin()[i]));
alloc.destroy(begin() + i);
}
alloc.deallocate_obj... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rax), %rax
cmpq 0x28(%rsp), %rax
jb 0x3db0b8
jmp 0x3db17b
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x3db1a0
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rcx
movslq 0x1c(%rsp), %r... | /anderslanglands[P]pbrt-v4/src/pbrt/util/pstd.h |
pstd::vector<pbrt::ShapeHandle, pstd::pmr::polymorphic_allocator<pbrt::ShapeHandle>>::vector(unsigned long, pbrt::ShapeHandle const&, pstd::pmr::polymorphic_allocator<pbrt::ShapeHandle> const&) | vector(size_t count, const T &value, const Allocator &alloc = {}) : alloc(alloc) {
reserve(count);
for (size_t i = 0; i < count; ++i)
this->alloc.template construct<T>(ptr + i, value);
nStored = count;
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movq 0x28(%rsp), %rsi
callq 0x3db3c0
movq $0x0, 0... | /anderslanglands[P]pbrt-v4/src/pbrt/util/pstd.h |
void pbrt::detail::stringPrintfRecursive<pbrt::Point3<float> const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, pbrt::Point3<float> 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 $0x248, %rsp # imm = 0x248
movq %rdi, 0x240(%rsp)
movq %rsi, 0x238(%rsp)
movq %rdx, 0x230(%rsp)
movq 0x240(%rsp), %rdx
leaq 0x210(%rsp), %rdi
leaq 0x238(%rsp), %rsi
callq 0x4ccc90
leaq 0x210(%rsp), %rdi
movl $0x2a, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x328670
cmpq $-0x1, %rax
setne %al
andb $0x1,... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<char const (&) [2], char const (&) [9], unsigned long&, char const (&) [2], int&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [2], char const (&) [9], unsigned long&, 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<char const (&) [9], unsigned long&, char const (&) [2], int&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [9], unsigned long&, 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<unsigned long&, char const (&) [2], int&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, unsigned long&, 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 $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 |
void pbrt::detail::stringPrintfRecursive<pstd::span<float const>, pstd::span<pbrt::Normal3<float> const>, float const&, float const&, pbrt::Transform const&, pbrt::Transform const&, bool const&, bool const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, pstd::span<float 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... | pushq %rbx
subq $0x280, %rsp # imm = 0x280
movq 0x2a8(%rsp), %rax
movq 0x2a0(%rsp), %rax
movq 0x298(%rsp), %rax
movq 0x290(%rsp), %rax
movq %rdi, 0x278(%rsp)
movq %rsi, 0x270(%rsp)
movq %rdx, 0x268(%rsp)
movq %rcx, 0x260(%rsp)
movq %r8, 0x258(%rsp)
movq %r9, 0x250(%rsp)
movq 0x278(%rsp), %rdx
leaq 0x230(%rsp... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
std::enable_if<HasSize<pstd::span<float const>>::value && HasData<pstd::span<float const>>::value, std::ostream&>::type pbrt::detail::operator<<<pstd::span<float const>>(std::ostream&, pstd::span<float const> const&) | inline std::enable_if_t<HasSize<T>::value && HasData<T>::value, std::ostream &>
operator<<(std::ostream &os, const T &v) {
os << "[ ";
auto ptr = v.data();
for (size_t i = 0; i < v.size(); ++i) {
os << ptr[i];
if (i < v.size() - 1)
os << ", ";
}
return os << " ]";
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x288a945(%rip), %rsi # 0x2c6cdff
callq 0x327c20
movq 0x28(%rsp), %rdi
callq 0x3e2960
movq %rax, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x3e2970
movq %rax, %rcx
mov... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
std::enable_if<HasSize<pstd::span<pbrt::Normal3<float> const>>::value && HasData<pstd::span<pbrt::Normal3<float> const>>::value, std::ostream&>::type pbrt::detail::operator<<<pstd::span<pbrt::Normal3<float> const>>(std::ostream&, pstd::span<pbrt::Normal3<float> const> const&) | inline std::enable_if_t<HasSize<T>::value && HasData<T>::value, std::ostream &>
operator<<(std::ostream &os, const T &v) {
os << "[ ";
auto ptr = v.data();
for (size_t i = 0; i < v.size(); ++i) {
os << ptr[i];
if (i < v.size() - 1)
os << ", ";
}
return os << " ]";
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x288a465(%rip), %rsi # 0x2c6cdff
callq 0x327c20
movq 0x28(%rsp), %rdi
callq 0x3e2ee0
movq %rax, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x3c5220
movq %rax, %rcx
mov... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<float const&, float const&, pbrt::Transform const&, pbrt::Transform const&, bool const&, bool const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, float const&, float const&, pbrt::Transform const&, pbrt::Transform const&, bool co... | 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 $0x298, %rsp # imm = 0x298
movq 0x2a8(%rsp), %rax
movq 0x2a0(%rsp), %rax
movq %rdi, 0x290(%rsp)
movq %rsi, 0x288(%rsp)
movq %rdx, 0x280(%rsp)
movq %rcx, 0x278(%rsp)
movq %r8, 0x270(%rsp)
movq %r9, 0x268(%rsp)
movq 0x290(%rsp), %rdx
leaq 0x248(%rsp), %rdi
leaq 0x288(%rsp), %rsi
callq 0x4ccc90
leaq 0x248(... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<pbrt::Transform const&, bool const&, bool const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, pbrt::Transform const&, bool 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 $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<bool const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char 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 $0x278, %rsp # imm = 0x278
movq %rdi, 0x270(%rsp)
movq %rsi, 0x268(%rsp)
movq %rdx, 0x260(%rsp)
movq 0x270(%rsp), %rdx
leaq 0x240(%rsp), %rdi
leaq 0x268(%rsp), %rsi
callq 0x4ccc90
leaq 0x240(%rsp), %rdi
movl $0x2a, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x328670
cmpq $-0x1, %rax
setne %al
andb $0x1,... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<char const (&) [5], char const (&) [18], pbrt::Vector3<float>&, char const (&) [5], pbrt::Vector3<float>&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [5], char const (&) [18], pbrt::Vector3<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 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<pbrt::Vector3<float>&, char const (&) [5], pbrt::Vector3<float>&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, pbrt::Vector3<float>&, char const (&) [5], pbrt::Vector3<float>&) | 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<char const (&) [5], pbrt::Vector3<float>&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [5], pbrt::Vector3<float>&) | 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<int&, int, int&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, int&, int&&, 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 |
void pbrt::detail::stringPrintfRecursive<int, int&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, int&&, 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 0x280(%rsp), %rdx
leaq 0x248(%rsp), %rdi
leaq 0x278(%rsp), %rsi
callq 0x4ccc90
leaq 0x248(%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<int>::type>::value, void>::type pbrt::detail::stringPrintfRecursiveWithPrecision<int, int&>(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&, int, i... | 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), %rax
movl (%rax), %r8d
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0x32... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<int, int, int&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, int&&, int&&, 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 |
pstd::vector<pbrt::ShapeHandle, pstd::pmr::polymorphic_allocator<pbrt::ShapeHandle>>::push_back(pbrt::ShapeHandle const&) | void push_back(const T &value) {
if (nAlloc == nStored)
reserve(nAlloc == 0 ? 4 : 2 * nAlloc);
alloc.construct(ptr + nStored, value);
++nStored;
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movq 0x10(%rcx), %rax
cmpq 0x18(%rcx), %rax
jne 0x3e7e2a
movq 0x10(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x3e7e0a
movl $0x4, %eax
movq %rax, 0x8(%rsp)
jmp 0x3e7e1b
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
shlq %r... | /anderslanglands[P]pbrt-v4/src/pbrt/util/pstd.h |
void pbrt::detail::stringPrintfRecursive<pbrt::Point2<float> const&, float const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, pbrt::Point2<float> const&, float 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 |
pstd::vector<pbrt::PiecewiseConstant1D, pstd::pmr::polymorphic_allocator<pbrt::PiecewiseConstant1D>>::reserve(unsigned long) | void reserve(size_t n) {
if (nAlloc >= n)
return;
T *ra = alloc.template allocate_object<T>(n);
for (int i = 0; i < nStored; ++i) {
alloc.template construct<T>(ra + i, std::move(begin()[i]));
alloc.destroy(begin() + i);
}
alloc.deallocate_obj... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rax), %rax
cmpq 0x28(%rsp), %rax
jb 0x3e8d48
jmp 0x3e8e0b
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x3eae40
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rcx
movslq 0x1c(%rsp), %r... | /anderslanglands[P]pbrt-v4/src/pbrt/util/pstd.h |
pbrt::PiecewiseConstant1D::PiecewiseConstant1D(pstd::span<float const>, float, float, pstd::pmr::polymorphic_allocator<std::byte>) | PiecewiseConstant1D(pstd::span<const Float> f, Float min, Float max,
Allocator alloc = {})
: func(f.begin(), f.end(), alloc), cdf(f.size() + 1, alloc), min(min), max(max) {
CHECK_GT(max, min);
// Compute integral of step function at $x_i$
cdf[0] = 0;
size_... | subq $0x148, %rsp # imm = 0x148
movq %rsi, 0x138(%rsp)
movq %rdx, 0x140(%rsp)
movq %rcx, 0x130(%rsp)
movq %rdi, 0x128(%rsp)
vmovss %xmm0, 0x124(%rsp)
vmovss %xmm1, 0x120(%rsp)
movq 0x128(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq %rax, 0x80(%rsp)
leaq 0x138(%rsp), %rdi
movq %rdi, 0xa8(%rsp)
callq 0x3eb8d0
movq 0... | /anderslanglands[P]pbrt-v4/src/pbrt/util/sampling.h |
void pbrt::detail::stringPrintfRecursive<char const (&) [12], char const (&) [24], char const (&) [12], unsigned long&, char const (&) [24], unsigned long&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [12], char const (&) [24], char const (&) [12], unsign... | 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 (&) [24], unsigned long&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [24], 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 $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 |
pstd::vector<float, pstd::pmr::polymorphic_allocator<float>>::vector<float const*>(float const*, float const*, pstd::pmr::polymorphic_allocator<float> const&) | vector(InputIt first, InputIt last, const Allocator &alloc = {}) : alloc(alloc) {
reserve(last - first);
size_t i = 0;
for (InputIt iter = first; iter != last; ++iter, ++i)
this->alloc.template construct<T>(ptr + i, *iter);
nStored = nAlloc;
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rax
subq %ra... | /anderslanglands[P]pbrt-v4/src/pbrt/util/pstd.h |
void pbrt::LogFatal<char const (&) [4], char const (&) [4], char const (&) [4], float&, char const (&) [4], float&>(pbrt::LogLevel, char const*, int, char const*, char const (&) [4], char const (&) [4], char const (&) [4], float&, char const (&) [4], float&) | 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 |
pstd::vector<float, pstd::pmr::polymorphic_allocator<float>>::reserve(unsigned long) | void reserve(size_t n) {
if (nAlloc >= n)
return;
T *ra = alloc.template allocate_object<T>(n);
for (int i = 0; i < nStored; ++i) {
alloc.template construct<T>(ra + i, std::move(begin()[i]));
alloc.destroy(begin() + i);
}
alloc.deallocate_obj... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rax), %rax
cmpq 0x28(%rsp), %rax
jb 0x3ebc38
jmp 0x3ebcfb
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x3ebd30
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rcx
movslq 0x1c(%rsp), %r... | /anderslanglands[P]pbrt-v4/src/pbrt/util/pstd.h |
pstd::vector<float, pstd::pmr::polymorphic_allocator<float>>::vector(unsigned long, float const&, pstd::pmr::polymorphic_allocator<float> const&) | vector(size_t count, const T &value, const Allocator &alloc = {}) : alloc(alloc) {
reserve(count);
for (size_t i = 0; i < count; ++i)
this->alloc.template construct<T>(ptr + i, value);
nStored = count;
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movq 0x28(%rsp), %rsi
callq 0x3ebc10
movq $0x0, 0... | /anderslanglands[P]pbrt-v4/src/pbrt/util/pstd.h |
void pbrt::detail::stringPrintfRecursive<char const (&) [4], char const (&) [4], char const (&) [4], float&, char const (&) [4], float&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [4], char const (&) [4], char const (&) [4], float&, char const (&) [4], f... | 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<float&, char const (&) [4], float&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, float&, char const (&) [4], float&) | 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 $0x278, %rsp # imm = 0x278
movq %rdi, 0x270(%rsp)
movq %rsi, 0x268(%rsp)
movq %rdx, 0x260(%rsp)
movq %rcx, 0x258(%rsp)
movq %r8, 0x250(%rsp)
movq 0x270(%rsp), %rdx
leaq 0x230(%rsp), %rdi
leaq 0x268(%rsp), %rsi
callq 0x4ccc90
leaq 0x230(%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<char const (&) [12], char const (&) [2], char const (&) [12], float&, char const (&) [2], int&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [12], char const (&) [2], char const (&) [12], float&, char const (&) [2],... | 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 |
pstd::vector<float, pstd::pmr::polymorphic_allocator<float>>::operator=(pstd::vector<float, pstd::pmr::polymorphic_allocator<float>>&&) | vector &operator=(vector &&other) {
if (this == &other)
return *this;
if (alloc == other.alloc) {
pstd::swap(ptr, other.ptr);
pstd::swap(nAlloc, other.nAlloc);
pstd::swap(nStored, other.nStored);
} else {
clear();
reserve(o... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq 0x20(%rsp), %rax
jne 0x3edb2e
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x3edc41
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x3edc50
testb $0x1, %al
jne 0x3edb43
jmp 0x3edb8d
movq 0x10(%rsp), %rdi
... | /anderslanglands[P]pbrt-v4/src/pbrt/util/pstd.h |
void pbrt::detail::stringPrintfRecursive<int const&, int const&, float const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, int const&, int const&, float 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 %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 |
std::enable_if<!std::is_class<std::decay<float const&>::type>::value, void>::type pbrt::detail::stringPrintfRecursiveWithPrecision<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>> co... | 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 0x70(%rsp), %rdi
callq 0x327260
movq %rax, %rdx
movl 0x6c(%rsp), %ecx
movq 0x60(%rsp), %rax
vmovss (%rax), %xmm1
vcvtss2sd %xmm1, %xmm0, %xmm0
xorl %eax, %eax
movl %eax, %esi
movb $0x1, %al... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<pbrt::Interaction const&, float const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, pbrt::Interaction const&, float 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 |
pbrt::TextureMapping2DHandle::Create(pbrt::ParameterDictionary const&, pbrt::Transform const&, pbrt::FileLoc const*, pstd::pmr::polymorphic_allocator<std::byte>) | TextureMapping2DHandle TextureMapping2DHandle::Create(
const ParameterDictionary ¶meters, const Transform &renderFromTexture,
const FileLoc *loc, Allocator alloc) {
std::string type = parameters.GetOneString("mapping", "uv");
if (type == "uv") {
Float su = parameters.GetOneFloat("uscale", 1.... | subq $0x4a8, %rsp # imm = 0x4A8
movq %rdi, 0x148(%rsp)
movq %rdi, %rax
movq %rax, 0x150(%rsp)
movq %rdi, 0x4a0(%rsp)
movq %r8, 0x498(%rsp)
movq %rsi, 0x490(%rsp)
movq %rdx, 0x488(%rsp)
movq %rcx, 0x480(%rsp)
movq 0x490(%rsp), %rax
movq %rax, 0x158(%rsp)
leaq 0x43f(%rsp), %rdi
movq %rdi, 0x160(%rsp)
callq 0x3... | /anderslanglands[P]pbrt-v4/src/pbrt/textures.cpp |
pbrt::FloatBilerpTexture::Create(pbrt::Transform const&, pbrt::TextureParameterDictionary const&, pbrt::FileLoc const*, pstd::pmr::polymorphic_allocator<std::byte>) | FloatBilerpTexture *FloatBilerpTexture::Create(
const Transform &renderFromTexture, const TextureParameterDictionary ¶meters,
const FileLoc *loc, Allocator alloc) {
// Initialize 2D texture mapping _map_ from _tp_
TextureMapping2DHandle map =
TextureMapping2DHandle::Create(parameters, render... | subq $0x158, %rsp # imm = 0x158
movq %rcx, 0x150(%rsp)
movq %rdi, 0x148(%rsp)
movq %rsi, 0x140(%rsp)
movq %rdx, 0x138(%rsp)
movq 0x140(%rsp), %rdi
callq 0x3fd4f0
movq %rax, %rsi
movq 0x148(%rsp), %rdx
movq 0x138(%rsp), %rcx
movq 0x150(%rsp), %rax
movq %rax, 0x128(%rsp)
movq 0x128(%rsp), %r8
leaq 0x130(%rsp),... | /anderslanglands[P]pbrt-v4/src/pbrt/textures.cpp |
pbrt::Checkerboard(pbrt::AAMethod, pbrt::TextureEvalContext, pbrt::TextureMapping2DHandle, pbrt::TextureMapping3DHandle) | pstd::array<Float, 2> Checkerboard(AAMethod aaMethod, TextureEvalContext ctx,
const TextureMapping2DHandle map2D,
const TextureMapping3DHandle map3D) {
if (map2D) {
CHECK(!map3D);
Vector2f dstdx, dstdy;
Point2f st = map2D.... | subq $0x278, %rsp # imm = 0x278
movq %rdx, 0x88(%rsp)
movq %rsi, 0x90(%rsp)
movl %edi, %eax
movq 0x90(%rsp), %rdi
leaq 0x280(%rsp), %rcx
movq %rcx, 0x98(%rsp)
movl %eax, 0x26c(%rsp)
movq %rdi, 0x260(%rsp)
movq %rdx, 0x258(%rsp)
callq 0x3fd780
testb $0x1, %al
jne 0x3f2776
jmp 0x3f2dcf
movq 0x88(%rsp), %rdi
ca... | /anderslanglands[P]pbrt-v4/src/pbrt/textures.cpp |
pbrt::SpectrumCheckerboardTexture::ToString[abi:cxx11]() const | std::string SpectrumCheckerboardTexture::ToString() const {
return StringPrintf("[ SpectrumCheckerboardTexture map2D: %s map3D: %s "
"tex[0]: %s tex[1]: %s aaMethod: %s]",
map2D ? map2D.ToString().c_str() : "(nullptr)",
map3D ? map3D.ToString()... | subq $0xc8, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xb8(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x3fd780
movb $0x0, 0x8f(%rsp)
testb $0x1, %al
jne 0x3f3fb4
jmp 0x3f3fe2
movq 0x38(%rsp), %rsi
leaq 0x90(%rsp), %rdi
callq 0x3fdce0
movb $0x1, 0x8f(%... | /anderslanglands[P]pbrt-v4/src/pbrt/textures.cpp |
pbrt::FloatDotsTexture::Create(pbrt::Transform const&, pbrt::TextureParameterDictionary const&, pbrt::FileLoc const*, pstd::pmr::polymorphic_allocator<std::byte>) | FloatDotsTexture *FloatDotsTexture::Create(const Transform &renderFromTexture,
const TextureParameterDictionary ¶meters,
const FileLoc *loc, Allocator alloc) {
// Initialize 2D texture mapping _map_ from _tp_
TextureMappin... | subq $0xd8, %rsp
movq %rcx, 0xd0(%rsp)
movq %rdi, 0xc8(%rsp)
movq %rsi, 0xc0(%rsp)
movq %rdx, 0xb8(%rsp)
movq 0xc0(%rsp), %rdi
callq 0x3fd4f0
movq %rax, %rsi
movq 0xc8(%rsp), %rdx
movq 0xb8(%rsp), %rcx
movq 0xd0(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0xa8(%rsp), %r8
leaq 0xb0(%rsp), %rdi
callq 0x3f0b50
movq 0xc0(%rsp),... | /anderslanglands[P]pbrt-v4/src/pbrt/textures.cpp |
pbrt::FBmTexture::Create(pbrt::Transform const&, pbrt::TextureParameterDictionary const&, pbrt::FileLoc const*, pstd::pmr::polymorphic_allocator<std::byte>) | FBmTexture *FBmTexture::Create(const Transform &renderFromTexture,
const TextureParameterDictionary ¶meters,
const FileLoc *loc, Allocator alloc) {
// Initialize 3D texture mapping _map_ from _tp_
TextureMapping3DHandle map =
TextureMappi... | subq $0xd8, %rsp
movq %rcx, 0xd0(%rsp)
movq %rdi, 0xc8(%rsp)
movq %rsi, 0xc0(%rsp)
movq %rdx, 0xb8(%rsp)
movq 0xc0(%rsp), %rdi
callq 0x3fd4f0
movq %rax, %rsi
movq 0xc8(%rsp), %rdx
movq 0xb8(%rsp), %rcx
movq 0xd0(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0xa8(%rsp), %r8
leaq 0xb0(%rsp), %rdi
callq 0x3f1700
movq 0xc0(%rsp),... | /anderslanglands[P]pbrt-v4/src/pbrt/textures.cpp |
pbrt::SpectrumImageTexture::Evaluate(pbrt::TextureEvalContext, pbrt::SampledWavelengths) const | SampledSpectrum SpectrumImageTexture::Evaluate(TextureEvalContext ctx,
SampledWavelengths lambda) const {
#ifdef PBRT_IS_GPU_CODE
assert(!"Should not be called in GPU code");
return SampledSpectrum(0);
#else
if (!mipmap)
return SampledSpectrum(scale);
... | subq $0x1d8, %rsp # imm = 0x1D8
leaq 0x220(%rsp), %rax
movq %rax, 0x90(%rsp)
leaq 0x1e0(%rsp), %rax
movq %rax, 0x98(%rsp)
movq %rdi, 0x1c0(%rsp)
movq 0x1c0(%rsp), %rax
movq %rax, 0xa0(%rsp)
cmpq $0x0, 0x10(%rax)
jne 0x3f4ec5
movq 0xa0(%rsp), %rax
vmovss 0x8(%rax), %xmm0
leaq 0x1c8(%rsp), %rdi
callq 0x3fea10
... | /anderslanglands[P]pbrt-v4/src/pbrt/textures.cpp |
pbrt::SpectrumImageTexture::Create(pbrt::Transform const&, pbrt::TextureParameterDictionary const&, pbrt::FileLoc const*, pstd::pmr::polymorphic_allocator<std::byte>) | SpectrumImageTexture *SpectrumImageTexture::Create(
const Transform &renderFromTexture, const TextureParameterDictionary ¶meters,
const FileLoc *loc, Allocator alloc) {
// Initialize 2D texture mapping _map_ from _tp_
TextureMapping2DHandle map =
TextureMapping2DHandle::Create(parameters, re... | subq $0x398, %rsp # imm = 0x398
movq %rcx, 0x390(%rsp)
movq %rdi, 0x388(%rsp)
movq %rsi, 0x380(%rsp)
movq %rdx, 0x378(%rsp)
movq 0x380(%rsp), %rdi
callq 0x3fd4f0
movq %rax, %rsi
movq 0x388(%rsp), %rdx
movq 0x378(%rsp), %rcx
movq 0x390(%rsp), %rax
movq %rax, 0x368(%rsp)
movq 0x368(%rsp), %r8
leaq 0x370(%rsp),... | /anderslanglands[P]pbrt-v4/src/pbrt/textures.cpp |
pbrt::MarbleTexture::Create(pbrt::Transform const&, pbrt::TextureParameterDictionary const&, pbrt::FileLoc const*, pstd::pmr::polymorphic_allocator<std::byte>) | MarbleTexture *MarbleTexture::Create(const Transform &renderFromTexture,
const TextureParameterDictionary ¶meters,
const FileLoc *loc, Allocator alloc) {
// Initialize 3D texture mapping _map_ from _tp_
TextureMapping3DHandle map =
... | subq $0x158, %rsp # imm = 0x158
movq %rcx, 0x150(%rsp)
movq %rdi, 0x148(%rsp)
movq %rsi, 0x140(%rsp)
movq %rdx, 0x138(%rsp)
movq 0x140(%rsp), %rdi
callq 0x3fd4f0
movq %rax, %rsi
movq 0x148(%rsp), %rdx
movq 0x138(%rsp), %rcx
movq 0x150(%rsp), %rax
movq %rax, 0x128(%rsp)
movq 0x128(%rsp), %r8
leaq 0x130(%rsp),... | /anderslanglands[P]pbrt-v4/src/pbrt/textures.cpp |
pbrt::FloatMixTexture::Create(pbrt::Transform const&, pbrt::TextureParameterDictionary const&, pbrt::FileLoc const*, pstd::pmr::polymorphic_allocator<std::byte>) | FloatMixTexture *FloatMixTexture::Create(const Transform &renderFromTexture,
const TextureParameterDictionary ¶meters,
const FileLoc *loc, Allocator alloc) {
return alloc.new_object<FloatMixTexture>(
parameters.GetFloatTex... | subq $0x118, %rsp # imm = 0x118
movq %rcx, 0x110(%rsp)
movq %rdi, 0x108(%rsp)
movq %rsi, 0x100(%rsp)
movq %rdx, 0xf8(%rsp)
movq 0x100(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0xcf(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x3283e0
movq 0x38(%rsp), %rdx
leaq 0x4550ea(%rip), %rsi # 0x84c44c
leaq 0xd0(%rsp), %rd... | /anderslanglands[P]pbrt-v4/src/pbrt/textures.cpp |
pbrt::SpectrumMixTexture::Create(pbrt::Transform const&, pbrt::TextureParameterDictionary const&, pbrt::FileLoc const*, pstd::pmr::polymorphic_allocator<std::byte>) | SpectrumMixTexture *SpectrumMixTexture::Create(
const Transform &renderFromTexture, const TextureParameterDictionary ¶meters,
const FileLoc *loc, Allocator alloc) {
SpectrumHandle zero = alloc.new_object<ConstantSpectrum>(0.);
SpectrumHandle one = alloc.new_object<ConstantSpectrum>(1.);
return a... | subq $0x148, %rsp # imm = 0x148
movq %rcx, 0x140(%rsp)
movq %rdi, 0x138(%rsp)
movq %rsi, 0x130(%rsp)
movq %rdx, 0x128(%rsp)
movq $0x0, 0x118(%rsp)
leaq 0x140(%rsp), %rdi
movq %rdi, 0x28(%rsp)
leaq 0x118(%rsp), %rsi
callq 0x3fd3f0
movq %rax, %rsi
leaq 0x120(%rsp), %rdi
callq 0x3fd440
movq 0x28(%rsp), %rdi
mov... | /anderslanglands[P]pbrt-v4/src/pbrt/textures.cpp |
pbrt::PtexTextureBase::ReportStats() | void PtexTextureBase::ReportStats() {
if (!cache)
return;
Ptex::PtexCache::Stats stats;
cache->getStats(stats);
nFilesAccessed += stats.filesAccessed;
nBlockReads += stats.blockReads;
peakMemoryUsed = std::max(peakMemoryUsed, int64_t(stats.peakMemUsed));
} | subq $0x48, %rsp
cmpq $0x0, 0x305b48c(%rip) # 0x3453078
jne 0x3f7bf3
jmp 0x3f7c75
movq 0x305b47e(%rip), %rdi # 0x3453078
movq (%rdi), %rax
leaq 0x10(%rsp), %rsi
callq *0x48(%rax)
movq 0x30(%rsp), %rcx
movq %fs:0x0, %rax
leaq -0x5c8(%rax), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq 0x40(%rsp), %rcx
movq %fs:0x0, ... | /anderslanglands[P]pbrt-v4/src/pbrt/textures.cpp |
pbrt::FloatPtexTexture::Evaluate(pbrt::TextureEvalContext) const | Float FloatPtexTexture::Evaluate(TextureEvalContext ctx) const {
#ifdef PBRT_IS_GPU_CODE
LOG_FATAL("Ptex not supported with GPU renderer");
return 0;
#else
float result[3];
int nc = SampleTexture(ctx, result);
if (nc == 1)
return result[0];
DCHECK_EQ(3, nc);
return (result[0] + resul... | subq $0xa8, %rsp
leaq 0xb0(%rsp), %rsi
movq %rdi, 0x98(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
movl $0x40, %edx
callq 0x327170
movq 0x40(%rsp), %rdi
leaq 0x8c(%rsp), %rsi
vmovdqu64 0x48(%rsp), %zmm0
movq %rsp, %rax
vmovdqu64 %zmm0, (%rax)
vzeroupper
callq 0x3f7c80
movl %eax, 0x88(%rsp)
c... | /anderslanglands[P]pbrt-v4/src/pbrt/textures.cpp |
pbrt::SpectrumPtexTexture::Evaluate(pbrt::TextureEvalContext, pbrt::SampledWavelengths) const | SampledSpectrum SpectrumPtexTexture::Evaluate(TextureEvalContext ctx,
SampledWavelengths lambda) const {
#ifdef PBRT_IS_GPU_CODE
LOG_FATAL("Ptex not supported with GPU renderer");
return SampledSpectrum(0);
#else
float result[3];
int nc = SampleTexture(ctx, ... | subq $0xf8, %rsp
leaq 0x140(%rsp), %rax
movq %rax, 0x58(%rsp)
leaq 0x100(%rsp), %rsi
movq %rdi, 0xe0(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x90(%rsp), %rdi
movl $0x40, %edx
callq 0x327170
movq 0x60(%rsp), %rdi
leaq 0xd4(%rsp), %rsi
vmovdqu64 0x90(%rsp), %zmm0
movq %rsp, %rax
vmovdqu64 %zmm0, (%rax)
vze... | /anderslanglands[P]pbrt-v4/src/pbrt/textures.cpp |
pbrt::SpectrumScaledTexture::Create(pbrt::Transform const&, pbrt::TextureParameterDictionary const&, pbrt::FileLoc const*, pstd::pmr::polymorphic_allocator<std::byte>) | SpectrumTextureHandle SpectrumScaledTexture::Create(
const Transform &renderFromTexture, const TextureParameterDictionary ¶meters,
const FileLoc *loc, Allocator alloc) {
SpectrumHandle one = alloc.new_object<ConstantSpectrum>(1.);
SpectrumTextureHandle tex =
parameters.GetSpectrumTexture("te... | subq $0x198, %rsp # imm = 0x198
movq %rdi, 0x58(%rsp)
movq %rdi, %rax
movq %rax, 0x60(%rsp)
movq %rdi, 0x190(%rsp)
movq %r8, 0x188(%rsp)
movq %rsi, 0x180(%rsp)
movq %rdx, 0x178(%rsp)
movq %rcx, 0x170(%rsp)
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x160(%rsp)
leaq 0x188(%rsp), %... | /anderslanglands[P]pbrt-v4/src/pbrt/textures.cpp |
pbrt::$_8::operator void (*)(pbrt::StatsAccumulator&)() const | FloatTextureHandle FloatTextureHandle::Create(
const std::string &name, const Transform &renderFromTexture,
const TextureParameterDictionary ¶meters, const FileLoc *loc, Allocator alloc,
bool gpu) {
FloatTextureHandle tex;
if (name == "constant")
tex = FloatConstantTexture::Create(render... | movq %rdi, -0x8(%rsp)
leaq 0x29a4(%rip), %rax # 0x3fbfb0
retq
nopl (%rax)
| /anderslanglands[P]pbrt-v4/src/pbrt/textures.cpp |
pbrt::FloatTextureHandle::Create(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, pbrt::Transform const&, pbrt::TextureParameterDictionary const&, pbrt::FileLoc const*, pstd::pmr::polymorphic_allocator<std::byte>, bool) | FloatTextureHandle FloatTextureHandle::Create(
const std::string &name, const Transform &renderFromTexture,
const TextureParameterDictionary ¶meters, const FileLoc *loc, Allocator alloc,
bool gpu) {
FloatTextureHandle tex;
if (name == "constant")
tex = FloatConstantTexture::Create(render... | subq $0x108, %rsp # imm = 0x108
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movb 0x110(%rsp), %al
movq %rdi, 0x100(%rsp)
movq %r9, 0xf8(%rsp)
movq %rsi, 0xf0(%rsp)
movq %rdx, 0xe8(%rsp)
movq %rcx, 0xe0(%rsp)
movq %r8, 0xd8(%rsp)
andb $0x1, %al
movb %al, 0xd7(%rsp)
callq 0x38ccc0
movq 0xf0(%rsp), %... | /anderslanglands[P]pbrt-v4/src/pbrt/textures.cpp |
pbrt::SpectrumTextureHandle::Create(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, pbrt::Transform const&, pbrt::TextureParameterDictionary const&, pbrt::FileLoc const*, pstd::pmr::polymorphic_allocator<std::byte>, bool) | SpectrumTextureHandle SpectrumTextureHandle::Create(
const std::string &name, const Transform &renderFromTexture,
const TextureParameterDictionary ¶meters, const FileLoc *loc, Allocator alloc,
bool gpu) {
SpectrumTextureHandle tex;
if (name == "constant")
tex = SpectrumConstantTexture::C... | subq $0xe8, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movb 0xf0(%rsp), %al
movq %rdi, 0xe0(%rsp)
movq %r9, 0xd8(%rsp)
movq %rsi, 0xd0(%rsp)
movq %rdx, 0xc8(%rsp)
movq %rcx, 0xc0(%rsp)
movq %r8, 0xb8(%rsp)
andb $0x1, %al
movb %al, 0xb7(%rsp)
callq 0x38de00
movq 0xd0(%rsp), %rdi
leaq 0x4562c6(%rip), %rs... | /anderslanglands[P]pbrt-v4/src/pbrt/textures.cpp |
auto pbrt::detail::DispatchSplitCPU<6>::operator()<pbrt::FloatTextureHandle::ToString[abi:cxx11]() const::$_0, pbrt::TaggedPointer<pbrt::FloatImageTexture, pbrt::GPUFloatImageTexture, pbrt::FloatMixTexture, pbrt::FloatScaledTexture, pbrt::FloatConstantTexture, pbrt::FloatBilerpTexture, pbrt::FloatCheckerboardTexture, 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 $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 $0x3, 0x40(%rsp)
movl 0x44(%rsp), %eax
subl $0x1, %eax
cmpl $0x3, %eax
jge 0x3fa3b4
movq (%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x4... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplitCPU<6>::operator()<pbrt::FloatTextureHandle::ToString[abi:cxx11]() const::$_0, pbrt::TaggedPointer<pbrt::FloatImageTexture, pbrt::GPUFloatImageTexture, pbrt::FloatMixTexture, pbrt::FloatScaledTexture, pbrt::FloatConstantTexture, pbrt::FloatBilerpTexture, pbrt::FloatCheckerboardTexture, 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 $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 $0x3, 0x40(%rsp)
movl 0x44(%rsp), %eax
subl $0x1, %eax
cmpl $0x3, %eax
jge 0x3fa454
movq (%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x4... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplitCPU<2>::operator()<pbrt::FloatTextureHandle::ToString[abi:cxx11]() const::$_0, pbrt::TaggedPointer<pbrt::FloatImageTexture, pbrt::GPUFloatImageTexture, pbrt::FloatMixTexture, pbrt::FloatScaledTexture, pbrt::FloatConstantTexture, pbrt::FloatBilerpTexture, pbrt::FloatCheckerboardTexture, 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 $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 $0x1, 0x40(%rsp)
movl 0x44(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x3fa694
movq (%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x4... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplitCPU<2>::operator()<pbrt::FloatTextureHandle::ToString[abi:cxx11]() const::$_0, pbrt::TaggedPointer<pbrt::FloatImageTexture, pbrt::GPUFloatImageTexture, pbrt::FloatMixTexture, pbrt::FloatScaledTexture, pbrt::FloatConstantTexture, pbrt::FloatBilerpTexture, pbrt::FloatCheckerboardTexture, 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 $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 $0x1, 0x40(%rsp)
movl 0x44(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x3fa8e4
movq (%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x4... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplitCPU<3>::operator()<pbrt::FloatTextureHandle::ToString[abi:cxx11]() const::$_0, pbrt::TaggedPointer<pbrt::FloatImageTexture, pbrt::GPUFloatImageTexture, pbrt::FloatMixTexture, pbrt::FloatScaledTexture, pbrt::FloatConstantTexture, pbrt::FloatBilerpTexture, pbrt::FloatCheckerboardTexture, 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 $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 $0x1, 0x40(%rsp)
movl 0x44(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x3faad4
movq (%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x4... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplitCPU<3>::operator()<pbrt::FloatTextureHandle::ToString[abi:cxx11]() const::$_0, pbrt::TaggedPointer<pbrt::FloatImageTexture, pbrt::GPUFloatImageTexture, pbrt::FloatMixTexture, pbrt::FloatScaledTexture, pbrt::FloatConstantTexture, pbrt::FloatBilerpTexture, pbrt::FloatCheckerboardTexture, 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 $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 $0x1, 0x40(%rsp)
movl 0x44(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x3fab74
movq (%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x4... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplitCPU<2>::operator()<pbrt::FloatTextureHandle::ToString[abi:cxx11]() const::$_0, pbrt::TaggedPointer<pbrt::FloatImageTexture, pbrt::GPUFloatImageTexture, pbrt::FloatMixTexture, pbrt::FloatScaledTexture, pbrt::FloatConstantTexture, pbrt::FloatBilerpTexture, pbrt::FloatCheckerboardTexture, 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 $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 $0x1, 0x40(%rsp)
movl 0x44(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x3fac74
movq (%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x4... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplitCPU<2>::operator()<pbrt::FloatTextureHandle::ToString[abi:cxx11]() const::$_0, pbrt::TaggedPointer<pbrt::FloatImageTexture, pbrt::GPUFloatImageTexture, pbrt::FloatMixTexture, pbrt::FloatScaledTexture, pbrt::FloatConstantTexture, pbrt::FloatBilerpTexture, pbrt::FloatCheckerboardTexture, 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 $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 $0x1, 0x40(%rsp)
movl 0x44(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x3faec4
movq (%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x4... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplitCPU<12>::operator()<pbrt::SpectrumTextureHandle::ToString[abi:cxx11]() const::$_0, pbrt::TaggedPointer<pbrt::RGBConstantTexture, pbrt::RGBReflectanceConstantTexture, pbrt::SpectrumImageTexture, pbrt::GPUSpectrumImageTexture, pbrt::SpectrumMixTexture, pbrt::SpectrumScaledTexture, pbrt::Sp... | 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 %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 $0x6, 0x40(%rsp)
movl 0x44(%rsp), %eax
subl $0x1, %eax
cmpl $0x6, %eax
jge 0x3fb0b4
movq (%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x4... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplitCPU<3>::operator()<pbrt::SpectrumTextureHandle::ToString[abi:cxx11]() const::$_0, pbrt::TaggedPointer<pbrt::RGBConstantTexture, pbrt::RGBReflectanceConstantTexture, pbrt::SpectrumImageTexture, pbrt::GPUSpectrumImageTexture, pbrt::SpectrumMixTexture, pbrt::SpectrumScaledTexture, pbrt::Spe... | 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 %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 $0x1, 0x40(%rsp)
movl 0x44(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x3fb294
movq (%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x4... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplitCPU<3>::operator()<pbrt::SpectrumTextureHandle::ToString[abi:cxx11]() const::$_0, pbrt::TaggedPointer<pbrt::RGBConstantTexture, pbrt::RGBReflectanceConstantTexture, pbrt::SpectrumImageTexture, pbrt::GPUSpectrumImageTexture, pbrt::SpectrumMixTexture, pbrt::SpectrumScaledTexture, pbrt::Spe... | 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 %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 $0x1, 0x40(%rsp)
movl 0x44(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x3fb334
movq (%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x4... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplitCPU<3>::operator()<pbrt::SpectrumTextureHandle::ToString[abi:cxx11]() const::$_0, pbrt::TaggedPointer<pbrt::RGBConstantTexture, pbrt::RGBReflectanceConstantTexture, pbrt::SpectrumImageTexture, pbrt::GPUSpectrumImageTexture, pbrt::SpectrumMixTexture, pbrt::SpectrumScaledTexture, pbrt::Spe... | 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 %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 $0x1, 0x40(%rsp)
movl 0x44(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x3fb874
movq (%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x4... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplitCPU<3>::operator()<pbrt::SpectrumTextureHandle::ToString[abi:cxx11]() const::$_0, pbrt::TaggedPointer<pbrt::RGBConstantTexture, pbrt::RGBReflectanceConstantTexture, pbrt::SpectrumImageTexture, pbrt::GPUSpectrumImageTexture, pbrt::SpectrumMixTexture, pbrt::SpectrumScaledTexture, pbrt::Spe... | 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 %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 $0x1, 0x40(%rsp)
movl 0x44(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x3fb914
movq (%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x4... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
pbrt::$_8::operator()(pbrt::StatsAccumulator&) const | FloatTextureHandle FloatTextureHandle::Create(
const std::string &name, const Transform &renderFromTexture,
const TextureParameterDictionary ¶meters, const FileLoc *loc, Allocator alloc,
bool gpu) {
FloatTextureHandle tex;
if (name == "constant")
tex = FloatConstantTexture::Create(render... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq %fs:0x0, %rax
leaq -0x5a8(%rax), %rax
movq (%rax), %rdx
leaq 0x4540d0(%rip), %rsi # 0x8500cd
callq 0x4f0b60
movq %fs:0x0, %rax
leaq -0x5a8(%rax), %rax
movq $0x0, (%rax)
addq $0x18, %rsp
retq
nop
| /anderslanglands[P]pbrt-v4/src/pbrt/textures.cpp |
void pbrt::LogFatal<char const (&) [7]>(pbrt::LogLevel, char const*, int, char const*, char const (&) [7]) | 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 $0x78, %rsp
movl %edi, 0x74(%rsp)
movq %rsi, 0x68(%rsp)
movl %edx, 0x64(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x384470
movq 0x8(%rsp), %rdi
movl 0x74(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x68(%rsp), %rax
movq ... | /anderslanglands[P]pbrt-v4/src/pbrt/util/log.h |
void pbrt::LogFatal<char const (&) [6]>(pbrt::LogLevel, char const*, int, char const*, char const (&) [6]) | 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 $0x78, %rsp
movl %edi, 0x74(%rsp)
movq %rsi, 0x68(%rsp)
movl %edx, 0x64(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x380ce0
movq 0x8(%rsp), %rdi
movl 0x74(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x68(%rsp), %rax
movq ... | /anderslanglands[P]pbrt-v4/src/pbrt/util/log.h |
void pbrt::LogFatal<char const (&) [49]>(pbrt::LogLevel, char const*, int, char const*, char const (&) [49]) | 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 $0x78, %rsp
movl %edi, 0x74(%rsp)
movq %rsi, 0x68(%rsp)
movl %edx, 0x64(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x412f50
movq 0x8(%rsp), %rdi
movl 0x74(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x68(%rsp), %rax
movq ... | /anderslanglands[P]pbrt-v4/src/pbrt/util/log.h |
pbrt::RGB::operator[](int) | PBRT_CPU_GPU
Float &operator[](int c) {
DCHECK(c >= 0 && c < 3);
if (c == 0)
return r;
else if (c == 1)
return g;
return b;
} | movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
cmpl $0x0, -0x14(%rsp)
jne 0x3fec76
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x3fec9d
cmpl $0x1, -0x14(%rsp)
jne 0x3fec8d
movq -0x20(%rsp), %rax
addq $0x4, %rax
movq %rax, -0x8(%rsp)
jmp 0x3fec9d
jmp 0x3fec8f
movq -0x20(... | /anderslanglands[P]pbrt-v4/src/pbrt/util/color.h |
pbrt::ParseWrapMode(char const*) | inline pstd::optional<WrapMode> ParseWrapMode(const char *w) {
if (!strcmp(w, "clamp"))
return WrapMode::Clamp;
else if (!strcmp(w, "repeat"))
return WrapMode::Repeat;
else if (!strcmp(w, "black"))
return WrapMode::Black;
else if (!strcmp(w, "octahedralsphere"))
return Wr... | subq $0x38, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x451152(%rip), %rsi # 0x850049
callq 0x3280f0
cmpl $0x0, %eax
jne 0x3fef1d
movq 0x8(%rsp), %rdi
movl $0x2, 0x24(%rsp)
leaq 0x24(%rsp), %rsi
callq 0x403240
jmp 0x3fefc5
m... | /anderslanglands[P]pbrt-v4/src/pbrt/util/image.h |
void pbrt::Log<float&>(pbrt::LogLevel, char const*, int, char const*, float&) | inline void Log(LogLevel level, const char *file, int line, const char *fmt,
Args &&... args) {
#ifdef PBRT_IS_GPU_CODE
Log(level, file, line, fmt); // just the format string #yolo
#else
std::string s = StringPrintf(fmt, std::forward<Args>(args)...);
Log(level, file, line, s.c_str());
#endi... | subq $0x78, %rsp
movl %edi, 0x74(%rsp)
movq %rsi, 0x68(%rsp)
movl %edx, 0x64(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x357420
movq 0x8(%rsp), %rdi
movl 0x74(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x68(%rsp), %rax
movq ... | /anderslanglands[P]pbrt-v4/src/pbrt/util/log.h |
pbrt::TaggedPointer<pbrt::UVMapping2D, pbrt::SphericalMapping2D, pbrt::CylindricalMapping2D, pbrt::PlanarMapping2D>::TaggedPointer<pbrt::UVMapping2D>(pbrt::UVMapping2D*) | 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 $0x1, -0x1a(%rsp)
movabsq $0x1000000000000, %rcx # imm = 0x1000000000000
orq -0x18(%rsp), %rcx
movq %rcx, (%rax)
retq
nopw (%rax,%rax)
| /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
pbrt::TaggedPointer<pbrt::UVMapping2D, pbrt::SphericalMapping2D, pbrt::CylindricalMapping2D, pbrt::PlanarMapping2D>::TaggedPointer<pbrt::SphericalMapping2D>(pbrt::SphericalMapping2D*) | 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 $0x2, -0x1a(%rsp)
movabsq $0x2000000000000, %rcx # imm = 0x2000000000000
orq -0x18(%rsp), %rcx
movq %rcx, (%rax)
retq
nopw (%rax,%rax)
| /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
pbrt::TaggedPointer<pbrt::TransformMapping3D>::TaggedPointer<pbrt::TransformMapping3D>(pbrt::TransformMapping3D*) | 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 $0x1, -0x1a(%rsp)
movabsq $0x1000000000000, %rcx # imm = 0x1000000000000
orq -0x18(%rsp), %rcx
movq %rcx, (%rax)
retq
nopw (%rax,%rax)
| /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
pbrt::TaggedPointer<pbrt::ConstantSpectrum, pbrt::DenselySampledSpectrum, pbrt::PiecewiseLinearSpectrum, pbrt::RGBSpectrum, pbrt::RGBReflectanceSpectrum, pbrt::BlackbodySpectrum>::TaggedPointer<pbrt::ConstantSpectrum>(pbrt::ConstantSpectrum*) | 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 $0x1, -0x1a(%rsp)
movabsq $0x1000000000000, %rcx # imm = 0x1000000000000
orq -0x18(%rsp), %rcx
movq %rcx, (%rax)
retq
nopw (%rax,%rax)
| /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
pbrt::SphericalMapping2D::Map(pbrt::TextureEvalContext, pbrt::Vector2<float>*, pbrt::Vector2<float>*) const | PBRT_CPU_GPU
Point2f Map(TextureEvalContext ctx, Vector2f *dstdx, Vector2f *dstdy) const {
Point2f st = sphere(ctx.p);
// Compute texture coordinate differentials for sphere $(u,v)$ mapping
const Float delta = .1f;
Point2f stDeltaX = sphere(ctx.p + delta * ctx.dpdx);
*dstdx =... | subq $0x108, %rsp # imm = 0x108
movq %rsi, %rax
leaq 0x110(%rsp), %rsi
movq %rsi, 0x18(%rsp)
movq %rdi, 0xf8(%rsp)
movq %rax, 0xf0(%rsp)
movq %rdx, 0xe8(%rsp)
movq 0xf8(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x401720
movq 0x18(%rsp), %rdi
vmovlpd %xmm0, 0x100(%rsp)
movl $0x3dcccccd, 0xe4(%rsp) # imm = 0x3DC... | /anderslanglands[P]pbrt-v4/src/pbrt/textures.h |
auto pbrt::detail::DispatchSplit<3>::operator()<pbrt::ColorEncodingHandle::ToLinear(pstd::span<unsigned char const>, pstd::span<float>) const::'lambda'(auto), pbrt::TaggedPointer<pbrt::LinearColorEncoding, pbrt::sRGBColorEncoding, pbrt::GammaColorEncoding>, pbrt::LinearColorEncoding, pbrt::sRGBColorEncoding, pbrt::Gamm... | 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 %rsi, 0x78(%rsp)
movq %rdx, 0x80(%rsp)
movq %rdi, 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 0x403462
movq 0x8(%rsp), %rsi
movq 0x78(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x80(%rsp), %... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
pbrt::TaggedPointer<pbrt::FloatImageTexture, pbrt::GPUFloatImageTexture, pbrt::FloatMixTexture, pbrt::FloatScaledTexture, pbrt::FloatConstantTexture, pbrt::FloatBilerpTexture, pbrt::FloatCheckerboardTexture, pbrt::FloatDotsTexture, pbrt::FBmTexture, pbrt::FloatPtexTexture, pbrt::WindyTexture, pbrt::WrinkledTexture>::Ta... | 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 $0x4, -0x1a(%rsp)
movabsq $0x4000000000000, %rcx # imm = 0x4000000000000
orq -0x18(%rsp), %rcx
movq %rcx, (%rax)
retq
nopw (%rax,%rax)
| /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
pbrt::TaggedPointer<pbrt::RGBConstantTexture, pbrt::RGBReflectanceConstantTexture, pbrt::SpectrumImageTexture, pbrt::GPUSpectrumImageTexture, pbrt::SpectrumMixTexture, pbrt::SpectrumScaledTexture, pbrt::SpectrumConstantTexture, pbrt::SpectrumBilerpTexture, pbrt::SpectrumCheckerboardTexture, pbrt::MarbleTexture, pbrt::S... | 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 |
pbrt::TaggedPointer<pbrt::RGBConstantTexture, pbrt::RGBReflectanceConstantTexture, pbrt::SpectrumImageTexture, pbrt::GPUSpectrumImageTexture, pbrt::SpectrumMixTexture, pbrt::SpectrumScaledTexture, pbrt::SpectrumConstantTexture, pbrt::SpectrumBilerpTexture, pbrt::SpectrumCheckerboardTexture, pbrt::MarbleTexture, pbrt::S... | 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 $0x6, -0x1a(%rsp)
movabsq $0x6000000000000, %rcx # imm = 0x6000000000000
orq -0x18(%rsp), %rcx
movq %rcx, (%rax)
retq
nopw (%rax,%rax)
| /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
pbrt::TaggedPointer<pbrt::FloatImageTexture, pbrt::GPUFloatImageTexture, pbrt::FloatMixTexture, pbrt::FloatScaledTexture, pbrt::FloatConstantTexture, pbrt::FloatBilerpTexture, pbrt::FloatCheckerboardTexture, pbrt::FloatDotsTexture, pbrt::FBmTexture, pbrt::FloatPtexTexture, pbrt::WindyTexture, pbrt::WrinkledTexture>::Ta... | 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 $0x6, -0x1a(%rsp)
movabsq $0x6000000000000, %rcx # imm = 0x6000000000000
orq -0x18(%rsp), %rcx
movq %rcx, (%rax)
retq
nopw (%rax,%rax)
| /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
pbrt::TaggedPointer<pbrt::FloatImageTexture, pbrt::GPUFloatImageTexture, pbrt::FloatMixTexture, pbrt::FloatScaledTexture, pbrt::FloatConstantTexture, pbrt::FloatBilerpTexture, pbrt::FloatCheckerboardTexture, pbrt::FloatDotsTexture, pbrt::FBmTexture, pbrt::FloatPtexTexture, pbrt::WindyTexture, pbrt::WrinkledTexture>::Ta... | 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 $0xb, -0x1a(%rsp)
movabsq $0xb000000000000, %rcx # imm = 0xB000000000000
orq -0x18(%rsp), %rcx
movq %rcx, (%rax)
retq
nopw (%rax,%rax)
| /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
pbrt::TaggedPointer<pbrt::FloatImageTexture, pbrt::GPUFloatImageTexture, pbrt::FloatMixTexture, pbrt::FloatScaledTexture, pbrt::FloatConstantTexture, pbrt::FloatBilerpTexture, pbrt::FloatCheckerboardTexture, pbrt::FloatDotsTexture, pbrt::FBmTexture, pbrt::FloatPtexTexture, pbrt::WindyTexture, pbrt::WrinkledTexture>::Ta... | 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 $0xa, -0x1a(%rsp)
movabsq $0xa000000000000, %rcx # imm = 0xA000000000000
orq -0x18(%rsp), %rcx
movq %rcx, (%rax)
retq
nopw (%rax,%rax)
| /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
pbrt::TaggedPointer<pbrt::RGBConstantTexture, pbrt::RGBReflectanceConstantTexture, pbrt::SpectrumImageTexture, pbrt::GPUSpectrumImageTexture, pbrt::SpectrumMixTexture, pbrt::SpectrumScaledTexture, pbrt::SpectrumConstantTexture, pbrt::SpectrumBilerpTexture, pbrt::SpectrumCheckerboardTexture, pbrt::MarbleTexture, pbrt::S... | 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 $0x7, -0x1a(%rsp)
movabsq $0x7000000000000, %rcx # imm = 0x7000000000000
orq -0x18(%rsp), %rcx
movq %rcx, (%rax)
retq
nopw (%rax,%rax)
| /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.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.