name string | code string | asm string | file string |
|---|---|---|---|
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 $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 |
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 $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 $0x9, -0x1a(%rsp)
movabsq $0x9000000000000, %rcx # imm = 0x9000000000000
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 $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 $0xc, -0x1a(%rsp)
movabsq $0xc000000000000, %rcx # imm = 0xC000000000000
orq -0x18(%rsp), %rcx
movq %rcx, (%rax)
retq
nopw (%rax,%rax)
| /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplit<6>::operator()<pbrt::FloatTextureHandle::Evaluate(pbrt::TextureEvalContext) const::'lambda'(auto), pbrt::TaggedPointer<pbrt::FloatImageTexture, pbrt::GPUFloatImageTexture, pbrt::FloatMixTexture, pbrt::FloatScaledTexture, pbrt::FloatConstantTexture, pbrt::FloatBilerpTexture, pbrt::FloatC... | PBRT_CPU_GPU inline auto operator()(F func, Tp tp, int tag, TypePack<Ts...> types) {
constexpr int mid = n / 2;
if (tag - 1 < mid) // 0-based indexing here to be more traditional
return DispatchSplit<mid>()(
func, tp, tag, typename TakeFirstN<mid, TypePack<Ts...>>::type());... | subq $0x78, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movl %ecx, 0x4c(%rsp)
movl $0x3, 0x48(%rsp)
movl 0x4c(%rsp), %eax
subl $0x1, %eax
cmpl $0x3, %eax
jge 0x404019
movq 0x8(%rsp), %rsi
movq 0x68(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x4007f0
mov... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplit<6>::operator()<pbrt::FloatTextureHandle::Evaluate(pbrt::TextureEvalContext) const::'lambda'(auto), pbrt::TaggedPointer<pbrt::FloatImageTexture, pbrt::GPUFloatImageTexture, pbrt::FloatMixTexture, pbrt::FloatScaledTexture, pbrt::FloatConstantTexture, pbrt::FloatBilerpTexture, pbrt::FloatC... | PBRT_CPU_GPU inline auto operator()(F func, Tp tp, int tag, TypePack<Ts...> types) {
constexpr int mid = n / 2;
if (tag - 1 < mid) // 0-based indexing here to be more traditional
return DispatchSplit<mid>()(
func, tp, tag, typename TakeFirstN<mid, TypePack<Ts...>>::type());... | subq $0x78, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movl %ecx, 0x4c(%rsp)
movl $0x3, 0x48(%rsp)
movl 0x4c(%rsp), %eax
subl $0x1, %eax
cmpl $0x3, %eax
jge 0x4040c9
movq 0x8(%rsp), %rsi
movq 0x68(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x4007f0
mov... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplit<3>::operator()<pbrt::FloatTextureHandle::Evaluate(pbrt::TextureEvalContext) const::'lambda'(auto), pbrt::TaggedPointer<pbrt::FloatImageTexture, pbrt::GPUFloatImageTexture, pbrt::FloatMixTexture, pbrt::FloatScaledTexture, pbrt::FloatConstantTexture, pbrt::FloatBilerpTexture, pbrt::FloatC... | PBRT_CPU_GPU inline auto operator()(F func, Tp tp, int tag, TypePack<Ts...> types) {
constexpr int mid = n / 2;
if (tag - 1 < mid) // 0-based indexing here to be more traditional
return DispatchSplit<mid>()(
func, tp, tag, typename TakeFirstN<mid, TypePack<Ts...>>::type());... | subq $0x78, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movl %ecx, 0x4c(%rsp)
movl $0x1, 0x48(%rsp)
movl 0x4c(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x404179
movq 0x8(%rsp), %rsi
movq 0x68(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x4007f0
mov... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
pbrt::FloatImageTexture::Evaluate(pbrt::TextureEvalContext) const | PBRT_CPU_GPU
Float Evaluate(TextureEvalContext ctx) const {
#ifdef PBRT_IS_GPU_CODE
assert(!"Should not be called in GPU code");
return 0;
#else
if (!mipmap)
return scale;
Vector2f dstdx, dstdy;
Point2f st = mapping.Map(ctx, &dstdx, &dstdy);
// Texture coo... | subq $0xf8, %rsp
leaq 0x100(%rsp), %rax
movq %rax, 0x70(%rsp)
movq %rdi, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
movq %rax, 0x78(%rsp)
cmpq $0x0, 0x10(%rax)
jne 0x404418
movq 0x78(%rsp), %rax
vmovss 0x8(%rax), %xmm0
vmovss %xmm0, 0xf4(%rsp)
jmp 0x40453c
leaq 0xe0(%rsp), %rdi
movq %rdi, 0x48(%rsp)
callq 0x3fd880
leaq 0xd8(%rsp... | /anderslanglands[P]pbrt-v4/src/pbrt/textures.h |
auto pbrt::detail::DispatchSplit<2>::operator()<pbrt::FloatTextureHandle::Evaluate(pbrt::TextureEvalContext) const::'lambda'(auto), pbrt::TaggedPointer<pbrt::FloatImageTexture, pbrt::GPUFloatImageTexture, pbrt::FloatMixTexture, pbrt::FloatScaledTexture, pbrt::FloatConstantTexture, pbrt::FloatBilerpTexture, pbrt::FloatC... | PBRT_CPU_GPU inline auto operator()(F func, Tp tp, int tag, TypePack<Ts...> types) {
constexpr int mid = n / 2;
if (tag - 1 < mid) // 0-based indexing here to be more traditional
return DispatchSplit<mid>()(
func, tp, tag, typename TakeFirstN<mid, TypePack<Ts...>>::type());... | subq $0x78, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movl %ecx, 0x4c(%rsp)
movl $0x1, 0x48(%rsp)
movl 0x4c(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x404889
movq 0x8(%rsp), %rsi
movq 0x68(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x4007f0
mov... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplit<3>::operator()<pbrt::FloatTextureHandle::Evaluate(pbrt::TextureEvalContext) const::'lambda'(auto), pbrt::TaggedPointer<pbrt::FloatImageTexture, pbrt::GPUFloatImageTexture, pbrt::FloatMixTexture, pbrt::FloatScaledTexture, pbrt::FloatConstantTexture, pbrt::FloatBilerpTexture, pbrt::FloatC... | PBRT_CPU_GPU inline auto operator()(F func, Tp tp, int tag, TypePack<Ts...> types) {
constexpr int mid = n / 2;
if (tag - 1 < mid) // 0-based indexing here to be more traditional
return DispatchSplit<mid>()(
func, tp, tag, typename TakeFirstN<mid, TypePack<Ts...>>::type());... | subq $0x78, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movl %ecx, 0x4c(%rsp)
movl $0x1, 0x48(%rsp)
movl 0x4c(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x404db9
movq 0x8(%rsp), %rsi
movq 0x68(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x4007f0
mov... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplit<3>::operator()<pbrt::FloatTextureHandle::Evaluate(pbrt::TextureEvalContext) const::'lambda'(auto), pbrt::TaggedPointer<pbrt::FloatImageTexture, pbrt::GPUFloatImageTexture, pbrt::FloatMixTexture, pbrt::FloatScaledTexture, pbrt::FloatConstantTexture, pbrt::FloatBilerpTexture, pbrt::FloatC... | PBRT_CPU_GPU inline auto operator()(F func, Tp tp, int tag, TypePack<Ts...> types) {
constexpr int mid = n / 2;
if (tag - 1 < mid) // 0-based indexing here to be more traditional
return DispatchSplit<mid>()(
func, tp, tag, typename TakeFirstN<mid, TypePack<Ts...>>::type());... | subq $0x78, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movl %ecx, 0x4c(%rsp)
movl $0x1, 0x48(%rsp)
movl 0x4c(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x404e69
movq 0x8(%rsp), %rsi
movq 0x68(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x4007f0
mov... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
pbrt::FloatCheckerboardTexture::Evaluate(pbrt::TextureEvalContext) const | PBRT_CPU_GPU
Float Evaluate(TextureEvalContext ctx) const {
pstd::array<Float, 2> wt = Checkerboard(aaMethod, ctx, map2D, map3D);
if (wt[0] == 0)
return wt[1] * tex[1].Evaluate(ctx);
else if (wt[1] == 0)
return wt[0] * tex[0].Evaluate(ctx);
else
re... | subq $0x218, %rsp # imm = 0x218
leaq 0x220(%rsp), %rax
movq %rax, 0x88(%rsp)
movq %rdi, 0x208(%rsp)
movq 0x208(%rsp), %rsi
movq %rsi, 0x90(%rsp)
movl 0x20(%rsi), %ecx
movl %ecx, 0x9c(%rsp)
vmovdqu64 (%rax), %zmm0
vmovdqu64 %zmm0, 0x1c0(%rsp)
leaq 0x1b8(%rsp), %rdi
movq %rdi, 0xa0(%rsp)
vzeroupper
callq 0x405... | /anderslanglands[P]pbrt-v4/src/pbrt/textures.h |
auto pbrt::detail::DispatchSplit<2>::operator()<pbrt::FloatTextureHandle::Evaluate(pbrt::TextureEvalContext) const::'lambda'(auto), pbrt::TaggedPointer<pbrt::FloatImageTexture, pbrt::GPUFloatImageTexture, pbrt::FloatMixTexture, pbrt::FloatScaledTexture, pbrt::FloatConstantTexture, pbrt::FloatBilerpTexture, pbrt::FloatC... | PBRT_CPU_GPU inline auto operator()(F func, Tp tp, int tag, TypePack<Ts...> types) {
constexpr int mid = n / 2;
if (tag - 1 < mid) // 0-based indexing here to be more traditional
return DispatchSplit<mid>()(
func, tp, tag, typename TakeFirstN<mid, TypePack<Ts...>>::type());... | subq $0x78, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movl %ecx, 0x4c(%rsp)
movl $0x1, 0x48(%rsp)
movl 0x4c(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x4059d9
movq 0x8(%rsp), %rsi
movq 0x68(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x4007f0
mov... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplit<12>::operator()<pbrt::SpectrumTextureHandle::Evaluate(pbrt::TextureEvalContext, pbrt::SampledWavelengths) const::'lambda'(auto), pbrt::TaggedPointer<pbrt::RGBConstantTexture, pbrt::RGBReflectanceConstantTexture, pbrt::SpectrumImageTexture, pbrt::GPUSpectrumImageTexture, pbrt::SpectrumMi... | 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 %rcx, 0x18(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x90(%rsp)
movq %rdi, 0x78(%rsp)
movq %rcx, 0x70(%rsp)
movl %r8d, 0x6c(%rsp)
movl $0x6, 0x68(%rsp)
movl 0x6c(%rsp), %eax
subl $0x1, %eax
cmpl $0x6, %eax
jge 0x406044
movq 0x18(%rsp), %rsi
vmovdqu 0x88(%rsp), %xmm0
vmovdqa %xmm0, 0x50(%rsp)
leaq 0x4... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplit<6>::operator()<pbrt::SpectrumTextureHandle::Evaluate(pbrt::TextureEvalContext, pbrt::SampledWavelengths) const::'lambda'(auto), pbrt::TaggedPointer<pbrt::RGBConstantTexture, pbrt::RGBReflectanceConstantTexture, pbrt::SpectrumImageTexture, pbrt::GPUSpectrumImageTexture, pbrt::SpectrumMix... | 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 %rcx, 0x18(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x90(%rsp)
movq %rdi, 0x78(%rsp)
movq %rcx, 0x70(%rsp)
movl %r8d, 0x6c(%rsp)
movl $0x3, 0x68(%rsp)
movl 0x6c(%rsp), %eax
subl $0x1, %eax
cmpl $0x3, %eax
jge 0x406154
movq 0x18(%rsp), %rsi
vmovdqu 0x88(%rsp), %xmm0
vmovdqa %xmm0, 0x50(%rsp)
leaq 0x4... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplit<6>::operator()<pbrt::SpectrumTextureHandle::Evaluate(pbrt::TextureEvalContext, pbrt::SampledWavelengths) const::'lambda'(auto), pbrt::TaggedPointer<pbrt::RGBConstantTexture, pbrt::RGBReflectanceConstantTexture, pbrt::SpectrumImageTexture, pbrt::GPUSpectrumImageTexture, pbrt::SpectrumMix... | 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 %rcx, 0x18(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x90(%rsp)
movq %rdi, 0x78(%rsp)
movq %rcx, 0x70(%rsp)
movl %r8d, 0x6c(%rsp)
movl $0x3, 0x68(%rsp)
movl 0x6c(%rsp), %eax
subl $0x1, %eax
cmpl $0x3, %eax
jge 0x406264
movq 0x18(%rsp), %rsi
vmovdqu 0x88(%rsp), %xmm0
vmovdqa %xmm0, 0x50(%rsp)
leaq 0x4... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplit<3>::operator()<pbrt::SpectrumTextureHandle::Evaluate(pbrt::TextureEvalContext, pbrt::SampledWavelengths) const::'lambda'(auto), pbrt::TaggedPointer<pbrt::RGBConstantTexture, pbrt::RGBReflectanceConstantTexture, pbrt::SpectrumImageTexture, pbrt::GPUSpectrumImageTexture, pbrt::SpectrumMix... | 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 %rcx, 0x18(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x90(%rsp)
movq %rdi, 0x78(%rsp)
movq %rcx, 0x70(%rsp)
movl %r8d, 0x6c(%rsp)
movl $0x1, 0x68(%rsp)
movl 0x6c(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x406484
movq 0x18(%rsp), %rsi
vmovdqu 0x88(%rsp), %xmm0
vmovdqa %xmm0, 0x50(%rsp)
leaq 0x4... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplit<2>::operator()<pbrt::SpectrumTextureHandle::Evaluate(pbrt::TextureEvalContext, pbrt::SampledWavelengths) const::'lambda'(auto), pbrt::TaggedPointer<pbrt::RGBConstantTexture, pbrt::RGBReflectanceConstantTexture, pbrt::SpectrumImageTexture, pbrt::GPUSpectrumImageTexture, pbrt::SpectrumMix... | 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 %rcx, 0x18(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x90(%rsp)
movq %rdi, 0x78(%rsp)
movq %rcx, 0x70(%rsp)
movl %r8d, 0x6c(%rsp)
movl $0x1, 0x68(%rsp)
movl 0x6c(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x4065f4
movq 0x18(%rsp), %rsi
vmovdqu 0x88(%rsp), %xmm0
vmovdqa %xmm0, 0x50(%rsp)
leaq 0x4... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplit<2>::operator()<pbrt::SpectrumTextureHandle::Evaluate(pbrt::TextureEvalContext, pbrt::SampledWavelengths) const::'lambda'(auto), pbrt::TaggedPointer<pbrt::RGBConstantTexture, pbrt::RGBReflectanceConstantTexture, pbrt::SpectrumImageTexture, pbrt::GPUSpectrumImageTexture, pbrt::SpectrumMix... | 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 %rcx, 0x18(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x90(%rsp)
movq %rdi, 0x78(%rsp)
movq %rcx, 0x70(%rsp)
movl %r8d, 0x6c(%rsp)
movl $0x1, 0x68(%rsp)
movl 0x6c(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x406a84
movq 0x18(%rsp), %rsi
vmovdqu 0x88(%rsp), %xmm0
vmovdqa %xmm0, 0x50(%rsp)
leaq 0x4... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplit<3>::operator()<pbrt::SpectrumTextureHandle::Evaluate(pbrt::TextureEvalContext, pbrt::SampledWavelengths) const::'lambda'(auto), pbrt::TaggedPointer<pbrt::RGBConstantTexture, pbrt::RGBReflectanceConstantTexture, pbrt::SpectrumImageTexture, pbrt::GPUSpectrumImageTexture, pbrt::SpectrumMix... | 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 %rcx, 0x18(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x90(%rsp)
movq %rdi, 0x78(%rsp)
movq %rcx, 0x70(%rsp)
movl %r8d, 0x6c(%rsp)
movl $0x1, 0x68(%rsp)
movl 0x6c(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x4072d4
movq 0x18(%rsp), %rsi
vmovdqu 0x88(%rsp), %xmm0
vmovdqa %xmm0, 0x50(%rsp)
leaq 0x4... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplit<2>::operator()<pbrt::SpectrumTextureHandle::Evaluate(pbrt::TextureEvalContext, pbrt::SampledWavelengths) const::'lambda'(auto), pbrt::TaggedPointer<pbrt::RGBConstantTexture, pbrt::RGBReflectanceConstantTexture, pbrt::SpectrumImageTexture, pbrt::GPUSpectrumImageTexture, pbrt::SpectrumMix... | 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 %rcx, 0x18(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x90(%rsp)
movq %rdi, 0x78(%rsp)
movq %rcx, 0x70(%rsp)
movl %r8d, 0x6c(%rsp)
movl $0x1, 0x68(%rsp)
movl 0x6c(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x407554
movq 0x18(%rsp), %rsi
vmovdqu 0x88(%rsp), %xmm0
vmovdqa %xmm0, 0x50(%rsp)
leaq 0x4... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplit<3>::operator()<pbrt::SpectrumHandle::Sample(pbrt::SampledWavelengths const&) const::'lambda'(auto), pbrt::TaggedPointer<pbrt::ConstantSpectrum, pbrt::DenselySampledSpectrum, pbrt::PiecewiseLinearSpectrum, pbrt::RGBSpectrum, pbrt::RGBReflectanceSpectrum, pbrt::BlackbodySpectrum>, pbrt::R... | 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 %rdx, 0x10(%rsp)
movq %rsi, 0x70(%rsp)
movq %rdi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movl %ecx, 0x54(%rsp)
movl $0x1, 0x50(%rsp)
movl 0x54(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x407a0a
movq 0x10(%rsp), %rsi
movq 0x70(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplit<2>::operator()<pbrt::SpectrumHandle::Sample(pbrt::SampledWavelengths const&) const::'lambda'(auto), pbrt::TaggedPointer<pbrt::ConstantSpectrum, pbrt::DenselySampledSpectrum, pbrt::PiecewiseLinearSpectrum, pbrt::RGBSpectrum, pbrt::RGBReflectanceSpectrum, pbrt::BlackbodySpectrum>, pbrt::R... | 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 %rdx, 0x10(%rsp)
movq %rsi, 0x70(%rsp)
movq %rdi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movl %ecx, 0x54(%rsp)
movl $0x1, 0x50(%rsp)
movl 0x54(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x407eea
movq 0x10(%rsp), %rsi
movq 0x70(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
void pbrt::LogFatal<char const (&) [11]>(pbrt::LogLevel, char const*, int, char const*, char const (&) [11]) | 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 0x37a770
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 |
auto pbrt::detail::DispatchSplit<2>::operator()<pbrt::SpectrumTextureHandle::Evaluate(pbrt::TextureEvalContext, pbrt::SampledWavelengths) const::'lambda'(auto), pbrt::TaggedPointer<pbrt::RGBConstantTexture, pbrt::RGBReflectanceConstantTexture, pbrt::SpectrumImageTexture, pbrt::GPUSpectrumImageTexture, pbrt::SpectrumMix... | 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 %rcx, 0x18(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x90(%rsp)
movq %rdi, 0x78(%rsp)
movq %rcx, 0x70(%rsp)
movl %r8d, 0x6c(%rsp)
movl $0x1, 0x68(%rsp)
movl 0x6c(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x409114
movq 0x18(%rsp), %rsi
vmovdqu 0x88(%rsp), %xmm0
vmovdqa %xmm0, 0x50(%rsp)
leaq 0x4... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
void pbrt::detail::stringPrintfRecursive<pbrt::Transform const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, pbrt::Transform 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<pbrt::Vector3<float> const&, float const&, float const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, pbrt::Vector3<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 $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<pbrt::SpectrumHandle const&, pbrt::SpectrumHandle const&, pbrt::SpectrumHandle const&, pbrt::SpectrumHandle const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, pbrt::SpectrumHandle const&, pbrt::SpectrumHandle const&, pbrt::Spect... | 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<pbrt::SpectrumHandle const&, pbrt::SpectrumHandle const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, pbrt::SpectrumHandle const&, pbrt::SpectrumHandle 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::FloatTextureHandle const&, pbrt::FloatTextureHandle const&, char const*>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, pbrt::FloatTextureHandle const&, pbrt::FloatTextureHandle const&, char const*&&) | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x258, %rsp # imm = 0x258
movq %rdi, 0x250(%rsp)
movq %rsi, 0x248(%rsp)
movq %rdx, 0x240(%rsp)
movq %rcx, 0x238(%rsp)
movq %r8, 0x230(%rsp)
movq 0x250(%rsp), %rdx
leaq 0x210(%rsp), %rdi
leaq 0x248(%rsp), %rsi
callq 0x4ccc90
leaq 0x210(%rsp), %rdi
movl $0x2a, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<char const*, char const*, pbrt::SpectrumTextureHandle const&, pbrt::SpectrumTextureHandle const&, char const*>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const*&&, char const*&&, pbrt::SpectrumTextureHandle const&, pbrt::Sp... | 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*, pbrt::SpectrumTextureHandle const&, pbrt::SpectrumTextureHandle const&, char const*>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const*&&, pbrt::SpectrumTextureHandle 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 %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<pbrt::FloatTextureHandle const&, pbrt::FloatTextureHandle const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, pbrt::FloatTextureHandle const&, pbrt::FloatTextureHandle 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<int const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, int 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 (&) [49]>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [49]) | 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<float const&, pbrt::MIPMap&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, float const&, pbrt::MIPMap&) | 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<pbrt::ColorEncodingHandle const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, pbrt::ColorEncodingHandle 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<pbrt::TextureMapping3DHandle const&, int const&, float const&, float const&, float const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, pbrt::TextureMapping3DHandle const&, int 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 $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::LogFatal<char const (&) [14], char const (&) [30], char const (&) [14], int&, char const (&) [30], unsigned long&>(pbrt::LogLevel, char const*, int, char const*, char const (&) [14], char const (&) [30], char const (&) [14], int&, char const (&) [30], 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::detail::stringPrintfRecursive<char const (&) [17], char const (&) [17], int&, char const (&) [17], unsigned long&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [17], char const (&) [17], int&, char const (&) [17], unsigned long&) | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x268, %rsp # imm = 0x268
movq 0x270(%rsp), %rax
movq %rdi, 0x260(%rsp)
movq %rsi, 0x258(%rsp)
movq %rdx, 0x250(%rsp)
movq %rcx, 0x248(%rsp)
movq %r8, 0x240(%rsp)
movq %r9, 0x238(%rsp)
movq 0x260(%rsp), %rdx
leaq 0x218(%rsp), %rdi
leaq 0x258(%rsp), %rsi
callq 0x4ccc90
leaq 0x218(%rsp), %rdi
movl $0x2a,... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<int&, char const (&) [17], unsigned long&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, int&, char const (&) [17], 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::TaggedPointer<pbrt::SimplePrimitive, pbrt::GeometricPrimitive, pbrt::TransformedPrimitive, pbrt::AnimatedPrimitive, pbrt::BVHAggregate, pbrt::KdTreeAggregate>::TaggedPointer<pbrt::SimplePrimitive>(pbrt::SimplePrimitive*) | 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::SimplePrimitive, pbrt::GeometricPrimitive, pbrt::TransformedPrimitive, pbrt::AnimatedPrimitive, pbrt::BVHAggregate, pbrt::KdTreeAggregate>::TaggedPointer<pbrt::BVHAggregate>(pbrt::BVHAggregate*) | 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 $0x5, -0x1a(%rsp)
movabsq $0x5000000000000, %rcx # imm = 0x5000000000000
orq -0x18(%rsp), %rcx
movq %rcx, (%rax)
retq
nopw (%rax,%rax)
| /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
pbrt::BufferCache<pbrt::Normal3<float>>::Clear() | void Clear() {
std::lock_guard<std::mutex> lock(mutex);
for (auto iter : cache)
alloc.deallocate_object(const_cast<T *>(iter.ptr), iter.size);
cache.clear();
} | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rsi
movq %rsi, 0x8(%rsp)
addq $0x8, %rsi
leaq 0x48(%rsp), %rdi
callq 0x38d0d0
movq 0x8(%rsp), %rax
addq $0x30, %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x427a90
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x427ac0
movq %rax, 0x30(%rsp)
leaq 0x... | /anderslanglands[P]pbrt-v4/src/pbrt/util/buffercache.h |
void pbrt::detail::stringPrintfRecursive<char const (&) [26]>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [26]) | 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::PrintStackTrace() | void PrintStackTrace() {
#if defined(PBRT_IS_OSX)
void* callstack[32];
int frames = backtrace(callstack, PBRT_ARRAYSIZE(callstack));
char** strs = backtrace_symbols(callstack, frames);
for (int i = 0; i < frames; ++i) {
// https://www.variadic.xyz/2013/04/14/generating-stack-trace-on-os-x/
... | subq $0x9a8, %rsp # imm = 0x9A8
leaq 0x8a0(%rsp), %rdi
movl $0x20, %esi
callq 0x3288c0
movl %eax, 0x89c(%rsp)
leaq 0x8a0(%rsp), %rdi
movl 0x89c(%rsp), %esi
callq 0x327890
movq %rax, 0x890(%rsp)
movl $0x0, 0x88c(%rsp)
movl 0x88c(%rsp), %eax
cmpl 0x89c(%rsp), %eax
jge 0x428b92
leaq 0x480(%rsp), %rdi
xorl %esi,... | /anderslanglands[P]pbrt-v4/src/pbrt/util/check.cpp |
void pbrt::detail::stringPrintfRecursive<char const (&) [17], char const (&) [2], char const (&) [17], unsigned long&, char const (&) [2], int&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [17], char const (&) [2], char const (&) [17], unsigned long&, cha... | 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 |
unsigned long pbrt::FindInterval<pbrt::RGBToSpectrumTable::operator()(pbrt::RGB const&) const::$_0>(unsigned long, pbrt::RGBToSpectrumTable::operator()(pbrt::RGB const&) const::$_0 const&) | PBRT_CPU_GPU inline size_t FindInterval(size_t size_, const Predicate &pred) {
using ssize_t = std::make_signed_t<size_t>; // Not all platforms have ssize_t
ssize_t size = (ssize_t)size_ - 2, first = 1;
while (size > 0) {
size_t half = (size_t)size >> 1, middle = first + half;
// .. and r... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
subq $0x2, %rax
movq %rax, 0x30(%rsp)
movq $0x1, 0x28(%rsp)
cmpq $0x0, 0x30(%rsp)
jle 0x42afb4
movq 0x30(%rsp), %rax
shrq %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
addq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
... | /anderslanglands[P]pbrt-v4/src/pbrt/util/math.h |
pbrt::ColorEncodingHandle::Get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | const ColorEncodingHandle ColorEncodingHandle::Get(const std::string &name) {
if (name == "linear")
return Linear;
else if (name == "sRGB")
return sRGB;
else {
static std::map<float, ColorEncodingHandle> cache;
std::vector<std::string> params = SplitStringsFromWhitespace(nam... | subq $0x98, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x88(%rsp), %rdi
leaq 0x42915b(%rip), %rsi # 0x85449e
callq 0x335dd0
testb $0x1, %al
jne 0x42b34e
jmp 0x42b364
movq 0x28(%rsp), %rdi
leaq 0x3027e4e(%rip), %rsi # 0x34531a8
callq 0x3fe2b0
jm... | /anderslanglands[P]pbrt-v4/src/pbrt/util/color.cpp |
pbrt::TaggedPointer<pbrt::LinearColorEncoding, pbrt::sRGBColorEncoding, pbrt::GammaColorEncoding>::TaggedPointer<pbrt::LinearColorEncoding>(pbrt::LinearColorEncoding*) | 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::LinearColorEncoding, pbrt::sRGBColorEncoding, pbrt::GammaColorEncoding>::TaggedPointer<pbrt::sRGBColorEncoding>(pbrt::sRGBColorEncoding*) | 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<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, float&, pbrt::ColorEncodingHandle&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, std::__cxx11::basic_string<char, std::char_traits<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... | 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 |
pbrt::RGBColorSpace::Lookup(pbrt::Point2<float>, pbrt::Point2<float>, pbrt::Point2<float>, pbrt::Point2<float>) | const RGBColorSpace *RGBColorSpace::Lookup(Point2f r, Point2f g, Point2f b, Point2f w) {
auto closeEnough = [](const Point2f &a, const Point2f &b) {
return ((a.x == b.x || std::abs((a.x - b.x) / b.x) < 1e-3) &&
(a.y == b.y || std::abs((a.y - b.y) / b.y) < 1e-3));
};
for (const RGBCol... | subq $0x88, %rsp
vmovlpd %xmm0, 0x78(%rsp)
vmovlpd %xmm1, 0x70(%rsp)
vmovlpd %xmm2, 0x68(%rsp)
vmovlpd %xmm3, 0x60(%rsp)
movq 0x3022f52(%rip), %rax # 0x3453238
movq %rax, 0x20(%rsp)
movq 0x3022f56(%rip), %rax # 0x3453248
movq %rax, 0x28(%rsp)
movq 0x3022f42(%rip), %rax # 0x3453240
movq %rax, 0x30(%rsp)
movq 0x302... | /anderslanglands[P]pbrt-v4/src/pbrt/util/colorspace.cpp |
pbrt::RGBColorSpace::Init(pstd::pmr::polymorphic_allocator<std::byte>) | void RGBColorSpace::Init(Allocator alloc) {
// Rec. ITU-R BT.709.3
sRGB = alloc.new_object<RGBColorSpace>(
Point2f(.64, .33), Point2f(.3, .6), Point2f(.15, .06),
GetNamedSpectrum("stdillum-D65"), RGBToSpectrumTable::sRGB, alloc);
// P3-D65 (display)
DCI_P3 = alloc.new_object<RGBColorSpac... | subq $0x188, %rsp # imm = 0x188
movq %rdi, 0x180(%rsp)
leaq 0x178(%rsp), %rdi
vmovss 0x421881(%rip), %xmm0 # 0x851da0
vmovss 0x41f0e9(%rip), %xmm1 # 0x84f610
callq 0x3348d0
leaq 0x170(%rsp), %rdi
vmovss 0x421868(%rip), %xmm0 # 0x851da4
vmovss 0x41f0c0(%rip), %xmm1 # 0x84f604
callq 0x3348d0
leaq 0x168... | /anderslanglands[P]pbrt-v4/src/pbrt/util/colorspace.cpp |
pbrt::XYZ::operator[](int) | PBRT_CPU_GPU
Float &operator[](int c) {
DCHECK(c >= 0 && c < 3);
if (c == 0)
return X;
else if (c == 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 0x432b56
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x432b7d
cmpl $0x1, -0x14(%rsp)
jne 0x432b6d
movq -0x20(%rsp), %rax
addq $0x4, %rax
movq %rax, -0x8(%rsp)
jmp 0x432b7d
jmp 0x432b6f
movq -0x20(... | /anderslanglands[P]pbrt-v4/src/pbrt/util/color.h |
void pbrt::detail::stringPrintfRecursive<char const (&) [11], int&, char const (&) [11], int&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [11], int&, char const (&) [11], 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 |
auto pbrt::detail::DispatchSplit<2>::operator()<pbrt::SpectrumHandle::operator()(float) const::'lambda'(auto), pbrt::TaggedPointer<pbrt::ConstantSpectrum, pbrt::DenselySampledSpectrum, pbrt::PiecewiseLinearSpectrum, pbrt::RGBSpectrum, pbrt::RGBReflectanceSpectrum, pbrt::BlackbodySpectrum>, pbrt::RGBReflectanceSpectrum,... | PBRT_CPU_GPU inline auto operator()(F func, Tp tp, int tag, TypePack<Ts...> types) {
constexpr int mid = n / 2;
if (tag - 1 < mid) // 0-based indexing here to be more traditional
return DispatchSplit<mid>()(
func, tp, tag, typename TakeFirstN<mid, TypePack<Ts...>>::type());... | subq $0x78, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movl %ecx, 0x4c(%rsp)
movl $0x1, 0x48(%rsp)
movl 0x4c(%rsp), %eax
subl $0x1, %eax
cmpl $0x1, %eax
jge 0x434ca9
movq 0x8(%rsp), %rsi
movq 0x68(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x407860
mov... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
pbrt::XYZ pbrt::Mul<pbrt::XYZ, 3, pbrt::XYZ>(pbrt::SquareMatrix<3> const&, pbrt::XYZ const&) | PBRT_CPU_GPU inline Tresult Mul(const SquareMatrix<N> &m, const T &v) {
Tresult result;
for (int i = 0; i < N; ++i) {
result[i] = 0;
for (int j = 0; j < N; ++j)
result[i] += m[i][j] * v[j];
}
return result;
} | subq $0x58, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
leaq 0x4c(%rsp), %rdi
callq 0x4351e0
movl $0x0, 0x34(%rsp)
cmpl $0x3, 0x34(%rsp)
jge 0x4351bb
movl 0x34(%rsp), %esi
leaq 0x4c(%rsp), %rdi
callq 0x432b30
vpxor %xmm0, %xmm0, %xmm0
vmovss %xmm0, (%rax)
movl $0x0, 0x30(%rsp)
cmpl $0x3, 0x30(%rsp)
jge 0x4351a9
mo... | /anderslanglands[P]pbrt-v4/src/pbrt/util/math.h |
void pbrt::detail::stringPrintfRecursive<pbrt::Point2<float> const&, pbrt::Point2<float> const&, pbrt::Point2<float> const&, pbrt::Point2<float> const&, pbrt::DenselySampledSpectrum const&, pbrt::SquareMatrix<3> const&, pbrt::SquareMatrix<3> const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocato... | 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 |
void pbrt::detail::stringPrintfRecursive<pbrt::Point2<float> const&, pbrt::Point2<float> const&, pbrt::Point2<float> const&, pbrt::DenselySampledSpectrum const&, pbrt::SquareMatrix<3> const&, pbrt::SquareMatrix<3> const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char 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 0x278(%rsp), %rax
movq 0x270(%rsp), %rax
movq %rdi, 0x260(%rsp)
movq %rsi, 0x258(%rsp)
movq %rdx, 0x250(%rsp)
movq %rcx, 0x248(%rsp)
movq %r8, 0x240(%rsp)
movq %r9, 0x238(%rsp)
movq 0x260(%rsp), %rdx
leaq 0x218(%rsp), %rdi
leaq 0x258(%rsp), %rsi
callq 0x4ccc90
leaq 0x218(... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<pbrt::Point2<float> const&, pbrt::Point2<float> const&, pbrt::DenselySampledSpectrum const&, pbrt::SquareMatrix<3> const&, pbrt::SquareMatrix<3> const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, pbrt::Point2<float> 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 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::Point2<float> const&, pbrt::DenselySampledSpectrum const&, pbrt::SquareMatrix<3> const&, pbrt::SquareMatrix<3> const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, pbrt::Point2<float> const&, pbrt::DenselySampledSpectrum 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 $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<pbrt::SquareMatrix<3> const&, pbrt::SquareMatrix<3> const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, pbrt::SquareMatrix<3> const&, pbrt::SquareMatrix<3> 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::IPCChannel::IPCChannel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | IPCChannel::IPCChannel(const std::string &hostname) {
if (numActiveChannels++ == 0) {
#ifdef PBRT_IS_WINDOWS
WSADATA wsaData;
int err = WSAStartup(MAKEWORD(2, 2), &wsaData);
if (err != NO_ERROR)
LOG_FATAL("Unable to initialize WinSock: %s", ErrorString(err));
#else
// We ... | subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq 0xe0(%rsp), %rdi
movq %rdi, 0x30(%rsp)
movl $0x0, (%rdi)
addq $0x8, %rdi
movq %rdi, 0x20(%rsp)
callq 0x327750
movq 0x30(%rsp), %rdi
addq $0x28, %rdi
movq %rdi, 0x28(%rsp)
callq 0x327750
movq 0x30(%rsp), %rax
movl $0xffffffff, 0x48(%rax) # imm = 0xFFFFFFF... | /anderslanglands[P]pbrt-v4/src/pbrt/util/display.cpp |
pbrt::IPCChannel::Connect() | void IPCChannel::Connect() {
CHECK_EQ(socketFd, INVALID_SOCKET);
LOG_VERBOSE("Trying to connect to display server");
struct addrinfo hints = {}, *addrinfo;
hints.ai_family = PF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
int err = getaddrinfo(address.c_str(), port.c_str(), &hints, &addrinfo);
... | pushq %rbx
subq $0x100, %rsp # imm = 0x100
movq %rdi, 0xf8(%rsp)
movq 0xf8(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movl 0x48(%rax), %eax
movl %eax, 0xf4(%rsp)
movl $0xffffffff, 0xf0(%rsp) # imm = 0xFFFFFFFF
movl 0xf4(%rsp), %eax
cmpl 0xf0(%rsp), %eax
je 0x43738b
movl $0x2, %edi
leaq 0x41ad10(... | /anderslanglands[P]pbrt-v4/src/pbrt/util/display.cpp |
pbrt::IPCChannel::~IPCChannel() | IPCChannel::~IPCChannel() {
if (Connected())
Disconnect();
if (--numActiveChannels == 0) {
#ifdef PBRT_IS_WINDOWS
WSACleanup();
#endif
}
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x43a860
movb %al, 0xf(%rsp)
jmp 0x4376fd
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x437707
jmp 0x437714
movq (%rsp), %rdi
callq 0x437750
jmp 0x437712
jmp 0x437714
leaq 0x301bbb1(%rip), %rdi # 0x34532cc
callq 0x43a880
cmpl $0x0, %eax
... | /anderslanglands[P]pbrt-v4/src/pbrt/util/display.cpp |
pbrt::IPCChannel::Send(pstd::span<unsigned char const>) | bool IPCChannel::Send(pstd::span<const uint8_t> message) {
if (!Connected()) {
Connect();
if (!Connected())
return false;
}
// Start with the length of the message.
// FIXME: annoying coupling w/sending code's message buffer layout...
int *startPtr = (int *)message.data(... | subq $0x98, %rsp
movq %rsi, 0x80(%rsp)
movq %rdx, 0x88(%rsp)
movq %rdi, 0x78(%rsp)
movq 0x78(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x43a860
testb $0x1, %al
jne 0x437806
movq 0x28(%rsp), %rdi
callq 0x4372f0
movq 0x28(%rsp), %rdi
callq 0x43a860
testb $0x1, %al
jne 0x437804
movb $0x0, 0x97(%rsp)
jmp 0x437946
jmp 0x43780... | /anderslanglands[P]pbrt-v4/src/pbrt/util/display.cpp |
pbrt::DisplayItem::DisplayItem(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, pbrt::Point2<int>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char... | DisplayItem::DisplayItem(
const std::string &baseTitle, Point2i resolution,
std::vector<std::string> channelNames,
std::function<void(Bounds2i b, pstd::span<pstd::span<Float>>)> getTileValues)
: resolution(resolution), getTileValues(getTileValues), channelNames(channelNames) {
#ifdef PBRT_IS_WINDOWS
... | subq $0x108, %rsp # imm = 0x108
movq %rcx, 0x20(%rsp)
movq %r8, 0x38(%rsp)
movq %rdx, 0x100(%rsp)
movq %rdi, 0xf8(%rsp)
movq %rsi, 0xf0(%rsp)
movq %rcx, 0xe8(%rsp)
movq %r8, 0xe0(%rsp)
movq 0xf8(%rsp), %rdi
movq %rdi, 0x30(%rsp)
movb $0x0, (%rdi)
addq $0x8, %rdi
movq %rdi, 0x28(%rsp)
callq 0x327750
movq 0x30... | /anderslanglands[P]pbrt-v4/src/pbrt/util/display.cpp |
pbrt::DisplayItem::Display(pbrt::IPCChannel&) | bool DisplayItem::Display(IPCChannel &ipcChannel) {
if (!openedImage) {
if (!SendOpenImage(ipcChannel))
// maybe next time
return false;
openedImage = true;
}
std::vector<pstd::span<Float>> displayValues(channelBuffers.size());
for (int c = 0; c < channelBuffers.... | subq $0x128, %rsp # imm = 0x128
movq %rdi, 0x118(%rsp)
movq %rsi, 0x110(%rsp)
movq 0x118(%rsp), %rax
movq %rax, 0x50(%rsp)
testb $0x1, (%rax)
jne 0x438164
movq 0x50(%rsp), %rdi
movq 0x110(%rsp), %rsi
callq 0x438610
testb $0x1, %al
jne 0x43815c
movb $0x0, 0x127(%rsp)
jmp 0x4385f2
movq 0x50(%rsp), %rax
movb $0... | /anderslanglands[P]pbrt-v4/src/pbrt/util/display.cpp |
pbrt::InlinedVector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 4, pstd::pmr::polymorphic_allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::reserve(unsigned long) | void reserve(size_t n) {
if (capacity() >= 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... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x43c7c0
cmpq 0x28(%rsp), %rax
jb 0x43c669
jmp 0x43c738
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x3aade0
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rcx
movslq 0x1c(%rsp), %rax
cmpq... | /anderslanglands[P]pbrt-v4/src/pbrt/util/containers.h |
void pbrt::detail::stringPrintfRecursive<char const (&) [5], char const (&) [9], int&, char const (&) [5], int&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [5], char const (&) [9], int&, char const (&) [5], 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], int&, char const (&) [5], int&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [9], int&, char const (&) [5], 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 |
pbrt::IsAbsolutePath(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static bool IsAbsolutePath(const std::string &filename) {
if (filename.empty())
return false;
return filesystem::path(filename).is_absolute();
} | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x327620
testb $0x1, %al
jne 0x445439
jmp 0x445440
movb $0x0, 0x57(%rsp)
jmp 0x445494
movq 0x48(%rsp), %rsi
leaq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x446130
movq 0x8(%rsp), %rdi
callq 0x44a0c0
movb %al, 0x13(%rsp)
jmp 0x445464
movb 0x13(%rsp), ... | /anderslanglands[P]pbrt-v4/src/pbrt/util/file.cpp |
filesystem::path::make_absolute() const | path make_absolute() const {
#if !defined(_WIN32)
char temp[PATH_MAX];
if (realpath(str().c_str(), temp) == NULL)
throw std::runtime_error("Internal error in realpath(): " + std::string(strerror(errno)));
return path(temp);
#else
std::wstring value = wstr(), out(MAX_PATH_WIND... | subq $0x10c8, %rsp # imm = 0x10C8
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x10c0(%rsp)
movq %rsi, 0x10b8(%rsp)
movq 0x10b8(%rsp), %rsi
leaq 0x90(%rsp), %rdi
movl $0x1, %edx
callq 0x4469a0
leaq 0x90(%rsp), %rdi
callq 0x327260
movq %rax, %rdi
leaq 0xb0(%rsp), %rsi
callq 0x327c70
m... | /anderslanglands[P]pbrt-v4/src/ext/filesystem/filesystem/path.h |
void pbrt::detail::stringPrintfRecursive<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, 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&) | 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 (&) [18], char const (&) [13], int&, char const (&) [18], unsigned long&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [18], char const (&) [13], int&, char const (&) [18], unsigned long&) | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x268, %rsp # imm = 0x268
movq 0x270(%rsp), %rax
movq %rdi, 0x260(%rsp)
movq %rsi, 0x258(%rsp)
movq %rdx, 0x250(%rsp)
movq %rcx, 0x248(%rsp)
movq %r8, 0x240(%rsp)
movq %r9, 0x238(%rsp)
movq 0x260(%rsp), %rdx
leaq 0x218(%rsp), %rdi
leaq 0x258(%rsp), %rsi
callq 0x4ccc90
leaq 0x218(%rsp), %rdi
movl $0x2a,... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<char const (&) [13], int&, char const (&) [18], unsigned long&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [13], int&, char const (&) [18], unsigned long&) | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x268, %rsp # imm = 0x268
movq %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<int&, char const (&) [18], unsigned long&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, int&, char const (&) [18], 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 |
void pbrt::detail::stringPrintfRecursive<char (&) [32]>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char (&) [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 |
pbrt::ToString[abi:cxx11](pbrt::PixelFormat) | std::string ToString(PixelFormat format) {
switch (format) {
case PixelFormat::U256:
return "U256";
case PixelFormat::Half:
return "Half";
case PixelFormat::Float:
return "Float";
default:
LOG_FATAL("Unhandled PixelFormat in FormatName()");
return "";
}
} | subq $0x58, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x34(%rsp)
testl %eax, %eax
je 0x44cb35
jmp 0x44cb18
movl 0x34(%rsp), %eax
subl $0x1, %eax
je 0x44cb88
jmp 0x44cb23
movl 0x34(%rsp), %eax
subl $0x2, %eax
je 0x44cbd8
... | /anderslanglands[P]pbrt-v4/src/pbrt/util/image.cpp |
pbrt::Image::GenerateMIPMap(pbrt::Image, pbrt::WrapMode2D, pstd::pmr::polymorphic_allocator<std::byte>) | pstd::vector<Image> Image::GenerateMIPMap(Image image, WrapMode2D wrapMode,
Allocator alloc) {
PixelFormat origFormat = image.format;
int nChannels = image.NChannels();
ColorEncodingHandle origEncoding = image.encoding;
// Set things up so we have a power-of-tw... | subq $0x848, %rsp # imm = 0x848
movq %rsi, 0x118(%rsp)
movq %rdi, %rax
movq 0x118(%rsp), %rdi
movq %rax, 0x108(%rsp)
movq %rax, %rsi
movq %rsi, 0x110(%rsp)
movq %rax, 0x840(%rsp)
movq %rdx, 0x838(%rsp)
movq %rcx, 0x830(%rsp)
movq %rdi, 0x828(%rsp)
movl (%rdi), %eax
movl %eax, 0x824(%rsp)
callq 0x43c130
movq ... | /anderslanglands[P]pbrt-v4/src/pbrt/util/image.cpp |
pbrt::Image::GetChannelDesc(pstd::span<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const>) const | ImageChannelDesc Image::GetChannelDesc(
pstd::span<const std::string> requestedChannels) const {
ImageChannelDesc desc;
desc.offset.resize(requestedChannels.size());
for (size_t i = 0; i < requestedChannels.size(); ++i) {
size_t j;
for (j = 0; j < channelNames.size(); ++j)
if... | subq $0x108, %rsp # imm = 0x108
movq %rdi, 0x60(%rsp)
movq %rdi, %rax
movq %rax, 0x68(%rsp)
movq %rdi, 0x100(%rsp)
movq %rdx, 0xf0(%rsp)
movq %rcx, 0xf8(%rsp)
movq %rsi, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
movq %rax, 0x70(%rsp)
leaq 0xb8(%rsp), %rdi
movq %rdi, 0x78(%rsp)
callq 0x465e60
leaq 0xf0(%rsp), %rdi
cal... | /anderslanglands[P]pbrt-v4/src/pbrt/util/image.cpp |
pbrt::Image::L1Error(pbrt::ImageChannelDesc const&, pbrt::Image const&, pbrt::Image*) const | ImageChannelValues Image::L1Error(const ImageChannelDesc &desc, const Image &ref,
Image *errorImage) const {
std::vector<double> sumError(desc.size(), 0.);
ImageChannelDesc refDesc = ref.GetChannelDesc(ChannelNames(desc));
CHECK((bool)refDesc);
CHECK_EQ(Resolution(), r... | subq $0x408, %rsp # imm = 0x408
movq %rdi, 0x100(%rsp)
movq %rdi, %rax
movq %rax, 0x108(%rsp)
movq %rdi, 0x400(%rsp)
movq %rsi, 0x3f8(%rsp)
movq %rdx, 0x3f0(%rsp)
movq %rcx, 0x3e8(%rsp)
movq %r8, 0x3e0(%rsp)
movq 0x3f8(%rsp), %rax
movq %rax, 0x110(%rsp)
movq 0x3f0(%rsp), %rdi
callq 0x466bd0
movq %rax, 0x118(... | /anderslanglands[P]pbrt-v4/src/pbrt/util/image.cpp |
pbrt::Image::MRSE(pbrt::ImageChannelDesc const&, pbrt::Image const&, pbrt::Image*) const | ImageChannelValues Image::MRSE(const ImageChannelDesc &desc, const Image &ref,
Image *mrseImage) const {
std::vector<double> sumRSE(desc.size(), 0.);
ImageChannelDesc refDesc = ref.GetChannelDesc(ChannelNames(desc));
CHECK((bool)refDesc);
CHECK_EQ(Resolution(), ref.Resolu... | subq $0x428, %rsp # imm = 0x428
movq %rdi, 0x120(%rsp)
movq %rdi, %rax
movq %rax, 0x128(%rsp)
movq %rdi, 0x420(%rsp)
movq %rsi, 0x418(%rsp)
movq %rdx, 0x410(%rsp)
movq %rcx, 0x408(%rsp)
movq %r8, 0x400(%rsp)
movq 0x418(%rsp), %rax
movq %rax, 0x130(%rsp)
movq 0x410(%rsp), %rdi
callq 0x466bd0
movq %rax, 0x138(... | /anderslanglands[P]pbrt-v4/src/pbrt/util/image.cpp |
pbrt::Image::Average(pbrt::ImageChannelDesc const&) const | ImageChannelValues Image::Average(const ImageChannelDesc &desc) const {
std::vector<double> sum(desc.size(), 0.);
for (int y = 0; y < Resolution().y; ++y)
for (int x = 0; x < Resolution().x; ++x) {
ImageChannelValues v = GetChannels({x, y}, desc);
for (int c = 0; c < desc.size()... | subq $0x188, %rsp # imm = 0x188
movq %rdi, 0x98(%rsp)
movq %rdi, %rax
movq %rax, 0xa0(%rsp)
movq %rdi, 0x180(%rsp)
movq %rsi, 0x178(%rsp)
movq %rdx, 0x170(%rsp)
movq 0x178(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0x170(%rsp), %rdi
callq 0x466bd0
movq %rax, 0xb0(%rsp)
movq $0x0, 0x150(%rsp)
leaq 0x14f(%rsp), %r... | /anderslanglands[P]pbrt-v4/src/pbrt/util/image.cpp |
pbrt::Image::LookupNearest(pbrt::Point2<float>, pbrt::ImageChannelDesc const&, pbrt::WrapMode2D) const | ImageChannelValues Image::LookupNearest(Point2f p, const ImageChannelDesc &desc,
WrapMode2D wrapMode) const {
ImageChannelValues cv(desc.offset.size(), Float(0));
for (int i = 0; i < desc.offset.size(); ++i)
cv[i] = LookupNearestChannel(p, desc.offset[i], wrapMode... | subq $0x98, %rsp
movq %rdi, 0x40(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x90(%rsp)
vmovlpd %xmm0, 0x88(%rsp)
movq %rcx, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x38(%rsp)
movb $0x0, 0x6f(%rsp)
movq 0x70(%rsp), %rdi
callq 0x442270
movq 0x40(%rsp), %rdi
movq... | /anderslanglands[P]pbrt-v4/src/pbrt/util/image.cpp |
pbrt::Image::WritePNG(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, pbrt::ImageMetadata const&) const | bool Image::WritePNG(const std::string &name, const ImageMetadata &metadata) const {
unsigned int error = 0;
int nOutOfGamut = 0;
if (format == PixelFormat::U256) {
if (NChannels() == 1)
error = lodepng_encode_file(name.c_str(), p8.data(), resolution.x,
... | subq $0x108, %rsp # imm = 0x108
movq %rdi, 0xf8(%rsp)
movq %rsi, 0xf0(%rsp)
movq %rdx, 0xe8(%rsp)
movq 0xf8(%rsp), %rax
movq %rax, 0x68(%rsp)
movl $0x0, 0xe4(%rsp)
movl $0x0, 0xe0(%rsp)
cmpl $0x0, (%rax)
jne 0x4600ea
movq 0x68(%rsp), %rdi
callq 0x43c130
cmpl $0x1, %eax
jne 0x46005a
movq 0xf0(%rsp), %rdi
call... | /anderslanglands[P]pbrt-v4/src/pbrt/util/image.cpp |
pstd::vector<unsigned char, pstd::pmr::polymorphic_allocator<unsigned char>>::operator=(pstd::vector<unsigned char, pstd::pmr::polymorphic_allocator<unsigned char>>&&) | 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 0x469a1e
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x469b2a
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x469d50
testb $0x1, %al
jne 0x469a33
jmp 0x469a7d
movq 0x10(%rsp), %rdi
... | /anderslanglands[P]pbrt-v4/src/pbrt/util/pstd.h |
void pbrt::detail::stringPrintfRecursive<char const (&) [47]>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [47]) | 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 (&) [10], char const (&) [44], char const (&) [10], unsigned long&, char const (&) [44], int&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [10], char const (&) [44], char const (&) [10], unsigned long&, ... | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x268, %rsp # imm = 0x268
movq 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 (&) [13], char const (&) [17], char const (&) [13], pbrt::Point2<int>&, char const (&) [17], pbrt::Point2<int>&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [13], char const (&) [17], char const (&) [13]... | 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 (&) [28], int&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [28], 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 (&) [17], char const (&) [18], char const (&) [17], unsigned long&, char const (&) [18], unsigned long&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [17], char const (&) [18], char const (&) [17], 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 (&) [29], char const (&) [28], char const (&) [29], int&, char const (&) [28], int&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [29], char const (&) [28], char const (&) [29], int&, char const (&) [28],... | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x268, %rsp # imm = 0x268
movq 0x278(%rsp), %rax
movq 0x270(%rsp), %rax
movq %rdi, 0x260(%rsp)
movq %rsi, 0x258(%rsp)
movq %rdx, 0x250(%rsp)
movq %rcx, 0x248(%rsp)
movq %r8, 0x240(%rsp)
movq %r9, 0x238(%rsp)
movq 0x260(%rsp), %rdx
leaq 0x218(%rsp), %rdi
leaq 0x258(%rsp), %rsi
callq 0x4ccc90
leaq 0x218(... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<pbrt::InlinedVector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 4, pstd::pmr::polymorphic_allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, char const*>(std::__cxx11::basic_string<char, std::cha... | 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 (&) [12], int&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, int&, char const (&) [12], 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 |
pbrt::(anonymous namespace)::TimeNow[abi:cxx11]() | std::string TimeNow() {
std::time_t t = std::time(NULL);
std::tm tm = *std::localtime(&t);
std::stringstream ss;
ss << std::put_time(&tm, "%Y%m%d.%H%M%S");
return ss.str();
} | subq $0x218, %rsp # imm = 0x218
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x210(%rsp)
xorl %eax, %eax
movl %eax, %edi
callq 0x327ef0
movq %rax, 0x208(%rsp)
leaq 0x208(%rsp), %rdi
callq 0x327d60
vmovdqu (%rax), %ymm0
vmovdqu 0x18(%rax), %ymm1
vmovdqu %ymm1, 0x1e8(%rsp)
vmovdqu %ymm0, 0... | /anderslanglands[P]pbrt-v4/src/pbrt/util/log.cpp |
pbrt::LoopSubdivide(pbrt::Transform const*, bool, int, pstd::span<int const>, pstd::span<pbrt::Point3<float> const>, pstd::pmr::polymorphic_allocator<std::byte>) | TriangleMesh *LoopSubdivide(const Transform *renderFromObject, bool reverseOrientation,
int nLevels, pstd::span<const int> vertexIndices,
pstd::span<const Point3f> p, Allocator alloc) {
std::vector<SDVertex *> vertices;
std::vector<SDFace *> faces;
// ... | subq $0x1078, %rsp # imm = 0x1078
movb %sil, %al
leaq 0x1080(%rsp), %rsi
movq %rsi, 0x670(%rsp)
movq %rcx, 0x1068(%rsp)
movq %r8, 0x1070(%rsp)
movq %r9, 0x1060(%rsp)
movq %rdi, 0x1058(%rsp)
andb $0x1, %al
movb %al, 0x1057(%rsp)
movl %edx, 0x1050(%rsp)
leaq 0x1038(%rsp), %rdi
callq 0x48c860
leaq 0x1020(%rsp), ... | /anderslanglands[P]pbrt-v4/src/pbrt/util/loopsubdiv.cpp |
pbrt::SDFace::otherVert(pbrt::SDVertex*, pbrt::SDVertex*) | SDVertex *otherVert(SDVertex *v0, SDVertex *v1) {
for (int i = 0; i < 3; ++i)
if (v[i] != v0 && v[i] != v1)
return v[i];
LOG_FATAL("Basic logic error in SDVertex::otherVert()");
return nullptr;
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x3, 0xc(%rsp)
jge 0x48d614
movq (%rsp), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpq 0x18(%rsp), %rax
je 0x48d605
movq (%rsp), %rax
movslq 0xc(%rsp), %rcx
m... | /anderslanglands[P]pbrt-v4/src/pbrt/util/loopsubdiv.cpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.