name string | code string | asm string | file string |
|---|---|---|---|
pbrt::TaggedPointer<pbrt::CoatedDiffuseMaterial, pbrt::CoatedConductorMaterial, pbrt::ConductorMaterial, pbrt::DielectricMaterial, pbrt::DiffuseMaterial, pbrt::DiffuseTransmissionMaterial, pbrt::HairMaterial, pbrt::MeasuredMaterial, pbrt::SubsurfaceMaterial, pbrt::ThinDielectricMaterial, pbrt::MixMaterial>::TaggedPoint... | 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::CoatedDiffuseMaterial, pbrt::CoatedConductorMaterial, pbrt::ConductorMaterial, pbrt::DielectricMaterial, pbrt::DiffuseMaterial, pbrt::DiffuseTransmissionMaterial, pbrt::HairMaterial, pbrt::MeasuredMaterial, pbrt::SubsurfaceMaterial, pbrt::ThinDielectricMaterial, pbrt::MixMaterial>::TaggedPoint... | 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 $0x8, -0x1a(%rsp)
movabsq $0x8000000000000, %rcx # imm = 0x8000000000000
orq -0x18(%rsp), %rcx
movq %rcx, (%rax)
retq
nopw (%rax,%rax)
| /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
void pbrt::detail::stringPrintfRecursive<pbrt::FloatTextureHandle const&, pbrt::SpectrumTextureHandle const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, pbrt::FloatTextureHandle const&, pbrt::SpectrumTextureHandle 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<pbrt::SpectrumTextureHandle const&, pbrt::SpectrumTextureHandle const&, pbrt::FloatTextureHandle const&, pbrt::FloatTextureHandle const&, bool const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, pbrt::SpectrumTextureHandle 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::FloatTextureHandle const&, pbrt::SpectrumTextureHandle const&, pbrt::FloatTextureHandle const&, pbrt::FloatTextureHandle const&, pbrt::FloatTextureHandle const&, pbrt::FloatTextureHandle const&, bool const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::all... | 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 0x290(%rsp), %rax
movq 0x288(%rsp), %rax
movq 0x280(%rsp), %rax
movq %rdi, 0x270(%rsp)
movq %rsi, 0x268(%rsp)
movq %rdx, 0x260(%rsp)
movq %rcx, 0x258(%rsp)
movq %r8, 0x250(%rsp)
movq %r9, 0x248(%rsp)
movq 0x270(%rsp), %rdx
leaq 0x228(%rsp), %rdi
leaq 0x268(%rsp), %rsi
cal... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
pbrt::UniformGridMediumProvider::UniformGridMediumProvider(pbrt::Bounds3<float> const&, pstd::optional<pbrt::SampledGrid<float>>, pstd::optional<pbrt::SampledGrid<pbrt::RGB>>, pbrt::RGBColorSpace const*, pbrt::SpectrumHandle, pbrt::SampledGrid<float>, pstd::pmr::polymorphic_allocator<std::byte>) | UniformGridMediumProvider::UniformGridMediumProvider(
const Bounds3f &bounds, pstd::optional<SampledGrid<Float>> dgrid,
pstd::optional<SampledGrid<RGB>> rgbgrid, const RGBColorSpace *colorSpace,
SpectrumHandle Le, SampledGrid<Float> Legrid, Allocator alloc)
: bounds(bounds),
densityGrid(std::move(... | subq $0xd8, %rsp
movq %r9, 0x48(%rsp)
movq %rcx, 0x70(%rsp)
movq %rdx, 0x50(%rsp)
movq %rsi, %rax
movq 0x50(%rsp), %rsi
movq 0xe8(%rsp), %rdx
movq 0xe0(%rsp), %r10
movq %r10, 0x58(%rsp)
movq %rdx, 0xd0(%rsp)
movq %rdi, 0xc8(%rsp)
movq %rax, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rcx, 0xb0(%rsp)
movq %r8, 0xa8(%rsp)
mov... | /anderslanglands[P]pbrt-v4/src/pbrt/media.cpp |
auto pbrt::detail::DispatchSplitCPU<4>::operator()<pbrt::MediumHandle::IsEmissive() const::$_0, pbrt::TaggedPointer<pbrt::HomogeneousMedium, pbrt::GeneralMedium<pbrt::UniformGridMediumProvider>, pbrt::GeneralMedium<pbrt::CloudMediumProvider>, pbrt::GeneralMedium<pbrt::NanoVDBMediumProvider>>, pbrt::HomogeneousMedium, 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 $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 0x6316b5
movq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x3d13e0
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::DispatchSplitCPU<2>::operator()<pbrt::MediumHandle::ToString[abi:cxx11]() const::$_0, pbrt::TaggedPointer<pbrt::HomogeneousMedium, pbrt::GeneralMedium<pbrt::UniformGridMediumProvider>, pbrt::GeneralMedium<pbrt::CloudMediumProvider>, pbrt::GeneralMedium<pbrt::NanoVDBMediumProvider>>, pbrt::Homogeneous... | 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 0x631a94
movq (%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x3... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
pbrt::GeneralMedium<pbrt::NanoVDBMediumProvider>::Create(pbrt::NanoVDBMediumProvider const*, pbrt::ParameterDictionary const&, pbrt::Transform const&, pbrt::FileLoc const*, pstd::pmr::polymorphic_allocator<std::byte>) | static GeneralMedium<DensityProvider> *Create(const DensityProvider *provider,
const ParameterDictionary ¶meters,
const Transform &renderFromMedium,
const FileLoc *lo... | subq $0x298, %rsp # imm = 0x298
movq %r8, 0x290(%rsp)
movq %rdi, 0x288(%rsp)
movq %rsi, 0x280(%rsp)
movq %rdx, 0x278(%rsp)
movq %rcx, 0x270(%rsp)
xorl %eax, %eax
movl %eax, %esi
movq %rsi, 0xa0(%rsp)
leaq 0x268(%rsp), %rdi
callq 0x4e6880
movq 0xa0(%rsp), %rsi
leaq 0x260(%rsp), %rdi
callq 0x4e6880
movq 0x280(... | /anderslanglands[P]pbrt-v4/src/pbrt/media.h |
void pbrt::detail::stringPrintfRecursive<pbrt::HGPhaseFunction const&, pbrt::Transform const&, pstd::vector<float, pstd::pmr::polymorphic_allocator<float>> const&, pbrt::Point3<int> const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, pbrt::HGPhaseFunction const&, pbrt::... | 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<pstd::vector<float, pstd::pmr::polymorphic_allocator<float>> const&, pbrt::Point3<int> const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, pstd::vector<float, pstd::pmr::polymorphic_allocator<float>> const&, pbrt::Point3<int> con... | 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::RGB, pstd::pmr::polymorphic_allocator<pbrt::RGB>>::vector(pstd::vector<pbrt::RGB, pstd::pmr::polymorphic_allocator<pbrt::RGB>>&&) | vector(vector &&other) : alloc(other.alloc) {
nStored = other.nStored;
nAlloc = other.nAlloc;
ptr = other.ptr;
other.nStored = other.nAlloc = 0;
other.ptr = nullptr;
} | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq -0x10(%rsp), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%... | /anderslanglands[P]pbrt-v4/src/pbrt/util/pstd.h |
void pbrt::detail::stringPrintfRecursive<int&, char const (&) [14], unsigned long&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, int&, char const (&) [14], 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 $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::RGB, pstd::pmr::polymorphic_allocator<pbrt::RGB>>::vector<pbrt::RGB const*>(pbrt::RGB const*, pbrt::RGB const*, pstd::pmr::polymorphic_allocator<pbrt::RGB> 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), %rax
movq 0x28(%rsp), %rcx
subq %rc... | /anderslanglands[P]pbrt-v4/src/pbrt/util/pstd.h |
void pbrt::detail::stringPrintfRecursive<int&, int, unsigned long>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, int&, int&&, 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 $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 |
pbrt::GeneralMedium<pbrt::CloudMediumProvider>::GeneralMedium(pbrt::CloudMediumProvider const*, pbrt::SpectrumHandle, pbrt::SpectrumHandle, float, float, pbrt::Transform const&, pstd::pmr::polymorphic_allocator<std::byte>) | GeneralMedium(const DensityProvider *provider, SpectrumHandle sigma_a,
SpectrumHandle sigma_s, Float sigScale, Float g,
const Transform &renderFromMedium, Allocator alloc)
: provider(provider),
mediumBounds(provider->Bounds()),
sigma_a_spec(sigma_a, alloc)... | subq $0xe8, %rsp
movq %rdx, 0x20(%rsp)
movq %rcx, 0x40(%rsp)
movq %r9, 0xe0(%rsp)
movq %rdi, 0xd8(%rsp)
movq %rsi, 0xd0(%rsp)
movq %rdx, 0xc8(%rsp)
movq %rcx, 0xc0(%rsp)
vmovss %xmm0, 0xbc(%rsp)
vmovss %xmm1, 0xb8(%rsp)
movq %r8, 0xb0(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0xd0(%rsp), %rcx
movq %rcx, (%... | /anderslanglands[P]pbrt-v4/src/pbrt/media.h |
void pbrt::detail::stringPrintfRecursive<char const (&) [6], char const (&) [30], char const (&) [6], unsigned long&, char const (&) [30], int&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [6], char const (&) [30], char const (&) [6], unsigned long&, 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... | 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 |
bool nanovdb::ReadAccessor<nanovdb::RootNode<nanovdb::InternalNode<nanovdb::InternalNode<nanovdb::LeafNode<float, nanovdb::Coord, nanovdb::Mask, 3u>, 4u>, 5u>>>::isCached<nanovdb::InternalNode<nanovdb::InternalNode<nanovdb::LeafNode<float, nanovdb::Coord, nanovdb::Mask, 3u>, 4u>, 5u>>(int) const | __hostdev__ bool isCached(CoordValueType dirty) const
{
if (!mNode[NodeT::LEVEL])
return false;
if (dirty & int32_t(~NodeT::MASK)) {
mNode[NodeT::LEVEL] = nullptr;
return false;
}
return true;
} | movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
cmpq $0x0, 0x20(%rax)
jne 0x647481
movb $0x0, -0x1(%rsp)
jmp 0x6474a8
movl -0x14(%rsp), %eax
andl $0xfffff000, %eax # imm = 0xFFFFF000
cmpl $0x0, %eax
je 0x6474a3
movq -0x20(%rsp), %rax
movq $0x0, 0x20(%rax)
movb $0x0, -0x... | /anderslanglands[P]pbrt-v4/src/ext/openvdb/nanovdb/nanovdb/NanoVDB.h |
void pbrt::detail::stringPrintfRecursive<bool const&, bool const&, bool const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allo... | 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 $0x2c8, %rsp # imm = 0x2C8
movq 0x318(%rsp), %rax
movq 0x310(%rsp), %rax
movq 0x308(%rsp), %rax
movq 0x300(%rsp), %rax
movq 0x2f8(%rsp), %rax
movq 0x2f0(%rsp), %rax
movq %rdi, 0x2c0(%rsp)
movq %rsi, 0x2b8(%rsp)
movq %rdx, 0x2b0(%rsp)
movq %rcx, 0x2a8(%rsp)
mov... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
std::vector<pbrt::SpectrumHandle, std::allocator<pbrt::SpectrumHandle>> pbrt::returnArray<pbrt::SpectrumHandle, pstd::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, pstd::pmr::polymorphic_allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, ... | static std::vector<ReturnType> returnArray(const ValuesType &values,
const ParsedParameter ¶m, int nPerItem,
C convert) {
if (values.empty())
ErrorExit(¶m.loc, "No values provided for \"%s\".", param.name);
if ... | subq $0x88, %rsp
movq %r8, 0x18(%rsp)
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movl %ecx, 0x6c(%rsp)
movq %r8, 0x60(%rsp)
movq 0x78(%rsp), %rdi
callq 0x3a4a10
testb $0x1, %al
jne 0x64f304
jmp 0x64f322
movq 0x70(%rsp), %rdi
addq $0x40, ... | /anderslanglands[P]pbrt-v4/src/pbrt/paramdict.cpp |
std::vector<pbrt::Point3<float>, std::allocator<pbrt::Point3<float>>> pbrt::returnArray<pbrt::Point3<float>, pstd::vector<double, pstd::pmr::polymorphic_allocator<double>>, pbrt::Point3<float> (*)(double const*, pbrt::FileLoc const*)>(pstd::vector<double, pstd::pmr::polymorphic_allocator<double>> const&, pbrt::ParsedPa... | static std::vector<ReturnType> returnArray(const ValuesType &values,
const ParsedParameter ¶m, int nPerItem,
C convert) {
if (values.empty())
ErrorExit(¶m.loc, "No values provided for \"%s\".", param.name);
if ... | subq $0xc8, %rsp
movq %rdi, 0x48(%rsp)
movq %rdi, %rax
movq %rax, 0x50(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movl %ecx, 0xac(%rsp)
movq %r8, 0xa0(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x3a4b80
testb $0x1, %al
jne 0x65324e
jmp 0x653272
movq 0xb0(%rsp), %rdi
addq $0x40, %rdi
movq 0xb0(%rsp),... | /anderslanglands[P]pbrt-v4/src/pbrt/paramdict.cpp |
pbrt::ParsedParameter** pbrt::InlinedVector<pbrt::ParsedParameter*, 8, pstd::pmr::polymorphic_allocator<pbrt::ParsedParameter*>>::insert<std::reverse_iterator<pbrt::ParsedParameter* const*>>(pbrt::ParsedParameter* const*, std::reverse_iterator<pbrt::ParsedParameter* const*>, std::reverse_iterator<pbrt::ParsedParameter*... | iterator insert(const_iterator pos, InputIt first, InputIt last) {
if (pos == end()) {
reserve(size() + (last - first));
iterator pos = end(), startPos = end();
for (auto iter = first; iter != last; ++iter, ++pos)
alloc.template construct<T>(pos, *iter);
... | subq $0x68, %rsp
movq %rdx, 0x10(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
callq 0x352fb0
movq %rax, %rcx
movq 0x28(%rsp), %rax
cmpq %rcx, %rax
jne 0x6549d5
m... | /anderslanglands[P]pbrt-v4/src/pbrt/util/containers.h |
pbrt::ParameterTypeTraits<(pbrt::ParameterType)0>::ReturnType pbrt::ParameterDictionary::lookupSingle<(pbrt::ParameterType)0>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, pbrt::ParameterTypeTraits<(pbrt::ParameterType)0>::ReturnType) const | typename ParameterTypeTraits<PT>::ReturnType ParameterDictionary::lookupSingle(
const std::string &name,
typename ParameterTypeTraits<PT>::ReturnType defaultValue) const {
// Search _params_ for parameter _name_
using traits = ParameterTypeTraits<PT>;
for (const ParsedParameter *p : params) {
... | subq $0x48, %rsp
movb %dl, %al
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movb %al, 0x2f(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x365b30
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x655600
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x654fed
movq 0... | /anderslanglands[P]pbrt-v4/src/pbrt/paramdict.cpp |
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 $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 |
void pbrt::detail::stringPrintfRecursive<int, float&, double const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, int&&, float&, double 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&, double const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, float&, double 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 %rcx, 0x258(%rsp)
movq 0x270(%rsp), %rdx
leaq 0x238(%rsp), %rdi
leaq 0x268(%rsp), %rsi
callq 0x4ccc90
leaq 0x238(%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 (&) [42]>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [42]) | 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 |
pbrt::PaddedSobolSampler::Clone(int, pstd::pmr::polymorphic_allocator<std::byte>) | std::vector<SamplerHandle> PaddedSobolSampler::Clone(int n, Allocator alloc) {
std::vector<SamplerHandle> samplers(n);
PaddedSobolSampler *samplerMem =
(PaddedSobolSampler *)alloc.allocate_object<PaddedSobolSampler>(n);
for (int i = 0; i < n; ++i) {
alloc.construct(&samplerMem[i], *this);
... | subq $0x78, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movl %edx, 0x5c(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movb $0x0, 0x5b(%rsp)
movslq 0x5c(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x5a(%rsp), %rdi
movq %rdi, 0x28(%rsp)
... | /anderslanglands[P]pbrt-v4/src/pbrt/samplers.cpp |
void pbrt::detail::stringPrintfRecursive<pbrt::RNG const&, float const&, float const&, int const&, pstd::vector<pbrt::MLTSampler::PrimarySample, pstd::pmr::polymorphic_allocator<pbrt::MLTSampler::PrimarySample>> const&, long const&, bool const&, long const&, int const&, int const&>(std::__cxx11::basic_string<char, 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... | pushq %r15
pushq %r14
pushq %rbx
subq $0x290, %rsp # imm = 0x290
movq 0x2d8(%rsp), %rax
movq 0x2d0(%rsp), %rax
movq 0x2c8(%rsp), %rax
movq 0x2c0(%rsp), %rax
movq 0x2b8(%rsp), %rax
movq 0x2b0(%rsp), %rax
movq %rdi, 0x288(%rsp)
movq %rsi, 0x280(%rsp)
movq %rdx, 0x278(%rsp)
movq %rcx, 0x270(%rsp)
movq %r8, 0x26... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<long const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, long 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<pbrt::RandomizeStrategy const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, pbrt::RandomizeStrategy 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<int const&, int const&, int const&, bool const&, int const&, pbrt::RNG const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, int const&, int const&, int const&, bool const&, int const&, pbrt::RNG 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 $0x2a8, %rsp # imm = 0x2A8
movq 0x2b8(%rsp), %rax
movq 0x2b0(%rsp), %rax
movq %rdi, 0x2a0(%rsp)
movq %rsi, 0x298(%rsp)
movq %rdx, 0x290(%rsp)
movq %rcx, 0x288(%rsp)
movq %r8, 0x280(%rsp)
movq %r9, 0x278(%rsp)
movq 0x2a0(%rsp), %rdx
leaq 0x258(%rsp), %rdi
leaq 0x298(%rsp), %rsi
callq 0x4ccc90
leaq 0x258(... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<char const (&) [20], char const (&) [9], int&, char const (&) [20], int&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [20], char const (&) [9], int&, char const (&) [20], 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 |
pbrt::StratifiedSampler::StratifiedSampler(int, int, bool, int) | StratifiedSampler(int xPixelSamples, int yPixelSamples, bool jitter, int seed = 0)
: xPixelSamples(xPixelSamples),
yPixelSamples(yPixelSamples),
jitter(jitter),
seed(seed) {} | subq $0x28, %rsp
movb %cl, %al
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movl %r8d, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, (%rdi)
movl 0x18(%rsp), %eax
movl %eax, 0x4(%rdi)
movb 0x17(%rsp), %al
andb $0x1, %al
mov... | /anderslanglands[P]pbrt-v4/src/pbrt/samplers.h |
pbrt::BVHAggregate::buildHLBVH(pstd::pmr::polymorphic_allocator<std::byte>, std::vector<pbrt::BVHPrimitive, std::allocator<pbrt::BVHPrimitive>> const&, std::atomic<int>*, std::vector<pbrt::PrimitiveHandle, std::allocator<pbrt::PrimitiveHandle>>&) | BVHBuildNode *BVHAggregate::buildHLBVH(Allocator alloc,
const std::vector<BVHPrimitive> &bvhPrimitives,
std::atomic<int> *totalNodes,
std::vector<PrimitiveHandle> &orderedPrims) {
// Compute bounding... | subq $0x228, %rsp # imm = 0x228
movq %rsi, 0x220(%rsp)
movq %rdi, 0x218(%rsp)
movq %rdx, 0x210(%rsp)
movq %rcx, 0x208(%rsp)
movq %r8, 0x200(%rsp)
movq 0x218(%rsp), %rax
movq %rax, 0x58(%rsp)
leaq 0x1e8(%rsp), %rdi
callq 0x3db700
movq 0x210(%rsp), %rax
movq %rax, 0x1e0(%rsp)
movq 0x1e0(%rsp), %rdi
callq 0x67f... | /anderslanglands[P]pbrt-v4/src/pbrt/cpu/aggregates.cpp |
void pbrt::LogFatal<char const (&) [26], char const (&) [20], char const (&) [26], int&, char const (&) [20], unsigned long&>(pbrt::LogLevel, char const*, int, char const*, char const (&) [26], char const (&) [20], char const (&) [26], int&, char const (&) [20], unsigned long&) | 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 |
void pbrt::LogFatal<char const (&) [12], char const (&) [16], char const (&) [12], int&, char const (&) [16], int&>(pbrt::LogLevel, char const*, int, char const*, char const (&) [12], char const (&) [16], char const (&) [12], int&, char const (&) [16], 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 |
void pbrt::LogFatal<char const (&) [18], char const (&) [6], char const (&) [18], int&, char const (&) [6], int&>(pbrt::LogLevel, char const*, int, char const*, char const (&) [18], char const (&) [6], char const (&) [18], int&, char const (&) [6], 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 |
void pbrt::LogFatal<char const (&) [4], char const (&) [6], char const (&) [4], int&, char const (&) [6], int&>(pbrt::LogLevel, char const*, int, char const*, char const (&) [4], char const (&) [6], char const (&) [4], int&, char const (&) [6], 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 |
std::enable_if<!std::is_class<std::decay<char const (&) [9]>::type>::value, void>::type pbrt::detail::stringPrintfRecursiveWithPrecision<char const (&) [9], 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::a... | 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<char const (&) [20], unsigned long&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [20], 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 |
void pbrt::detail::stringPrintfRecursive<char const (&) [12], int&, char const (&) [2], int&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [12], 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 %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 (&) [16], int&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [16], 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 |
void pbrt::detail::stringPrintfRecursive<int&, char const (&) [6], int&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, int&, char const (&) [6], 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<char const (&) [6], int&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [6], 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 |
void pbrt::detail::stringPrintfRecursive<char const (&) [4], char const (&) [6], int&, char const (&) [4], int&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [4], char const (&) [6], int&, char const (&) [4], 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 |
pbrt::PathIntegrator::SampleLd(pbrt::SurfaceInteraction const&, pbrt::BSDF const&, pbrt::SampledWavelengths&, pbrt::SamplerHandle) const | SampledSpectrum PathIntegrator::SampleLd(const SurfaceInteraction &intr, const BSDF &bsdf,
SampledWavelengths &lambda,
SamplerHandle sampler) const {
// Choose a light source for the direct lighting calculation
pstd::optional<Samp... | subq $0x438, %rsp # imm = 0x438
movq %r8, 0x1a8(%rsp)
movq %rdi, 0x420(%rsp)
movq %rsi, 0x418(%rsp)
movq %rdx, 0x410(%rsp)
movq %rcx, 0x408(%rsp)
movq %r8, 0x400(%rsp)
movq 0x420(%rsp), %rax
movq %rax, 0x190(%rsp)
addq $0x70, %rax
movq %rax, 0x198(%rsp)
movq 0x418(%rsp), %rsi
leaq 0x3b8(%rsp), %rdi
movq %rdi... | /anderslanglands[P]pbrt-v4/src/pbrt/cpu/integrators.cpp |
pbrt::VolPathIntegrator::SampleLd(pbrt::Interaction const&, pbrt::BSDF const*, pbrt::SampledWavelengths&, pbrt::SamplerHandle, pbrt::SampledSpectrum const&, pbrt::SampledSpectrum const&) const | SampledSpectrum VolPathIntegrator::SampleLd(const Interaction &intr, const BSDF *bsdf,
SampledWavelengths &lambda,
SamplerHandle sampler,
const SampledSpectrum &beta,
... | subq $0x888, %rsp # imm = 0x888
movq %r8, 0x2d0(%rsp)
movq %rdi, %rax
movq 0x2d0(%rsp), %rdi
movq 0x890(%rsp), %r8
movq %rax, 0x870(%rsp)
movq %rsi, 0x868(%rsp)
movq %rdx, 0x860(%rsp)
movq %rcx, 0x858(%rsp)
movq %rdi, 0x850(%rsp)
movq %r9, 0x848(%rsp)
movq 0x870(%rsp), %rax
movq %rax, 0x2d8(%rsp)
callq 0x5ce... | /anderslanglands[P]pbrt-v4/src/pbrt/cpu/integrators.cpp |
pbrt::AOIntegrator::Li(pbrt::RayDifferential, pbrt::SampledWavelengths&, pbrt::SamplerHandle, pbrt::ScratchBuffer&, pbrt::VisibleSurface*) const | SampledSpectrum AOIntegrator::Li(RayDifferential ray, SampledWavelengths &lambda,
SamplerHandle sampler, ScratchBuffer &scratchBuffer,
VisibleSurface *visibleSurface) const {
SampledSpectrum L(0.f);
// Intersect _ray_ with scene and store inters... | subq $0x638, %rsp # imm = 0x638
movq %rsi, 0x190(%rsp)
movq %rcx, 0x198(%rsp)
movq %rdi, 0x620(%rsp)
movq %rsi, 0x618(%rsp)
movq %rdx, 0x610(%rsp)
movq %rcx, 0x608(%rsp)
movq %r8, 0x600(%rsp)
movq %r9, 0x5f8(%rsp)
movq 0x620(%rsp), %rax
movq %rax, 0x1a0(%rsp)
leaq 0x5e8(%rsp), %rdi
vpxor %xmm0, %xmm0, %xmm0
... | /anderslanglands[P]pbrt-v4/src/pbrt/cpu/integrators.cpp |
pbrt::G(pbrt::Integrator const&, pbrt::SamplerHandle, pbrt::Vertex const&, pbrt::Vertex const&, pbrt::SampledWavelengths const&) | SampledSpectrum G(const Integrator &integrator, SamplerHandle sampler, const Vertex &v0,
const Vertex &v1, const SampledWavelengths &lambda) {
Vector3f d = v0.p() - v1.p();
Float g = 1 / LengthSquared(d);
d *= std::sqrt(g);
if (v0.IsOnSurface())
g *= AbsDot(v0.ns(), d);
if ... | subq $0x148, %rsp # imm = 0x148
movq %rdi, 0x130(%rsp)
movq %rsi, 0x128(%rsp)
movq %rdx, 0x120(%rsp)
movq %rcx, 0x118(%rsp)
movq %r8, 0x110(%rsp)
movq 0x120(%rsp), %rdi
callq 0x6d1150
vmovss %xmm1, 0xf0(%rsp)
vmovlpd %xmm0, 0xe8(%rsp)
movl 0xf0(%rsp), %eax
movl %eax, 0x100(%rsp)
movq 0xe8(%rsp), %rax
movq %r... | /anderslanglands[P]pbrt-v4/src/pbrt/cpu/integrators.cpp |
pbrt::MISWeight(pbrt::Integrator const&, pbrt::Vertex*, pbrt::Vertex*, pbrt::Vertex&, int, int, pbrt::LightSamplerHandle) | Float MISWeight(const Integrator &integrator, Vertex *lightVertices,
Vertex *cameraVertices, Vertex &sampled, int s, int t,
LightSamplerHandle lightSampler) {
if (s + t == 2)
return 1;
Float sumRi = 0;
// Define helper function _remap0_ that deals with Dirac delta fun... | subq $0xa48, %rsp # imm = 0xA48
movq 0xa50(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq %rdi, 0xa38(%rsp)
movq %rsi, 0xa30(%rsp)
movq %rdx, 0xa28(%rsp)
movq %rcx, 0xa20(%rsp)
movl %r8d, 0xa1c(%rsp)
movl %r9d, 0xa18(%rsp)
movl 0xa1c(%rsp), %eax
addl 0xa18(%rsp), %eax
cmpl $0x2, %eax
jne 0x6a5850
vmovss 0x1a5912(%ri... | /anderslanglands[P]pbrt-v4/src/pbrt/cpu/integrators.cpp |
pbrt::BDPTIntegrator::Create(pbrt::ParameterDictionary const&, pbrt::CameraHandle, pbrt::SamplerHandle, pbrt::PrimitiveHandle, std::vector<pbrt::LightHandle, std::allocator<pbrt::LightHandle>>, pbrt::FileLoc const*) | std::unique_ptr<BDPTIntegrator> BDPTIntegrator::Create(
const ParameterDictionary ¶meters, CameraHandle camera, SamplerHandle sampler,
PrimitiveHandle aggregate, std::vector<LightHandle> lights, const FileLoc *loc) {
int maxDepth = parameters.GetOneInt("maxdepth", 5);
bool visualizeStrategies = para... | subq $0x228, %rsp # imm = 0x228
movq %r9, 0x90(%rsp)
movq %r8, 0x98(%rsp)
movq %rcx, 0xa0(%rsp)
movq %rdx, 0xa8(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rdi, %rax
movq %rax, 0xb8(%rsp)
movq 0x230(%rsp), %rax
movq %rdi, 0x220(%rsp)
movq %rsi, 0x218(%rsp)
movq %rdx, 0x210(%rsp)
movq %rcx, 0x208(%rsp)
movq %r8, 0x200(... | /anderslanglands[P]pbrt-v4/src/pbrt/cpu/integrators.cpp |
pbrt::$_17::operator()(pbrt::StatsAccumulator&) const | pstd::optional<ShapeIntersection> Integrator::Intersect(const Ray &ray,
Float tMax) const {
++nIntersectionTests;
DCHECK_NE(ray.d, Vector3f(0, 0, 0));
if (aggregate)
return aggregate.Intersect(ray, tMax);
else
return {};
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq %fs:0x0, %rax
leaq -0x2d0(%rax), %rax
movq (%rax), %rdx
leaq 0x25beaf8(%rip), %rsi # 0x2c6f0c5
callq 0x4f0b60
movq %fs:0x0, %rax
leaq -0x2d0(%rax), %rax
movq $0x0, (%rax)
addq $0x18, %rsp
retq
nop
| /anderslanglands[P]pbrt-v4/src/pbrt/cpu/integrators.cpp |
auto pbrt::detail::DispatchSplit<2>::operator()<void pbrt::MediumHandle::SampleTmaj<pbrt::VolPathIntegrator::SampleLd(pbrt::Interaction const&, pbrt::BSDF const*, pbrt::SampledWavelengths&, pbrt::SamplerHandle, pbrt::SampledSpectrum const&, pbrt::SampledSpectrum const&) const::$_0>(pbrt::Ray const&, float, pbrt::RNG&, ... | 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 %rsi, 0x30(%rsp)
leaq 0xe0(%rsp), %rax
movq %rax, 0x38(%rsp)
movq %rdi, 0xc8(%rsp)
movq %rsi, 0xc0(%rsp)
movl %edx, 0xbc(%rsp)
movl $0x1, 0xb8(%rsp)
movl 0xbc(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x6bedb0
movq 0x38(%rsp), %rsi
leaq 0x88(%rsp), %rdi
movl $0x28, %edx
callq 0x327170
movq 0... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
void pbrt::GeneralMedium<pbrt::NanoVDBMediumProvider>::SampleTmaj<pbrt::VolPathIntegrator::SampleLd(pbrt::Interaction const&, pbrt::BSDF const*, pbrt::SampledWavelengths&, pbrt::SamplerHandle, pbrt::SampledSpectrum const&, pbrt::SampledSpectrum const&) const::$_0>(pbrt::Ray const&, float, pbrt::RNG&, pbrt::SampledWavel... | PBRT_CPU_GPU void SampleTmaj(const Ray &rRender, Float raytMax, RNG &rng,
const SampledWavelengths &lambda, F callback) const {
// Transform ray to grid density's space and compute bounds overlap
raytMax *= Length(rRender.d);
Ray ray = mediumFromRender(Ray(rRende... | subq $0x648, %rsp # imm = 0x648
leaq 0x650(%rsp), %rax
movq %rax, 0xe0(%rsp)
movq %rdi, 0x640(%rsp)
movq %rsi, 0x638(%rsp)
vmovss %xmm0, 0x634(%rsp)
movq %rdx, 0x628(%rsp)
movq %rcx, 0x620(%rsp)
movq 0x640(%rsp), %rax
movq %rax, 0xf8(%rsp)
movq 0x638(%rsp), %rdi
addq $0xc, %rdi
callq 0x3619f0
movq 0xf8(%rsp)... | /anderslanglands[P]pbrt-v4/src/pbrt/media.h |
pbrt::LightLeSample::~LightLeSample() | struct LightLeSample {
public:
LightLeSample() = default;
PBRT_CPU_GPU
LightLeSample(const SampledSpectrum &L, const Ray &ray, Float pdfPos, Float pdfDir)
: L(L), ray(ray), pdfPos(pdfPos), pdfDir(pdfDir) {}
PBRT_CPU_GPU
LightLeSample(const SampledSpectrum &L, const Ray &ray, const Interact... | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
addq $0x38, %rdi
callq 0x60a3c0
popq %rax
retq
nopw %cs:(%rax,%rax)
nop
| /anderslanglands[P]pbrt-v4/src/pbrt/lights.h |
pbrt::VolPathIntegrator::rescale(pbrt::SampledSpectrum&, pbrt::SampledSpectrum&, pbrt::SampledSpectrum&) | static void rescale(SampledSpectrum &beta, SampledSpectrum &pdfLight,
SampledSpectrum &pdfUni) {
if (beta.MaxComponentValue() > 0x1p24f ||
pdfLight.MaxComponentValue() > 0x1p24f ||
pdfUni.MaxComponentValue() > 0x1p24f) {
beta *= 1.f / 0x1p24f;
... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x6432e0
vmovss 0x259e4d0(%rip), %xmm1 # 0x2c6e034
vucomiss %xmm1, %xmm0
ja 0x6cfb99
movq 0x8(%rsp), %rdi
callq 0x6432e0
vmovss 0x259e4b8(%rip), %xmm1 # 0x2c6e034
vucomiss %xmm1, %xmm0
ja 0x6cfb99
movq (%rsp), %r... | /anderslanglands[P]pbrt-v4/src/pbrt/cpu/integrators.h |
void pbrt::LogFatal<char const (&) [43]>(pbrt::LogLevel, char const*, int, char const*, char const (&) [43]) | 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 0x709d00
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::ConductorBxDF::f(pbrt::Vector3<float>, pbrt::Vector3<float>, pbrt::TransportMode) const | f(Vector3f wo, Vector3f wi, TransportMode mode) const {
if (!SameHemisphere(wo, wi))
return {};
if (mfDistrib.EffectivelySpecular())
return {};
Float cosTheta_o = AbsCosTheta(wo), cosTheta_i = AbsCosTheta(wi);
Vector3f wh = wi + wo;
// Handle degenerate ca... | subq $0x128, %rsp # imm = 0x128
vmovlpd %xmm0, 0xf8(%rsp)
vmovss %xmm1, 0x100(%rsp)
movl 0x100(%rsp), %eax
movl %eax, 0x110(%rsp)
movq 0xf8(%rsp), %rax
movq %rax, 0x108(%rsp)
vmovlpd %xmm2, 0xdc(%rsp)
vmovss %xmm3, 0xe4(%rsp)
movq 0xdc(%rsp), %rax
movq %rax, 0xec(%rsp)
movl 0xe4(%rsp), %eax
movl %eax, 0xf4(%... | /anderslanglands[P]pbrt-v4/src/pbrt/bxdfs.h |
auto pbrt::detail::DispatchSplit<4>::operator()<pbrt::SamplerHandle::StartPixelSample(pbrt::Point2<int> const&, int, int)::'lambda'(auto), pbrt::TaggedPointer<pbrt::HaltonSampler, pbrt::PaddedSobolSampler, pbrt::PMJ02BNSampler, pbrt::RandomSampler, pbrt::SobolSampler, pbrt::StratifiedSampler, pbrt::MLTSampler, pbrt::De... | 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 0x6d9bb1
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<2>::operator()<pbrt::SamplerHandle::StartPixelSample(pbrt::Point2<int> const&, int, int)::'lambda'(auto), pbrt::TaggedPointer<pbrt::HaltonSampler, pbrt::PaddedSobolSampler, pbrt::PMJ02BNSampler, pbrt::RandomSampler, pbrt::SobolSampler, pbrt::StratifiedSampler, pbrt::MLTSampler, pbrt::De... | 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 0x6d9df1
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<2>::operator()<pbrt::SamplerHandle::SamplesPerPixel() const::'lambda'(auto), pbrt::TaggedPointer<pbrt::HaltonSampler, pbrt::PaddedSobolSampler, pbrt::PMJ02BNSampler, pbrt::RandomSampler, pbrt::SobolSampler, pbrt::StratifiedSampler, pbrt::MLTSampler, pbrt::DebugMLTSampler>, pbrt::SobolSa... | 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 0x6db4c3
movq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x420fb0
movl 0x3c(%rsp), %edx
leaq 0x37(%rsp), %rdi
leaq 0x28(%rsp), %rsi
cal... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
pbrt::RGBFilm::AddSample(pbrt::Point2<int> const&, pbrt::SampledSpectrum, pbrt::SampledWavelengths const&, pbrt::VisibleSurface const*, float) | PBRT_CPU_GPU
void AddSample(const Point2i &pFilm, SampledSpectrum L,
const SampledWavelengths &lambda, const VisibleSurface *,
Float weight) {
// Convert sample radiance to _PixelSensor_ RGB
SampledSpectrum H = L * sensor->ImagingRatio();
RGB rgb = senso... | subq $0xb8, %rsp
vmovlpd %xmm0, 0xa8(%rsp)
vmovlpd %xmm1, 0xb0(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
vmovss %xmm2, 0x84(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rax), %rdi
callq 0x5b8200
leaq 0xa8(%rsp), %rdi
callq 0x406fa0
movq 0x10(%rsp), %ra... | /anderslanglands[P]pbrt-v4/src/pbrt/film.h |
auto pbrt::detail::DispatchSplit<4>::operator()<pbrt::LightSamplerHandle::Sample(float) const::'lambda'(auto), pbrt::TaggedPointer<pbrt::UniformLightSampler, pbrt::PowerLightSampler, pbrt::BVHLightSampler, pbrt::ExhaustiveLightSampler>, pbrt::UniformLightSampler, pbrt::PowerLightSampler, pbrt::BVHLightSampler, pbrt::Ex... | 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 $0x2, 0x58(%rsp)
movl 0x5c(%rsp), %eax
subl $0x1, %eax
cmpl $0x2, %eax
jge 0x6fad42
movq 0x8(%rsp), %rsi
mo... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
void pbrt::detail::stringPrintfRecursive<char const (&) [32]>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [32]) | 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<int&, int&, int&, int&, int&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, int&, int&, 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 $0x2a8, %rsp # imm = 0x2A8
movq 0x2b0(%rsp), %rax
movq %rdi, 0x2a0(%rsp)
movq %rsi, 0x298(%rsp)
movq %rdx, 0x290(%rsp)
movq %rcx, 0x288(%rsp)
movq %r8, 0x280(%rsp)
movq %r9, 0x278(%rsp)
movq 0x2a0(%rsp), %rdx
leaq 0x258(%rsp), %rdi
leaq 0x298(%rsp), %rsi
callq 0x4ccc90
leaq 0x258(%rsp), %rdi
movl $0x2a,... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
auto pbrt::detail::DispatchSplit<5>::operator()<pbrt::FilterHandle::Sample(pbrt::Point2<float> const&) const::'lambda'(auto), pbrt::TaggedPointer<pbrt::BoxFilter, pbrt::GaussianFilter, pbrt::MitchellFilter, pbrt::LanczosSincFilter, pbrt::TriangleFilter>, pbrt::BoxFilter, pbrt::GaussianFilter, pbrt::MitchellFilter, pbrt... | 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 $0xc8, %rsp
movq %rdx, 0x18(%rsp)
movq %rsi, 0xb0(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rdx, 0x98(%rsp)
movl %ecx, 0x94(%rsp)
movl $0x2, 0x90(%rsp)
movl 0x94(%rsp), %eax
subl $0x1, %eax
cmpl $0x2, %eax
jge 0x700bb0
movq 0x18(%rsp), %rsi
movq 0xb0(%rsp), %rax
movq %rax, 0x80(%rsp)
leaq 0x78(%rsp), %rdi
movq %rdi, 0x10(... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplit<3>::operator()<pbrt::FilterHandle::Sample(pbrt::Point2<float> const&) const::'lambda'(auto), pbrt::TaggedPointer<pbrt::BoxFilter, pbrt::GaussianFilter, pbrt::MitchellFilter, pbrt::LanczosSincFilter, pbrt::TriangleFilter>, pbrt::MitchellFilter, pbrt::LanczosSincFilter, pbrt::TriangleFilt... | 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 $0xc8, %rsp
movq %rdx, 0x18(%rsp)
movq %rsi, 0xb0(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rdx, 0x98(%rsp)
movl %ecx, 0x94(%rsp)
movl $0x1, 0x90(%rsp)
movl 0x94(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x700e30
movq 0x18(%rsp), %rsi
movq 0xb0(%rsp), %rax
movq %rax, 0x80(%rsp)
leaq 0x78(%rsp), %rdi
movq %rdi, 0x10(... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
void pbrt::detail::stringPrintfRecursive<int const&, int&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, int const&, 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 |
pbrt::TaggedPointer<pbrt::HomogeneousMedium, pbrt::GeneralMedium<pbrt::UniformGridMediumProvider>, pbrt::GeneralMedium<pbrt::CloudMediumProvider>, pbrt::GeneralMedium<pbrt::NanoVDBMediumProvider>>::TaggedPointer<pbrt::GeneralMedium<pbrt::NanoVDBMediumProvider> const>(pbrt::GeneralMedium<pbrt::NanoVDBMediumProvider> con... | 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 |
void pbrt::detail::stringPrintfRecursive<std::unique_ptr<pbrt::PowerLightSampler, std::default_delete<pbrt::PowerLightSampler>> const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, std::unique_ptr<pbrt::PowerLightSampler, std::default_delete<pbrt::PowerLightSampler>> con... | 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<pbrt::LightSamplerHandle const&, bool const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, pbrt::LightSamplerHandle 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 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 (&) [43]>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [43]) | 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 |
pbrt::BDPTIntegrator::BDPTIntegrator(pbrt::CameraHandle, pbrt::SamplerHandle, pbrt::PrimitiveHandle, std::vector<pbrt::LightHandle, std::allocator<pbrt::LightHandle>>, int, bool, bool, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | BDPTIntegrator(CameraHandle camera, SamplerHandle sampler, PrimitiveHandle aggregate,
std::vector<LightHandle> lights, int maxDepth,
bool visualizeStrategies, bool visualizeWeights,
const std::string &lightSampleStrategy = "power",
bool regular... | subq $0xe8, %rsp
movq %r8, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %rdx, %r10
movq %r10, 0x20(%rsp)
movq %rdi, %r11
movq 0x28(%rsp), %rdi
movb 0x108(%rsp), %al
movq 0x100(%rsp), %rcx
movb 0xf8(%rsp), %cl
movb 0xf0(%rsp), %dl
movq %r11, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %r10, 0xd0(%rsp)
movq %rdi, 0xc8(%rsp)
movq %r8,... | /anderslanglands[P]pbrt-v4/src/pbrt/cpu/integrators.h |
void pbrt::detail::stringPrintfRecursive<int const&, float const&, float const&, pbrt::LightSamplerHandle const&, bool const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, int const&, float const&, float const&, pbrt::LightSamplerHandle 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 $0x2a8, %rsp # imm = 0x2A8
movq 0x2b0(%rsp), %rax
movq %rdi, 0x2a0(%rsp)
movq %rsi, 0x298(%rsp)
movq %rdx, 0x290(%rsp)
movq %rcx, 0x288(%rsp)
movq %r8, 0x280(%rsp)
movq %r9, 0x278(%rsp)
movq 0x2a0(%rsp), %rdx
leaq 0x258(%rsp), %rdi
leaq 0x298(%rsp), %rsi
callq 0x4ccc90
leaq 0x258(%rsp), %rdi
movl $0x2a,... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
pbrt::MLTIntegrator::MLTIntegrator(pbrt::CameraHandle, pbrt::PrimitiveHandle, std::vector<pbrt::LightHandle, std::allocator<pbrt::LightHandle>>, int, int, int, int, float, float, bool) | MLTIntegrator(CameraHandle camera, PrimitiveHandle aggregate,
std::vector<LightHandle> lights, int maxDepth, int nBootstrap,
int nChains, int mutationsPerPixel, Float sigma,
Float largeStepProbability, bool regularize)
: Integrator(aggregate, lights),
... | subq $0xc8, %rsp
movq %rcx, 0x28(%rsp)
movq %rdx, 0x18(%rsp)
movq %rsi, %rdx
movq 0x18(%rsp), %rsi
movq %rdx, 0x20(%rsp)
movb 0xe0(%rsp), %al
movl 0xd8(%rsp), %r10d
movl 0xd0(%rsp), %r10d
movq %rdi, 0xc0(%rsp)
movq %rdx, 0xb8(%rsp)
movq %rsi, 0xb0(%rsp)
movq %rcx, 0xa8(%rsp)
movl %r8d, 0xa4(%rsp)
movl %r9d, 0xa0(%rsp)
... | /anderslanglands[P]pbrt-v4/src/pbrt/cpu/integrators.h |
pbrt::TaggedPointer<pbrt::UniformLightSampler, pbrt::PowerLightSampler, pbrt::BVHLightSampler, pbrt::ExhaustiveLightSampler>::TaggedPointer<pbrt::BVHLightSampler>(pbrt::BVHLightSampler*) | 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<int const&, int const&, bool const&, pbrt::RGBColorSpace const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, int const&, int const&, bool const&, pbrt::RGBColorSpace 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 $0x298, %rsp # imm = 0x298
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(%rsp), %rdi
movl $0x2a, %esi
xorl %eax, %eax
m... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
auto pbrt::detail::DispatchSplitCPU<6>::operator()<pbrt::PrimitiveHandle::Bounds() const::$_0, pbrt::TaggedPointer<pbrt::SimplePrimitive, pbrt::GeometricPrimitive, pbrt::TransformedPrimitive, pbrt::AnimatedPrimitive, pbrt::BVHAggregate, pbrt::KdTreeAggregate>, pbrt::SimplePrimitive, pbrt::GeometricPrimitive, pbrt::Tran... | 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 $0x3, 0x48(%rsp)
movl 0x4c(%rsp), %eax
subl $0x1, %eax
cmpl $0x3, %eax
jge 0x71662e
movq 0x8(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x420f00
movq 0x10(%rsp), %rdi
mov... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplitCPU<6>::operator()<pbrt::PrimitiveHandle::Intersect(pbrt::Ray const&, float) const::$_0, pbrt::TaggedPointer<pbrt::SimplePrimitive, pbrt::GeometricPrimitive, pbrt::TransformedPrimitive, pbrt::AnimatedPrimitive, pbrt::BVHAggregate, pbrt::KdTreeAggregate>, pbrt::SimplePrimitive, pbrt::Geom... | 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 $0x98, %rsp
movq %r8, (%rsp)
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x90(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x88(%rsp)
movq %rsi, 0x70(%rsp)
movq %r8, 0x68(%rsp)
movl %r9d, 0x64(%rsp)
movl $0x3, 0x60(%rsp)
movl 0x64(%rsp), %eax
subl $0x1, %eax
cmpl $0x3, %eax
jge 0x716c90
movq (%... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplitCPU<6>::operator()<pbrt::PrimitiveHandle::IntersectP(pbrt::Ray const&, float) const::$_0, pbrt::TaggedPointer<pbrt::SimplePrimitive, pbrt::GeometricPrimitive, pbrt::TransformedPrimitive, pbrt::AnimatedPrimitive, pbrt::BVHAggregate, pbrt::KdTreeAggregate>, pbrt::SimplePrimitive, pbrt::Geo... | 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 %rcx, (%rsp)
movq %rsi, 0x70(%rsp)
movq %rdx, 0x78(%rsp)
movq %rdi, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movl %r8d, 0x54(%rsp)
movl $0x3, 0x50(%rsp)
movl 0x54(%rsp), %eax
subl $0x1, %eax
cmpl $0x3, %eax
jge 0x717533
movq (%rsp), %rsi
movq 0x70(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x78(%rsp), %rax
mo... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplit<3>::operator()<pbrt::ShapeHandle::Intersect(pbrt::Ray const&, float) 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::... | 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 $0x98, %rsp
movq %r8, (%rsp)
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x90(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x88(%rsp)
movq %rsi, 0x70(%rsp)
movq %r8, 0x68(%rsp)
movl %r9d, 0x64(%rsp)
movl $0x1, 0x60(%rsp)
movl 0x64(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x718b80
movq (%... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplit<5>::operator()<pbrt::MaterialHandle::IsTransparent() const::'lambda'(auto), pbrt::TaggedPointer<pbrt::CoatedDiffuseMaterial, pbrt::CoatedConductorMaterial, pbrt::ConductorMaterial, pbrt::DielectricMaterial, pbrt::DiffuseMaterial, pbrt::DiffuseTransmissionMaterial, pbrt::HairMaterial, pb... | 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 0x71a595
movq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x389a90
movl 0x3c(%rsp), %edx
leaq 0x37(%rsp), %rdi
leaq 0x28(%rsp), %rsi
cal... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
void pbrt::LogFatal<char const (&) [15], char const (&) [16], char const (&) [15], int&, char const (&) [16], int&>(pbrt::LogLevel, char const*, int, char const*, char const (&) [15], char const (&) [16], char const (&) [15], int&, char const (&) [16], 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::ProgressReporter::Done() | void ProgressReporter::Done() {
if (!quiet) {
#ifdef PBRT_BUILD_GPU_RENDERER
if (gpuEvents.size()) {
CHECK_EQ(gpuEventsLaunchedOffset.load(), gpuEvents.size());
while (gpuEventsFinishedOffset < gpuEventsLaunchedOffset) {
cudaError_t err =
cudaEvent... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
testb $0x1, 0x28(%rax)
jne 0x7219e1
movq (%rsp), %rdi
movb $0x0, 0xf(%rsp)
addq $0x40, %rdi
leaq 0xf(%rsp), %rsi
movl $0x1, %edx
movl $0x5, %ecx
callq 0x722510
testb $0x1, %al
jne 0x72198f
jmp 0x7219df
movq (%rsp), %rdi
movq (%rdi), %rsi
add... | /anderslanglands[P]pbrt-v4/src/pbrt/util/progressreporter.cpp |
void pbrt::detail::stringPrintfRecursive<std::atomic<bool> const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, std::atomic<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 0x250(%rsp), %rdx
leaq 0x220(%rsp), %rdi
leaq 0x248(%rsp), %rsi
callq 0x4ccc90
leaq 0x220(%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<unsigned long const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, unsigned long 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::BSSRDFTable::BSSRDFTable(int, int, pstd::pmr::polymorphic_allocator<std::byte>) | BSSRDFTable::BSSRDFTable(int nRhoSamples, int nRadiusSamples, Allocator alloc)
: rhoSamples(nRhoSamples, alloc),
radiusSamples(nRadiusSamples, alloc),
profile(nRadiusSamples * nRhoSamples, alloc),
rhoEff(nRhoSamples, alloc),
profileCDF(nRadiusSamples * nRhoSamples, alloc) {} | subq $0xd8, %rsp
movq %rcx, 0xd0(%rsp)
movq %rdi, 0xc8(%rsp)
movl %esi, 0xc4(%rsp)
movl %edx, 0xc0(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, 0x60(%rsp)
movq %rax, 0x48(%rsp)
movslq 0xc4(%rsp), %rax
movq %rax, 0x50(%rsp)
leaq 0xb8(%rsp), %rdi
movq %rdi, 0x58(%rsp)
leaq 0xd0(%rsp), %rsi
movq %rsi, 0x68(%rsp)
callq 0x3e97c0
... | /anderslanglands[P]pbrt-v4/src/pbrt/bssrdf.cpp |
void pbrt::detail::stringPrintfRecursive<pbrt::BSSRDFTable const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, pbrt::BSSRDFTable 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<pstd::vector<float, pstd::pmr::polymorphic_allocator<float>> const&, pstd::vector<float, pstd::pmr::polymorphic_allocator<float>> const&, pstd::vector<float, pstd::pmr::polymorphic_allocator<float>> const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<... | 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<pstd::vector<float, pstd::pmr::polymorphic_allocator<float>> const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, pstd::vector<float, pstd::pmr::polymorphic_allocator<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 |
pbrt::LayeredBxDF<pbrt::DielectricInterfaceBxDF, pbrt::IdealDiffuseBxDF>::Sample_f(pbrt::Vector3<float>, float, pbrt::Point2<float> const&, pbrt::TransportMode, pbrt::BxDFReflTransFlags) const | PBRT_CPU_GPU
BSDFSample Sample_f(Vector3f wo, Float uc, const Point2f &u, TransportMode mode,
BxDFReflTransFlags sampleFlags = BxDFReflTransFlags::All) const {
CHECK(sampleFlags == BxDFReflTransFlags::All); // for now
// Set _wo_ for layered BSDF sampling
bool flipWi... | subq $0x2a8, %rsp # imm = 0x2A8
movq %rdi, 0x40(%rsp)
movq %rdi, 0x48(%rsp)
vmovlpd %xmm0, 0x28c(%rsp)
vmovss %xmm1, 0x294(%rsp)
movq 0x28c(%rsp), %rax
movq %rax, 0x29c(%rsp)
movl 0x294(%rsp), %eax
movl %eax, 0x2a4(%rsp)
movq %rsi, 0x280(%rsp)
vmovss %xmm2, 0x27c(%rsp)
movq %rdx, 0x270(%rsp)
movl %ecx, 0x26c... | /anderslanglands[P]pbrt-v4/src/pbrt/bxdfs.h |
pbrt::LayeredBxDF<pbrt::DielectricInterfaceBxDF, pbrt::ConductorBxDF>::f(pbrt::Vector3<float>, pbrt::Vector3<float>, pbrt::TransportMode) const | f(Vector3f wo, Vector3f wi, TransportMode mode) const {
SampledSpectrum f(0.);
// Set _wi_ and _wi_ for layered BSDF evaluation
if (config.twoSided && wo.z < 0) {
// BIG WIN
wo = -wo;
wi = -wi;
}
// Determine entrance and exit interfaces for l... | subq $0x6a8, %rsp # imm = 0x6A8
vmovlpd %xmm0, 0x678(%rsp)
vmovss %xmm1, 0x680(%rsp)
movl 0x680(%rsp), %eax
movl %eax, 0x690(%rsp)
movq 0x678(%rsp), %rax
movq %rax, 0x688(%rsp)
vmovlpd %xmm2, 0x65c(%rsp)
vmovss %xmm3, 0x664(%rsp)
movq 0x65c(%rsp), %rax
movq %rax, 0x66c(%rsp)
movl 0x664(%rsp), %eax
movl %eax,... | /anderslanglands[P]pbrt-v4/src/pbrt/bxdfs.h |
pstd::array<float const*, 2>::array(std::initializer_list<float const*>) | PBRT_CPU_GPU
array(std::initializer_list<T> v) {
size_t i = 0;
for (const T &val : v)
values[i++] = val;
} | subq $0x58, %rsp
movq %rsi, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movq %rax, %rcx
addq $0x10, %rcx
movq %rcx, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq $0x0, (%rax)
addq $0x8, %rax
cmpq %rcx, %rax
movq %rax, 0x10(%rsp)
jne 0x... | /anderslanglands[P]pbrt-v4/src/pbrt/util/pstd.h |
pbrt::PiecewiseLinear2D<2ul>::Invert(pbrt::Vector2<float>, float const*) const | PBRT_CPU_GPU
PLSample Invert(Vector2f sample, const Float *param = nullptr) const {
/* Look up parameter-related indices and weights (if Dimension != 0) */
float param_weight[2 * ArraySize];
uint32_t slice_offset = 0u;
for (size_t dim = 0; dim < Dimension; ++dim) {
if (m_... | subq $0x158, %rsp # imm = 0x158
vmovlpd %xmm0, 0x140(%rsp)
movq %rdi, 0x138(%rsp)
movq %rsi, 0x130(%rsp)
movq 0x138(%rsp), %rax
movq %rax, 0x58(%rsp)
movl $0x0, 0x11c(%rsp)
movq $0x0, 0x110(%rsp)
cmpq $0x2, 0x110(%rsp)
jae 0x73ef85
movq 0x58(%rsp), %rax
movq 0x110(%rsp), %rcx
cmpl $0x1, 0x18(%rax,%rcx,4)
jne... | /anderslanglands[P]pbrt-v4/src/pbrt/util/sampling.h |
pbrt::PiecewiseLinear2D<2ul>::Sample(pbrt::Vector2<float>, float const*) const | PBRT_CPU_GPU
PLSample Sample(Vector2f sample, const Float *param = nullptr) const {
/* Avoid degeneracies at the extrema */
sample[0] = Clamp(sample[0], 1 - OneMinusEpsilon, OneMinusEpsilon);
sample[1] = Clamp(sample[1], 1 - OneMinusEpsilon, OneMinusEpsilon);
/* Look up parameter-re... | subq $0x158, %rsp # imm = 0x158
vmovlpd %xmm0, 0x144(%rsp)
movq %rdi, 0x138(%rsp)
movq %rsi, 0x130(%rsp)
movq 0x138(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x144(%rsp), %rdi
xorl %esi, %esi
callq 0x3cf090
vmovss (%rax), %xmm0
vmovss 0x10e3b4(%rip), %xmm1 # 0x84e36c
vmovss 0x11527c(%rip), %xmm2 # 0x85523c
... | /anderslanglands[P]pbrt-v4/src/pbrt/util/sampling.h |
pbrt::I0(float) | PBRT_CPU_GPU
inline Float I0(Float x) {
Float val = 0;
Float x2i = 1;
int64_t ifact = 1;
int i4 = 1;
// I0(x) \approx Sum_i x^(2i) / (4^i (i!)^2)
for (int i = 0; i < 10; ++i) {
if (i > 1)
ifact *= i;
val += x2i / (i4 * Sqr(ifact));
x2i *= x * x;
i4 *= ... | subq $0x38, %rsp
vmovss %xmm0, 0x34(%rsp)
vpxor %xmm0, %xmm0, %xmm0
vmovss %xmm0, 0x30(%rsp)
vmovss 0x109c68(%rip), %xmm0 # 0x84b154
vmovss %xmm0, 0x2c(%rsp)
movq $0x1, 0x20(%rsp)
movl $0x1, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
cmpl $0xa, 0x18(%rsp)
jge 0x7415a7
cmpl $0x1, 0x18(%rsp)
jle 0x74152d
movslq 0x18(%rsp), %rax
... | /anderslanglands[P]pbrt-v4/src/pbrt/util/math.h |
void pbrt::detail::stringPrintfRecursive<pbrt::SampledSpectrum const&, pbrt::SampledSpectrum const&, float const&, float const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, pbrt::SampledSpectrum const&, pbrt::SampledSpectrum 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 $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&, float const&, float const&, pbrt::SampledSpectrum 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&, pbrt::SampledSp... | 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 |
pbrt::PiecewiseLinear2D<2ul>::PiecewiseLinear2D(pstd::pmr::polymorphic_allocator<std::byte>) | PiecewiseLinear2D(Allocator alloc)
: m_param_values(alloc),
m_data(alloc),
m_marginal_cdf(alloc),
m_conditional_cdf(alloc) {
for (int i = 0; i < ArraySize; ++i)
m_param_values.emplace_back(alloc);
} | subq $0x98, %rsp
movq %rsi, 0x90(%rsp)
movq %rdi, 0x88(%rsp)
movq 0x88(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x746d00
movq 0x30(%rsp), %rdi
addq $0x8, %rdi
callq 0x3fd880
movq 0x30(%rsp), %rdi
addq $0x10, %rdi
callq 0x3fd880
movq 0x30(%rsp), %rax
addq $0x28, %rax
movq %rax, 0x20(%rsp)
leaq 0x80(%rsp), %rdi
movq %rdi,... | /anderslanglands[P]pbrt-v4/src/pbrt/util/sampling.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.