name string | code string | asm string | file string |
|---|---|---|---|
pbrt::InlinedVector<pbrt::Point3<float>, 16, pstd::pmr::polymorphic_allocator<pbrt::Point3<float>>>::InlinedVector(unsigned long, pbrt::Point3<float> const&, pstd::pmr::polymorphic_allocator<pbrt::Point3<float>> const&) | InlinedVector(size_t count, const T &value, const Allocator &alloc = {})
: alloc(alloc) {
reserve(count);
for (size_t i = 0; i < count; ++i)
this->alloc.template construct<T>(begin() + i, value);
nStored = count;
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movq $0x0, 0xd0(%rdi)
movq $0x0, 0xd8(%rdi)
movq 0x28(%rsp), %rsi
callq 0x48f460
movq $0x0, 0... | /anderslanglands[P]pbrt-v4/src/pbrt/util/containers.h |
unsigned long pbrt::FindInterval<pbrt::CatmullRomWeights(pstd::span<float const>, float, int*, pstd::span<float>)::$_0>(unsigned long, pbrt::CatmullRomWeights(pstd::span<float const>, float, int*, pstd::span<float>)::$_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 0x498324
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::InvertCatmullRom(pstd::span<float const>, pstd::span<float const>, float) | Float InvertCatmullRom(pstd::span<const Float> x, pstd::span<const Float> values,
Float u) {
// Stop when _u_ is out of bounds
if (!(u > values.front()))
return x.front();
else if (!(u < values.back()))
return x.back();
// Map _u_ to a spline interval by inverting... | subq $0x108, %rsp # imm = 0x108
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xf8(%rsp)
movq %rdx, 0xe0(%rsp)
movq %rcx, 0xe8(%rsp)
vmovss %xmm0, 0xdc(%rsp)
vmovss 0xdc(%rsp), %xmm0
vmovss %xmm0, 0x4c(%rsp)
leaq 0xe0(%rsp), %rdi
callq 0x49c550
vmovaps %xmm0, %xmm1
vmovss 0x4c(%rsp), %xmm0
vucomiss %xmm1, %xmm0
ja 0x4987... | /anderslanglands[P]pbrt-v4/src/pbrt/util/math.cpp |
pbrt::SquareMatrix<4>::operator+(pbrt::SquareMatrix<4> const&) const | operator+(const SquareMatrix &m) const {
SquareMatrix r = *this;
for (int i = 0; i < N; ++i)
for (int j = 0; j < N; ++j)
r.m[i][j] += m.m[i][j];
return r;
} | subq $0x28, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rsi
movl $0x40, %edx
callq 0x327170
movl $0x0, 0x14(%rsp)
cmpl $0x4, 0x14(%rsp)
jge 0x49b9ad
movl $0x0, 0x10(%rsp)
cmpl $0x4, 0x10(%rsp)
jge 0x49b99e
movq (%rsp), %rax
movq 0x18(%rsp), %... | /anderslanglands[P]pbrt-v4/src/pbrt/util/math.h |
pbrt::SquareMatrix<4>::ToString[abi:cxx11]() const | std::string SquareMatrix<N>::ToString() const {
std::string s = "[ [";
for (int i = 0; i < N; ++i) {
for (int j = 0; j < N; ++j) {
s += StringPrintf(" %f", m[i][j]);
if (j < N - 1)
s += ',';
else
s += " ]";
}
if (i < N -... | subq $0x78, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
movb $0x0, 0x67(%rsp)
leaq 0x66(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x3283e0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rdx
leaq 0x3b7aeb(%rip), %rsi # ... | /anderslanglands[P]pbrt-v4/src/pbrt/util/math.cpp |
void pbrt::detail::stringPrintfRecursive<char const (&) [14], char const (&) [13], unsigned long&, char const (&) [14], unsigned long&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [14], char const (&) [13], unsigned long&, char const (&) [14], unsigned lo... | 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 |
float pbrt::MIPMap::EWA<float>(int, pbrt::Point2<float>, pbrt::Vector2<float>, pbrt::Vector2<float>) const | T MIPMap::EWA(int level, Point2f st, Vector2f dst0, Vector2f dst1) const {
if (level >= Levels())
return Texel<T>(Levels() - 1, {0, 0});
// Convert EWA coordinates to appropriate scale for level
Point2i levelRes = LevelResolution(level);
st[0] = st[0] * levelRes[0] - 0.5f;
st[1] = st[1] * l... | subq $0x108, %rsp # imm = 0x108
vmovlpd %xmm0, 0xfc(%rsp)
vmovlpd %xmm1, 0xf4(%rsp)
vmovlpd %xmm2, 0xec(%rsp)
movq %rdi, 0xe0(%rsp)
movl %esi, 0xdc(%rsp)
movq 0xe0(%rsp), %rdi
movq %rdi, 0x58(%rsp)
movl 0xdc(%rsp), %eax
movl %eax, 0x64(%rsp)
callq 0x4bf760
movl %eax, %ecx
movl 0x64(%rsp), %eax
cmpl %ecx, %ea... | /anderslanglands[P]pbrt-v4/src/pbrt/util/mipmap.cpp |
pbrt::ParallelFor(long, long, std::function<void (long, long)>) | void ParallelFor(int64_t start, int64_t end, std::function<void(int64_t, int64_t)> func) {
CHECK(threadPool);
int64_t chunkSize = std::max<int64_t>(1, (end - start) / (8 * RunningThreads()));
if (end - start < chunkSize) {
func(start, end);
return;
}
// Create and enqueue _ParallelJ... | subq $0x108, %rsp # imm = 0x108
movq %rdx, 0x38(%rsp)
movq %rdi, 0x100(%rsp)
movq %rsi, 0xf8(%rsp)
movq %rdx, 0xf0(%rsp)
leaq 0x2f8c3b5(%rip), %rdi # 0x3453560
callq 0x4c87c0
testb $0x1, %al
jne 0x4c71d8
movl $0x2, %edi
leaq 0x38dd70(%rip), %rsi # 0x854f30
movl $0x131, %edx # imm = 0x131
leaq... | /anderslanglands[P]pbrt-v4/src/pbrt/util/parallel.cpp |
void pbrt::detail::stringPrintfRecursive<char const (&) [2], char const (&) [11], int&, char const (&) [2], int&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [2], char const (&) [11], int&, char const (&) [2], int&) | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x268, %rsp # imm = 0x268
movq 0x270(%rsp), %rax
movq %rdi, 0x260(%rsp)
movq %rsi, 0x258(%rsp)
movq %rdx, 0x250(%rsp)
movq %rcx, 0x248(%rsp)
movq %r8, 0x240(%rsp)
movq %r9, 0x238(%rsp)
movq 0x260(%rsp), %rdx
leaq 0x218(%rsp), %rdi
leaq 0x258(%rsp), %rsi
callq 0x4ccc90
leaq 0x218(%rsp), %rdi
movl $0x2a,... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
double_conversion::StringBuilder::Finalize() | char* Finalize() {
DOUBLE_CONVERSION_ASSERT(!is_finalized() && position_ < buffer_.length());
buffer_[position_] = '\0';
// Make sure nobody managed to add a 0-character to the
// buffer while building the string.
DOUBLE_CONVERSION_ASSERT(strlen(buffer_.start()) == static_cast<size_t>(position_));
... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl 0x10(%rdi), %esi
callq 0x4cd0d0
movq 0x8(%rsp), %rdi
movb $0x0, (%rax)
movl $0xffffffff, 0x10(%rdi) # imm = 0xFFFFFFFF
callq 0x4cd0f0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| /anderslanglands[P]pbrt-v4/src/ext/double-conversion/double-conversion/utils.h |
pbrt::Array2D<double>::ToString[abi:cxx11]() const | std::string ToString() const {
std::string s = StringPrintf("[ Array2D extent: %s values: [", extent);
for (int y = extent.pMin.y; y < extent.pMax.y; ++y) {
s += " [ ";
for (int x = extent.pMin.x; x < extent.pMax.x; ++x) {
T value = (*this)(x, y);
... | subq $0x78, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x68(%rsp), %rdx
movq %rdx, 0x20(%rsp)
movb $0x0, 0x67(%rsp)
leaq 0x378f3b(%rip), %rsi # 0x85577c
callq 0x4dc9a0
movq 0x20(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x60(%rsp)
movq 0x20(%rs... | /anderslanglands[P]pbrt-v4/src/pbrt/util/containers.h |
auto pbrt::detail::DispatchSplitCPU<3>::operator()<pbrt::SpectrumHandle::ParameterType[abi:cxx11]() const::$_0, pbrt::TaggedPointer<pbrt::ConstantSpectrum, pbrt::DenselySampledSpectrum, pbrt::PiecewiseLinearSpectrum, pbrt::RGBSpectrum, pbrt::RGBReflectanceSpectrum, pbrt::BlackbodySpectrum>, pbrt::ConstantSpectrum, pbrt... | inline auto operator()(F func, Tp tp, int tag, TypePack<Ts...> types) {
constexpr int mid = n / 2;
if (tag - 1 < mid) // 0-based indexing here to be more traditional
return DispatchSplitCPU<mid>()(
func, tp, tag, typename TakeFirstN<mid, TypePack<Ts...>>::type());
e... | subq $0x68, %rsp
movq %rdx, (%rsp)
movq %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 0x4e36d4
movq (%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x4... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
auto pbrt::detail::DispatchSplitCPU<3>::operator()<pbrt::SpectrumHandle::ParameterType[abi:cxx11]() const::$_0, pbrt::TaggedPointer<pbrt::ConstantSpectrum, pbrt::DenselySampledSpectrum, pbrt::PiecewiseLinearSpectrum, pbrt::RGBSpectrum, pbrt::RGBReflectanceSpectrum, pbrt::BlackbodySpectrum>, pbrt::RGBSpectrum, pbrt::RGB... | 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 0x4e3774
movq (%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x4... | /anderslanglands[P]pbrt-v4/src/pbrt/util/taggedptr.h |
void pbrt::LogFatal<char const (&) [2], char const (&) [19], char const (&) [2], int&, char const (&) [19], unsigned long&>(pbrt::LogLevel, char const*, int, char const*, char const (&) [2], char const (&) [19], char const (&) [2], int&, char const (&) [19], 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 |
pbrt::RGB pbrt::Mul<pbrt::RGB, 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 0x4c1f50
movl $0x0, 0x34(%rsp)
cmpl $0x3, 0x34(%rsp)
jge 0x4e6c0b
movl 0x34(%rsp), %esi
leaq 0x4c(%rsp), %rdi
callq 0x3fec50
vpxor %xmm0, %xmm0, %xmm0
vmovss %xmm0, (%rax)
movl $0x0, 0x30(%rsp)
cmpl $0x3, 0x30(%rsp)
jge 0x4e6bf9
mo... | /anderslanglands[P]pbrt-v4/src/pbrt/util/math.h |
void pbrt::detail::stringPrintfRecursive<char const (&) [14], char const (&) [15], unsigned long&, char const (&) [14], unsigned long&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [14], char const (&) [15], unsigned long&, char const (&) [14], unsigned lo... | 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 (&) [11], char const (&) [15], char const (&) [11], float&, char const (&) [15], float&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [11], char const (&) [15], char const (&) [11], float&, char const (&)... | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x268, %rsp # imm = 0x268
movq 0x278(%rsp), %rax
movq 0x270(%rsp), %rax
movq %rdi, 0x260(%rsp)
movq %rsi, 0x258(%rsp)
movq %rdx, 0x250(%rsp)
movq %rcx, 0x248(%rsp)
movq %r8, 0x240(%rsp)
movq %r9, 0x238(%rsp)
movq 0x260(%rsp), %rdx
leaq 0x218(%rsp), %rdi
leaq 0x258(%rsp), %rsi
callq 0x4ccc90
leaq 0x218(... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
void pbrt::detail::stringPrintfRecursive<char const (&) [2], char const (&) [13], unsigned long&, char const (&) [2], int&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, char const*, char const (&) [2], char const (&) [13], unsigned long&, char const (&) [2], int&) | inline void stringPrintfRecursive(std::string *s, const char *fmt, T &&v,
Args &&... args) {
std::string nextFmt = copyToFormatString(&fmt, s);
bool precisionViaArg = nextFmt.find('*') != std::string::npos;
bool isSFmt = nextFmt.find('s') != std::string::npos;
bool isD... | subq $0x268, %rsp # imm = 0x268
movq 0x270(%rsp), %rax
movq %rdi, 0x260(%rsp)
movq %rsi, 0x258(%rsp)
movq %rdx, 0x250(%rsp)
movq %rcx, 0x248(%rsp)
movq %r8, 0x240(%rsp)
movq %r9, 0x238(%rsp)
movq 0x260(%rsp), %rdx
leaq 0x218(%rsp), %rdi
leaq 0x258(%rsp), %rsi
callq 0x4ccc90
leaq 0x218(%rsp), %rdi
movl $0x2a,... | /anderslanglands[P]pbrt-v4/src/pbrt/util/print.h |
stbi_is_16_bit | STBIDEF int stbi_is_16_bit(char const *filename)
{
FILE *f = stbi__fopen(filename, "rb");
int result;
if (!f) return stbi__err("can't fopen", "Unable to open file");
result = stbi_is_16_bit_from_file(f);
fclose(f);
return result;
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x34ccf2(%rip), %rsi # 0x853157
callq 0x504d40
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x506489
leaq 0x35a2e2(%rip), %rdi # 0x860760
callq 0x504d70
movl %eax, 0x24(%rsp)
jmp 0x5064a9
movq 0x10(%rsp), %rdi
callq 0x5064c0
movl %eax, 0xc(%rsp)... | /anderslanglands[P]pbrt-v4/src/ext/stb/stb_image.h |
stbi__convert_16_to_8(unsigned short*, int, int, int) | static stbi_uc *stbi__convert_16_to_8(stbi__uint16 *orig, int w, int h, int channels)
{
int i;
int img_len = w * h * channels;
stbi_uc *reduced;
reduced = (stbi_uc *) stbi__malloc(img_len);
if (reduced == NULL) return stbi__errpuc("outofmem", "Out of memory");
for (i = 0; i < img_len; ++i)
red... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movl 0x24(%rsp), %eax
imull 0x20(%rsp), %eax
imull 0x1c(%rsp), %eax
movl %eax, 0x14(%rsp)
movslq 0x14(%rsp), %rdi
callq 0x50a4d0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x506a9c
leaq 0x359e7c(%rip), %rdi # ... | /anderslanglands[P]pbrt-v4/src/ext/stb/stb_image.h |
stbi__resample_row_hv_2(unsigned char*, unsigned char*, unsigned char*, int, int) | static stbi_uc *stbi__resample_row_hv_2(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
{
// need to generate 2x2 samples for every one in input
int i,t0,t1;
if (w == 1) {
out[0] = out[1] = stbi__div4(3*in_near[0] + in_far[0] + 2);
return out;
}
t1 = 3*in_near[0] + in_far[0];... | movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movl %ecx, -0x24(%rsp)
movl %r8d, -0x28(%rsp)
cmpl $0x1, -0x24(%rsp)
jne 0x50b11a
movq -0x18(%rsp), %rax
movzbl (%rax), %eax
imull $0x3, %eax, %eax
movq -0x20(%rsp), %rcx
movzbl (%rcx), %ecx
addl %ecx, %eax
addl $0x2, %eax
sarl $0x2, %eax
movb %al, %c... | /anderslanglands[P]pbrt-v4/src/ext/stb/stb_image.h |
stbi__process_frame_header(stbi__jpeg*, int) | static int stbi__process_frame_header(stbi__jpeg *z, int scan)
{
stbi__context *s = z->s;
int Lf,p,i,q, h_max=1,v_max=1,c;
Lf = stbi__get16be(s); if (Lf < 11) return stbi__err("bad SOF len","Corrupt JPEG"); // JPEG
p = stbi__get8(s); if (p != 8) return stbi__err("only 8-bit","JPEG format... | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movl %esi, 0x44(%rsp)
movq 0x48(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x38(%rsp)
movl $0x1, 0x24(%rsp)
movl $0x1, 0x20(%rsp)
movq 0x38(%rsp), %rdi
callq 0x512a60
movl %eax, 0x34(%rsp)
cmpl $0xb, 0x34(%rsp)
jge 0x511f84
leaq 0x34e934(%rip), %rdi # 0x8608aa
callq 0x504d70
movl... | /anderslanglands[P]pbrt-v4/src/ext/stb/stb_image.h |
stbi__refill_buffer(stbi__context*) | static void stbi__refill_buffer(stbi__context *s)
{
int n = (s->io.read)(s->io_user_data,(char*)s->buffer_start,s->buflen);
s->callback_already_read += (int) (s->img_buffer - s->img_buffer_original);
if (n == 0) {
// at end of file, treat same as if from memory, but need to handle case
// where s->... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x28(%rcx), %rdi
movq 0x10(%rsp), %rsi
addq $0x38, %rsi
movq 0x10(%rsp), %rcx
movl 0x34(%rcx), %edx
callq *%rax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq 0xc0(%rax), %rax
movq 0x10(%rsp), %rcx
movq 0xd0(%... | /anderslanglands[P]pbrt-v4/src/ext/stb/stb_image.h |
stbi__free_jpeg_components(stbi__jpeg*, int, int) | static int stbi__free_jpeg_components(stbi__jpeg *z, int ncomp, int why)
{
int i;
for (i=0; i < ncomp; ++i) {
if (z->img_comp[i].raw_data) {
STBI_FREE(z->img_comp[i].raw_data);
z->img_comp[i].raw_data = NULL;
z->img_comp[i].data = NULL;
}
if (z->img_comp[i].raw_coeff) ... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x5131ce
movq 0x10(%rsp), %rax
addq $0x46a0, %rax # imm = 0x46A0
movslq 0x4(%rsp), %rcx
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x38(%rax)
je 0x5130e3
... | /anderslanglands[P]pbrt-v4/src/ext/stb/stb_image.h |
stbi__resample_row_generic(unsigned char*, unsigned char*, unsigned char*, int, int) | static stbi_uc *stbi__resample_row_generic(stbi_uc *out, stbi_uc *in_near, stbi_uc *in_far, int w, int hs)
{
// resample with nearest-neighbor
int i,j;
STBI_NOTUSED(in_far);
for (i=0; i < w; ++i)
for (j=0; j < hs; ++j)
out[i*hs+j] = in_near[i];
return out;
} | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movl %ecx, -0x1c(%rsp)
movl %r8d, -0x20(%rsp)
movl $0x0, -0x24(%rsp)
movl -0x24(%rsp), %eax
cmpl -0x1c(%rsp), %eax
jge 0x51484d
movl $0x0, -0x28(%rsp)
movl -0x28(%rsp), %eax
cmpl -0x20(%rsp), %eax
jge 0x51483e
movq -0x10(%rsp), %rax
movslq -0x24(%rsp),... | /anderslanglands[P]pbrt-v4/src/ext/stb/stb_image.h |
stbi__extend_receive(stbi__jpeg*, int) | stbi_inline static int stbi__extend_receive(stbi__jpeg *j, int n)
{
unsigned int k;
int sgn;
if (j->code_bits < n) stbi__grow_buffer_unsafe(j);
sgn = (stbi__int32)j->code_buffer >> 31; // sign bit is always in MSB
k = stbi_lrot(j->code_buffer, n);
if (n < 0 || n >= (int) (sizeof(stbi__bmask)/sizeof(*... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movl 0x4824(%rax), %eax
cmpl 0x14(%rsp), %eax
jge 0x516938
movq 0x18(%rsp), %rdi
callq 0x515e90
movq 0x18(%rsp), %rax
movl 0x4820(%rax), %eax
sarl $0x1f, %eax
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rax
movl 0x4820(%rax), %eax
movl 0x14(%... | /anderslanglands[P]pbrt-v4/src/ext/stb/stb_image.h |
stbi__high_bit(unsigned int) | static int stbi__high_bit(unsigned int z)
{
int n=0;
if (z == 0) return -1;
if (z >= 0x10000) { n += 16; z >>= 16; }
if (z >= 0x00100) { n += 8; z >>= 8; }
if (z >= 0x00010) { n += 4; z >>= 4; }
if (z >= 0x00004) { n += 2; z >>= 2; }
if (z >= 0x00002) { n += 1;/* >>= 1;*/ }
return n;
} | movl %edi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
cmpl $0x0, -0x8(%rsp)
jne 0x517200
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x517294
cmpl $0x10000, -0x8(%rsp) # imm = 0x10000
jb 0x517220
movl -0xc(%rsp), %eax
addl $0x10, %eax
movl %eax, -0xc(%rsp)
movl -0x8(%rsp), %eax
shrl $0x10, %eax
movl %eax, -0x8(%rsp)
c... | /anderslanglands[P]pbrt-v4/src/ext/stb/stb_image.h |
stbi__gif_parse_colortable(stbi__context*, unsigned char (*) [4], int, int) | static void stbi__gif_parse_colortable(stbi__context *s, stbi_uc pal[256][4], int num_entries, int transp)
{
int i;
for (i=0; i < num_entries; ++i) {
pal[i][2] = stbi__get8(s);
pal[i][1] = stbi__get8(s);
pal[i][0] = stbi__get8(s);
pal[i][3] = transp == i ? 0 : 255;
}
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl %ecx, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x51863d
movq 0x20(%rsp), %rdi
callq 0x5128e0
movb %al, %dl
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
movb %dl, 0x2(%rax,%rcx,4)
movq 0x20(%rsp)... | /anderslanglands[P]pbrt-v4/src/ext/stb/stb_image.h |
testing::AssertionResult::AssertionResult(testing::AssertionResult const&) | AssertionResult::AssertionResult(const AssertionResult& other)
: success_(other.success_),
message_(other.message_.get() != NULL ?
new ::std::string(*other.message_) :
static_cast< ::std::string*>(NULL)) {
} | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq 0x48(%rsp), %rcx
movb (%rcx), %cl
andb $0x1, %cl
movb %cl, (%rax)
addq $0x8, %rax
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rdi
addq $0x8, %rdi
callq 0x4d7ab0
movb $0x0, 0x3f(%rsp)
cmpq $0x0, %rax
je 0x544bcf
movl $0x20, %edi
callq 0x... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest-all.cc |
testing::Test::HasSameFixtureClass() | bool Test::HasSameFixtureClass() {
internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
const TestCase* const test_case = impl->current_test_case();
// Info about the first test in the current test case.
const TestInfo* const first_test_info = test_case->test_info_list()[0];
const internal::Type... | subq $0x1b8, %rsp # imm = 0x1B8
callq 0x55dec0
movq %rax, 0x1a8(%rsp)
movq 0x1a8(%rsp), %rdi
callq 0x5600c0
movq %rax, 0x1a0(%rsp)
movq 0x1a0(%rsp), %rdi
callq 0x5600e0
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5600f0
movq (%rax), %rax
movq %rax, 0x198(%rsp)
movq 0x198(%rsp), %rax
movq 0x50(%ra... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest-all.cc |
testing::Test::Run() | void Test::Run() {
if (!HasSameFixtureClass()) return;
internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
impl->os_stack_trace_getter()->UponLeavingGTest();
internal::HandleExceptionsInMethodIfSupported(this, &Test::SetUp, "SetUp()");
// We will run the test only if SetUp() was successful.
i... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
callq 0x549020
testb $0x1, %al
jne 0x5498b0
jmp 0x549989
callq 0x55dec0
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x549990
movq %rax, %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movq (%rsp), %rdi
movq $0x0, 0x30(%rsp)
mo... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest-all.cc |
testing::TestCase::TestCase(char const*, char const*, void (*)(), void (*)()) | TestCase::TestCase(const char* a_name, const char* a_type_param,
Test::SetUpTestCaseFunc set_up_tc,
Test::TearDownTestCaseFunc tear_down_tc)
: name_(a_name),
type_param_(a_type_param ? new std::string(a_type_param) : NULL),
set_up_tc_(set_up_tc),
tear_down_tc_... | subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movq %r8, 0x80(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x2ec2d95(%rip), %rcx # 0x340d438
movq %rcx, (%rax)
addq $0x8, %rax
movq %rax, 0x40(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x7f... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest-all.cc |
testing::internal::ShouldUseColor(bool) | bool ShouldUseColor(bool stdout_is_tty) {
const char* const gtest_color = GTEST_FLAG(color).c_str();
if (String::CaseInsensitiveCStringEquals(gtest_color, "auto")) {
#if GTEST_OS_WINDOWS
// On Windows the TERM variable is usually not set, but the
// console there does support colors.
return stdout_is_t... | subq $0x28, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0x26(%rsp)
leaq 0x2f08a44(%rip), %rdi # 0x3453828
callq 0x327260
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x3175d0(%rip), %rsi # 0x8623ca
callq 0x546360
testb $0x1, %al
jne 0x54ae08
jmp 0x54af15
leaq 0x317cdc(%rip), %rdi # 0x862aeb
callq 0x561360
... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest-all.cc |
testing::internal::Int32FromEnvOrDie(char const*, int) | Int32 Int32FromEnvOrDie(const char* var, Int32 default_val) {
const char* str_val = posix::GetEnv(var);
if (str_val == NULL) {
return default_val;
}
Int32 result;
if (!ParseInt32(Message() << "The value of environment variable " << var,
str_val, &result)) {
exit(EXIT_FAILURE);
}
... | subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movl %esi, 0x54(%rsp)
movq 0x58(%rsp), %rdi
callq 0x561360
movq %rax, 0x48(%rsp)
cmpq $0x0, 0x48(%rsp)
jne 0x54bb51
movl 0x54(%rsp), %eax
movl %eax, 0x64(%rsp)
jmp 0x54bbf2
leaq 0x38(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x5445c0
movq 0x18(%rsp), %rdi
leaq 0x3176be(%rip), %rsi ... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest-all.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestCaseStart(testing::TestCase const&) | void PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase& test_case) {
const std::string counts =
FormatCountableNoun(test_case.test_to_run_count(), "test", "tests");
ColoredPrintf(COLOR_GREEN, "[----------] ");
printf("%s from %s", counts.c_str(), test_case.name());
if (test_case.type_param() == ... | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x58(%rsp), %rdi
callq 0x544500
movl %eax, %esi
leaq 0x317789(%rip), %rdx # 0x8634ea
leaq 0x3033a8(%rip), %rcx # 0x84f110
leaq 0x38(%rsp), %rdi
callq 0x54be70
leaq 0x316e94(%rip), %rsi # 0x862c0d
xorl %eax, %eax
movl $0x2, %edi
callq 0x54afa0
jm... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest-all.cc |
testing::internal::PrettyUnitTestResultPrinter::OnTestPartResult(testing::TestPartResult const&) | void PrettyUnitTestResultPrinter::OnTestPartResult(
const TestPartResult& result) {
// If the test part succeeded, we don't need to do anything.
if (result.type() == TestPartResult::kSuccess)
return;
// Print failure message from the assertion (e.g. expected this and got that).
PrintTestPartResult(resu... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x55e0b0
cmpl $0x0, %eax
jne 0x54bfff
jmp 0x54c018
movq 0x8(%rsp), %rdi
callq 0x54c020
movq 0x2ec4ed0(%rip), %rax # 0x3410ee0
movq (%rax), %rdi
callq 0x327aa0
addq $0x18, %rsp
retq
nopl (%rax)
| /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest-all.cc |
testing::internal::XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(char const*) | XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(const char* output_file)
: output_file_(output_file) {
if (output_file_.c_str() == NULL || output_file_.empty()) {
fprintf(stderr, "XML output file may not be null\n");
fflush(stderr);
exit(EXIT_FAILURE);
}
} | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x561850
movq 0x10(%rsp), %rax
leaq 0x2ec02b7(%rip), %rcx # 0x340d4e0
movq %rcx, (%rax)
addq $0x8, %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x47(%rsp), %rdi
movq %rdi, 0x28... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest-all.cc |
testing::internal::ParseInt32(testing::Message const&, char const*, int*) | bool ParseInt32(const Message& src_text, const char* str, Int32* value) {
// Parses the environment variable as a decimal integer.
char* end = NULL;
const long long_value = strtol(str, &end, 10); // NOLINT
// Has strtol() consumed all characters in the string?
if (*end != '\0') {
// No - an invalid char... | subq $0xf8, %rsp
movq %rdi, 0xe8(%rsp)
movq %rsi, 0xe0(%rsp)
movq %rdx, 0xd8(%rsp)
movq $0x0, 0xd0(%rsp)
movq 0xe0(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
movl $0xa, %edx
callq 0x3289a8
movq %rax, 0xc8(%rsp)
movq 0xd0(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x553cd8
leaq 0xc0(%rsp), %rdi
movq %rdi, 0x50(%rsp)
call... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest-all.cc |
testing::internal::DeathTestThreadWarning[abi:cxx11](unsigned long) | static std::string DeathTestThreadWarning(size_t thread_count) {
Message msg;
msg << "Death tests use fork(), which is unsafe particularly"
<< " in a threaded context. For this test, " << GTEST_NAME_ << " ";
if (thread_count == 0)
msg << "couldn't detect the number of threads.";
else
msg << "detec... | subq $0x68, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
leaq 0x50(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x5445c0
movq 0x30(%rsp), %rdi
leaq 0x30cafe(%rip), %rsi # 0x863d34
callq 0x569480
movq %rax, 0x38(%rsp)
jmp 0x557242
movq 0x38(%rsp), %rdi
leaq 0... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest-all.cc |
testing::internal::FilePath::DirectoryExists() const | bool FilePath::DirectoryExists() const {
bool result = false;
#if GTEST_OS_WINDOWS
// Don't strip off trailing separator if path is a root directory on
// Windows (like "C:\\").
const FilePath& path(IsRootDirectory() ? *this :
RemoveTrailingPathSeparator());
#else
co... | subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq 0xb0(%rsp), %rax
movb $0x0, 0xaf(%rsp)
movq %rax, 0xa0(%rsp)
movq 0xa0(%rsp), %rdi
callq 0x562500
movq %rax, %rdi
leaq 0x10(%rsp), %rsi
callq 0x565150
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0xf(%rsp)
jne 0x55aa3c
leaq 0x10(%rsp), %rdi
callq 0x565180
movb %a... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest-all.cc |
testing::internal::FilePath::CreateFolder() const | bool FilePath::CreateFolder() const {
#if GTEST_OS_WINDOWS_MOBILE
FilePath removed_sep(this->RemoveTrailingPathSeparator());
LPCWSTR unicode = String::AnsiToUtf16(removed_sep.c_str());
int result = CreateDirectory(unicode, NULL) ? 0 : -1;
delete [] unicode;
#elif GTEST_OS_WINDOWS
int result = _mkdir(pathname_... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x327260
movq %rax, %rdi
movl $0x1ff, %esi # imm = 0x1FF
callq 0x3275f0
movl %eax, 0x14(%rsp)
cmpl $-0x1, 0x14(%rsp)
jne 0x55ab12
movq 0x8(%rsp), %rdi
callq 0x55a9e0
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x55ab17
movb $... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest-all.cc |
testing::internal::RE::~RE() | RE::~RE() {
if (is_valid_) {
// regfree'ing an invalid regex might crash because the content
// of the regex is undefined. Since the regex's are essentially
// the same, one cannot be valid (or invalid) without the other
// being so too.
regfree(&partial_regex_);
regfree(&full_regex_);
}
f... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x8(%rax)
je 0x55acab
movq 0x8(%rsp), %rdi
addq $0x50, %rdi
callq 0x327960
jmp 0x55ac99
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
callq 0x327960
jmp 0x55aca9
jmp 0x55acab
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x327430
addq ... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest-all.cc |
testing::internal::GTestLog::GTestLog(testing::internal::GTestLogSeverity, char const*, int) | GTestLog::GTestLog(GTestLogSeverity severity, const char* file, int line)
: severity_(severity) {
const char* const marker =
severity == GTEST_INFO ? "[ INFO ]" :
severity == GTEST_WARNING ? "[WARNING]" :
severity == GTEST_ERROR ? "[ ERROR ]" : "[ FATAL ]";
GetStream() << ::std::endl << ... | subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movl %esi, 0x8c(%rsp)
movq %rdx, 0x80(%rsp)
movl %ecx, 0x7c(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x38(%rsp)
movl 0x8c(%rsp), %ecx
movl %ecx, (%rax)
cmpl $0x0, 0x8c(%rsp)
jne 0x55b070
leaq 0x308606(%rip), %rax # 0x86366f
movq %rax, 0x30(%rsp)
jmp 0x55b0c2
cmpl $0x1, 0x8c(%rsp)... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest-all.cc |
testing::internal::CaptureStream(int, char const*, testing::internal::CapturedStream**) | void CaptureStream(int fd, const char* stream_name, CapturedStream** stream) {
if (*stream != NULL) {
GTEST_LOG_(FATAL) << "Only one " << stream_name
<< " capturer can exist at a time.";
}
*stream = new CapturedStream(fd);
} | subq $0x58, %rsp
movl %edi, 0x54(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x40(%rsp), %rax
cmpq $0x0, (%rax)
je 0x55b459
leaq 0x30705a(%rip), %rdx # 0x862422
leaq 0x3c(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0x3, %esi
movl $0x228f, %ecx # imm = 0x228F
callq 0x55b020
movq 0x18(%rsp), %rdi
call... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest-all.cc |
void testing::internal::UniversalPrintCharArray<wchar_t>(wchar_t const*, unsigned long, std::ostream*) | static void UniversalPrintCharArray(
const CharType* begin, size_t len, ostream* os) {
// The code
// const char kFoo[] = "foo";
// generates an array of 4, not 3, elements, with the last one being '\0'.
//
// Therefore when printing a char array, we don't print the last element if
// it's '\0', such ... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, 0x8(%rsp)
jbe 0x55ba67
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
subq $0x1, %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x55ba67
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
subq $0x1, %rsi
movq (%rsp), %rdx
callq 0x55bc90
jmp 0x55ba8a
movq 0... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest-all.cc |
testing::internal::TypedTestCasePState::VerifyRegisteredTestNames(char const*, int, char const*) | const char* TypedTestCasePState::VerifyRegisteredTestNames(
const char* file, int line, const char* registered_tests) {
typedef ::std::set<const char*>::const_iterator DefinedTestIter;
registered_ = true;
// Skip initial whitespace in registered_tests since some
// preprocessors prefix stringizied literals... | subq $0x1d8, %rsp # imm = 0x1D8
movq %rdi, 0x1d0(%rsp)
movq %rsi, 0x1c8(%rsp)
movl %edx, 0x1c4(%rsp)
movq %rcx, 0x1b8(%rsp)
movq 0x1d0(%rsp), %rax
movq %rax, 0x98(%rsp)
movb $0x1, (%rax)
movq 0x1b8(%rsp), %rdi
callq 0x55c7b0
movq %rax, 0x1b8(%rsp)
leaq 0x1b0(%rsp), %rdi
callq 0x5445c0
leaq 0x180(%rsp), %rdi
... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest-all.cc |
testing::internal::ExecDeathTestChildMain(void*) | static int ExecDeathTestChildMain(void* child_arg) {
ExecDeathTestArgs* const args = static_cast<ExecDeathTestArgs*>(child_arg);
GTEST_DEATH_TEST_CHECK_SYSCALL_(close(args->close_fd));
// We need to execute the test program in the same environment where
// it was originally invoked. Therefore we change to the... | subq $0x308, %rsp # imm = 0x308
movq %rdi, 0x2f8(%rsp)
movq 0x2f8(%rsp), %rax
movq %rax, 0x2f0(%rsp)
jmp 0x55c851
movq 0x2f0(%rsp), %rax
movl 0x8(%rax), %edi
callq 0x327510
movl %eax, 0x2ec(%rsp)
xorl %eax, %eax
cmpl $-0x1, 0x2ec(%rsp)
movb %al, 0x2f(%rsp)
jne 0x55c887
callq 0x328500
cmpl $0x4, (%rax)
sete %... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest-all.cc |
testing::(anonymous namespace)::PrintByteSegmentInObjectTo(unsigned char const*, unsigned long, unsigned long, std::ostream*) | void PrintByteSegmentInObjectTo(const unsigned char* obj_bytes, size_t start,
size_t count, ostream* os) {
char text[5] = "";
for (size_t i = 0; i != count; i++) {
const size_t j = start + i;
if (i != 0) {
// Organizes the bytes into groups of 2 for easy parsing by
... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
leaq 0x13(%rsp), %rdi
xorl %esi, %esi
movl $0x5, %edx
callq 0x3276a0
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x20(%rsp), %rax
je 0x55d10f
movq 0x28(%rsp), %rax
addq 0x8(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest-all.cc |
testing::internal::HasGoogleTestFlagPrefix(char const*) | static bool HasGoogleTestFlagPrefix(const char* str) {
return (SkipPrefix("--", &str) ||
SkipPrefix("-", &str) ||
SkipPrefix("/", &str)) &&
!SkipPrefix(GTEST_FLAG_PREFIX_ "internal_", &str) &&
(SkipPrefix(GTEST_FLAG_PREFIX_, &str) ||
SkipPrefix(GTEST_FLAG_PREFIX_DASH_, ... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
leaq 0x305f00(%rip), %rdi # 0x863270
leaq 0x10(%rsp), %rsi
callq 0x554050
testb $0x1, %al
jne 0x55d3b3
leaq 0x305eec(%rip), %rdi # 0x863271
leaq 0x10(%rsp), %rsi
callq 0x554050
testb $0x1, %al
jne 0x55d3b3
leaq 0x305b57(%rip), %rdi # 0x862ef1
leaq 0x10(%rsp), %rsi
callq 0... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest-all.cc |
testing::internal::CharFormat testing::internal::PrintAsCharLiteralTo<unsigned char, unsigned char>(unsigned char, std::ostream*) | static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) {
switch (static_cast<wchar_t>(c)) {
case L'\0':
*os << "\\0";
break;
case L'\'':
*os << "\\'";
break;
case L'\\':
*os << "\\\\";
break;
case L'\a':
*os << "\\a";
break;
case L'\b':
*o... | subq $0x78, %rsp
movb %dil, %al
movb %al, 0x73(%rsp)
movq %rsi, 0x68(%rsp)
movzbl 0x73(%rsp), %eax
movq %rax, 0x10(%rsp)
subq $0x5c, %rax
ja 0x55d6e5
movq 0x10(%rsp), %rax
leaq 0x303a48(%rip), %rcx # 0x861048
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x68(%rsp), %rdi
leaq 0x30507f(%rip), %rsi # 0... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest-all.cc |
testing::Message& testing::Message::operator<<<char [11]>(char const (&) [11]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x4db250
movq %rax, %rdi
addq $0x10, %rdi
movq 0x8(%rsp), %rsi
callq 0x327c20
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest.h |
testing::Message& testing::Message::operator<<<char [2]>(char const (&) [2]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x4db250
movq %rax, %rdi
addq $0x10, %rdi
movq 0x8(%rsp), %rsi
callq 0x327c20
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest.h |
testing::Message& testing::Message::operator<<<char [10]>(char const (&) [10]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x4db250
movq %rax, %rdi
addq $0x10, %rdi
movq 0x8(%rsp), %rsi
callq 0x327c20
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest.h |
testing::AssertionResult testing::internal::FloatingPointLE<float>(char const*, char const*, float, float) | AssertionResult FloatingPointLE(const char* expr1,
const char* expr2,
RawType val1,
RawType val2) {
// Returns success if val1 is less than val2,
if (val1 < val2) {
return AssertionSuccess();
}
// or if val1 is ... | subq $0x428, %rsp # imm = 0x428
movq %rdi, 0x70(%rsp)
movq %rdi, %rax
movq %rax, 0x78(%rsp)
movq %rdi, 0x420(%rsp)
movq %rsi, 0x418(%rsp)
movq %rdx, 0x410(%rsp)
vmovss %xmm0, 0x40c(%rsp)
vmovss %xmm1, 0x408(%rsp)
vmovss 0x40c(%rsp), %xmm1
vmovss 0x408(%rsp), %xmm0
vucomiss %xmm1, %xmm0
jbe 0x55ea25
movq 0x70... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest-all.cc |
testing::internal::CreateCodePointFromUtf16SurrogatePair(wchar_t, wchar_t) | inline UInt32 CreateCodePointFromUtf16SurrogatePair(wchar_t first,
wchar_t second) {
const UInt32 mask = (1 << 10) - 1;
return (sizeof(wchar_t) == 2) ?
(((first & mask) << 10) | (second & mask)) + 0x10000 :
// This function should not be called when th... | movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movl $0x3ff, -0xc(%rsp) # imm = 0x3FF
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
nop
| /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest-all.cc |
testing::internal::Mutex::Mutex() | Mutex() {
GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL));
has_owner_ = false;
} | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x20(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0x327820
movl %eax, 0x3c(%rsp)
cmpl $0x0, 0x3c(%rsp)
je 0x55f5c9
leaq 0x304304(%rip), %rdx # 0x863846
leaq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0x3, %esi
movl $0x9cc, %ecx # imm... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest.h |
testing::internal::GTestFlagSaver::GTestFlagSaver() | GTestFlagSaver() {
also_run_disabled_tests_ = GTEST_FLAG(also_run_disabled_tests);
break_on_failure_ = GTEST_FLAG(break_on_failure);
catch_exceptions_ = GTEST_FLAG(catch_exceptions);
color_ = GTEST_FLAG(color);
death_test_style_ = GTEST_FLAG(death_test_style);
death_test_use_fork_ = GTEST_FLAG(d... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x30(%rsp)
addq $0x8, %rdi
movq %rdi, 0x38(%rsp)
callq 0x327750
movq 0x30(%rsp), %rdi
addq $0x28, %rdi
movq %rdi, 0x8(%rsp)
callq 0x327750
movq 0x30(%rsp), %rdi
addq $0x50, %rdi
movq %rdi, 0x10(%rsp)
callq 0x327750
movq 0x30(%rsp), %rdi
addq $0x70,... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest-all.cc |
testing::internal::GTestFlagSaver::~GTestFlagSaver() | ~GTestFlagSaver() {
GTEST_FLAG(also_run_disabled_tests) = also_run_disabled_tests_;
GTEST_FLAG(break_on_failure) = break_on_failure_;
GTEST_FLAG(catch_exceptions) = catch_exceptions_;
GTEST_FLAG(color) = color_;
GTEST_FLAG(death_test_style) = death_test_style_;
GTEST_FLAG(death_test_use_fork) = ... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rsi
movq %rsi, 0x8(%rsp)
movb (%rsi), %al
andb $0x1, %al
movb %al, 0x2ef38d5(%rip) # 0x3453822
movb 0x1(%rsi), %al
andb $0x1, %al
movb %al, 0x2ef38cb(%rip) # 0x3453823
movb 0x2(%rsi), %al
andb $0x1, %al
movb %al, 0x2ef38c1(%rip) # 0x3453824
addq $0x8, %r... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest-all.cc |
testing::Message& testing::Message::operator<<<char [59]>(char const (&) [59]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x4db250
movq %rax, %rdi
addq $0x10, %rdi
movq 0x8(%rsp), %rsi
callq 0x327c20
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest.h |
testing::Message& testing::Message::operator<<<char [30]>(char const (&) [30]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x4db250
movq %rax, %rdi
addq $0x10, %rdi
movq 0x8(%rsp), %rsi
callq 0x327c20
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest.h |
testing::Message& testing::Message::operator<<<char [39]>(char const (&) [39]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x4db250
movq %rax, %rdi
addq $0x10, %rdi
movq 0x8(%rsp), %rsi
callq 0x327c20
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest.h |
testing::Message& testing::Message::operator<<<char [62]>(char const (&) [62]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x4db250
movq %rax, %rdi
addq $0x10, %rdi
movq 0x8(%rsp), %rsi
callq 0x327c20
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest.h |
testing::internal::UnitTestImpl::AddTestInfo(void (*)(), void (*)(), testing::TestInfo*) | void AddTestInfo(Test::SetUpTestCaseFunc set_up_tc,
Test::TearDownTestCaseFunc tear_down_tc,
TestInfo* test_info) {
// In order to support thread-safe death tests, we need to
// remember the original working directory when the test program
// was first invoked. We cann... | subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x30(%rsp)
addq $0x10, %rdi
callq 0x565130
testb $0x1, %al
jne 0x56068d
jmp 0x560783
movq 0x30(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x20(%rsp)
leaq 0x48(%rsp), %rdi
movq %rdi, 0x2... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest-all.cc |
testing::Message& testing::Message::operator<<<char [13]>(char const (&) [13]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x4db250
movq %rax, %rdi
addq $0x10, %rdi
movq 0x8(%rsp), %rsi
callq 0x327c20
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest.h |
testing::internal::ParameterizedTestCaseRegistry::RegisterTests() | void RegisterTests() {
for (TestCaseInfoContainer::iterator it = test_case_infos_.begin();
it != test_case_infos_.end(); ++it) {
(*it)->RegisterTests();
}
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x566b00
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rdi
callq 0x566b70
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x566b30
testb $0x1, %al
jne 0x5608e1
jmp 0x560900
leaq 0x18(%rsp), %rdi
callq 0x566ba0
movq ... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest.h |
int testing::internal::CountIf<std::vector<testing::TestInfo*, std::allocator<testing::TestInfo*>>, bool (*)(testing::TestInfo const*)>(std::vector<testing::TestInfo*, std::allocator<testing::TestInfo*>> const&, bool (*)(testing::TestInfo const*)) | inline int CountIf(const Container& c, Predicate predicate) {
// Implemented as an explicit loop since std::count_if() in libCstd on
// Solaris has a non-standard signature.
int count = 0;
for (typename Container::const_iterator it = c.begin(); it != c.end(); ++it) {
if (predicate(*it))
++count;
}
... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movq 0x30(%rsp), %rdi
callq 0x56dcd0
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
callq 0x56dd40
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x56dd00
testb $0x1, %al
jne 0x560cb9
jmp 0x560cf9
movq 0x28(%rsp), %... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest-all.cc |
testing::internal::posix::GetEnv(char const*) | inline const char* GetEnv(const char* name) {
#if GTEST_OS_WINDOWS_MOBILE
// We are on Windows CE, which has no environment variables.
return NULL;
#elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9)
// Environment variables which we programmatically clear will be set to the
// empty str... | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x327f30
popq %rcx
retq
| /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest.h |
testing::Message& testing::Message::operator<<<char>(char const&) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x4db250
movq %rax, %rdi
addq $0x10, %rdi
movq 0x8(%rsp), %rax
movsbl (%rax), %esi
callq 0x327d70
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
| /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest.h |
testing::Message& testing::Message::operator<<<char [15]>(char const (&) [15]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x4db250
movq %rax, %rdi
addq $0x10, %rdi
movq 0x8(%rsp), %rsi
callq 0x327c20
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest.h |
testing::TestPartResult::TestPartResult(testing::TestPartResult::Type, char const*, int, char const*) | TestPartResult(Type a_type,
const char* a_file_name,
int a_line_number,
const char* a_message)
: type_(a_type),
file_name_(a_file_name == NULL ? "" : a_file_name),
line_number_(a_line_number),
summary_(ExtractSummary(a_message)),
m... | subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movl %esi, 0x7c(%rsp)
movq %rdx, 0x70(%rsp)
movl %ecx, 0x6c(%rsp)
movq %r8, 0x60(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x38(%rsp)
movl 0x7c(%rsp), %ecx
movl %ecx, (%rax)
addq $0x8, %rax
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x70(%rsp)
jne 0x561f53
leaq 0x303c0a(%rip), %rax # 0x865b... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest.h |
bool testing::internal::HandleExceptionsInMethodIfSupported<testing::internal::UnitTestImpl, bool>(testing::internal::UnitTestImpl*, bool (testing::internal::UnitTestImpl::*)(), char const*) | Result HandleExceptionsInMethodIfSupported(
T* object, Result (T::*method)(), const char* location) {
// NOTE: The user code can affect the way in which Google Test handles
// exceptions by setting GTEST_FLAG(catch_exceptions), but only before
// RUN_ALL_TESTS() starts. It is technically possible to check the... | subq $0xc8, %rsp
movq %rsi, 0xb0(%rsp)
movq %rdx, 0xb8(%rsp)
movq 0xb0(%rsp), %rax
movq 0xb8(%rsp), %rdx
movq %rdi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq %rax, 0x98(%rsp)
movq %rcx, 0x90(%rsp)
callq 0x55dec0
movq %rax, %rdi
callq 0x56db10
testb $0x1, %al
jne 0x56225d
jmp 0x56242b
movq 0xa8(%rsp), %rdi
movq 0x98(%rsp), ... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest-all.cc |
testing::internal::ParameterizedTestCaseRegistry::~ParameterizedTestCaseRegistry() | ~ParameterizedTestCaseRegistry() {
for (TestCaseInfoContainer::iterator it = test_case_infos_.begin();
it != test_case_infos_.end(); ++it) {
delete *it;
}
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x566b00
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rdi
callq 0x566b70
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x566b30
testb $0x1, %al
jne 0x5628b1
jmp 0x5628e0
leaq 0x18(%rsp), %rdi
callq 0x566ba0
movq ... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest.h |
testing::internal::ThreadLocal<testing::TestPartResultReporterInterface*>::~ThreadLocal() | ~ThreadLocal() {
// Destroys the managed object for the current thread, if any.
DeleteThreadLocalValue(pthread_getspecific(key_));
// Releases resources associated with the key. This will *not*
// delete managed objects for other threads.
GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_));
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl (%rax), %edi
callq 0x328660
movq %rax, %rdi
callq 0x570550
movq 0x10(%rsp), %rax
movl (%rax), %edi
callq 0x3282e0
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
je 0x562a56
leaq 0x300e56(%rip), %rdx # 0x863846
leaq 0x18(%rsp), %rdi
... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest.h |
testing::internal::GetNextRandomSeed(int) | inline int GetNextRandomSeed(int seed) {
GTEST_CHECK_(1 <= seed && seed <= kMaxRandomSeed)
<< "Invalid random seed " << seed << " - must be in [1, "
<< kMaxRandomSeed << "].";
const int next_seed = seed + 1;
return (next_seed > kMaxRandomSeed) ? 1 : next_seed;
} | subq $0x58, %rsp
movl %edi, 0x54(%rsp)
xorl %eax, %eax
movl $0x1, %ecx
cmpl 0x54(%rsp), %ecx
movb %al, 0x3f(%rsp)
jg 0x563328
cmpl $0x1869f, 0x54(%rsp) # imm = 0x1869F
setle %al
movb %al, 0x3f(%rsp)
movb 0x3f(%rsp), %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x5416e0
testb $0x1, %al
jne 0x56333d
jmp 0x563342
jmp 0x5... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest-all.cc |
testing::Message& testing::Message::operator<<<char [19]>(char const (&) [19]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x4db250
movq %rax, %rdi
addq $0x10, %rdi
movq 0x8(%rsp), %rsi
callq 0x327c20
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest.h |
testing::Message& testing::Message::operator<<<char [9]>(char const (&) [9]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x4db250
movq %rax, %rdi
addq $0x10, %rdi
movq 0x8(%rsp), %rsi
callq 0x327c20
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest.h |
testing::Message& testing::Message::operator<<<char [16]>(char const (&) [16]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x4db250
movq %rax, %rdi
addq $0x10, %rdi
movq 0x8(%rsp), %rsi
callq 0x327c20
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest.h |
void testing::internal::ShuffleRange<int>(testing::internal::Random*, int, int, std::vector<int, std::allocator<int>>*) | void ShuffleRange(internal::Random* random, int begin, int end,
std::vector<E>* v) {
const int size = static_cast<int>(v->size());
GTEST_CHECK_(0 <= begin && begin <= size)
<< "Invalid shuffle range start " << begin << ": must be in range [0, "
<< size << "].";
GTEST_CHECK_(begin <= ... | subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movl %esi, 0xbc(%rsp)
movl %edx, 0xb8(%rsp)
movq %rcx, 0xb0(%rsp)
movq 0xb0(%rsp), %rdi
callq 0x3349f0
movl %eax, 0xac(%rsp)
xorl %eax, %eax
xorl %ecx, %ecx
cmpl 0xbc(%rsp), %ecx
movb %al, 0x8b(%rsp)
jg 0x563805
movl 0xbc(%rsp), %eax
cmpl 0xac(%rsp), %eax
setle %al
movb %al, 0x8b(... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest-all.cc |
testing::Message& testing::Message::operator<<<char [33]>(char const (&) [33]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x4db250
movq %rax, %rdi
addq $0x10, %rdi
movq 0x8(%rsp), %rsi
callq 0x327c20
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest.h |
testing::Message& testing::Message::operator<<<char [51]>(char const (&) [51]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x4db250
movq %rax, %rdi
addq $0x10, %rdi
movq 0x8(%rsp), %rsi
callq 0x327c20
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest.h |
void testing::internal::Arguments::AddArguments<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(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>>>> cons... | void AddArguments(const ::std::vector<Str>& arguments) {
for (typename ::std::vector<Str>::const_iterator i = arguments.begin();
i != arguments.end();
++i) {
args_.insert(args_.end() - 1, posix::StrDup(i->c_str()));
}
} | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
callq 0x43f2d0
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0x43f300
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x43f4e0
testb $0x1, %al
jne 0x564b3b
jmp 0x564b... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest-all.cc |
testing::Message& testing::Message::operator<<<char [52]>(char const (&) [52]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x4db250
movq %rax, %rdi
addq $0x10, %rdi
movq 0x8(%rsp), %rsi
callq 0x327c20
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest.h |
testing::internal::CapturedStream::CapturedStream(int) | explicit CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) {
# if GTEST_OS_WINDOWS
char temp_dir_path[MAX_PATH + 1] = { '\0' }; // NOLINT
char temp_file_path[MAX_PATH + 1] = { '\0' }; // NOLINT
::GetTempPathA(sizeof(temp_dir_path), temp_dir_path);
const UINT success = ::GetTempFileNameA(temp_... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x4c(%rsp), %ecx
movl %ecx, (%rax)
movl 0x4c(%rsp), %edi
callq 0x3288a0
movq 0x8(%rsp), %rdi
movl %eax, 0x4(%rdi)
addq $0x8, %rdi
movq %rdi, 0x10(%rsp)
callq 0x327750
vmovdqu 0x2ff178(%rip), %xmm0 # 0x8643ac
v... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest-all.cc |
testing::internal::CapturedStream::GetCapturedString[abi:cxx11]() | std::string GetCapturedString() {
if (uncaptured_fd_ != -1) {
// Restores the original stream.
fflush(NULL);
dup2(uncaptured_fd_, fd_);
close(uncaptured_fd_);
uncaptured_fd_ = -1;
}
FILE* const file = posix::FOpen(filename_.c_str(), "r");
const std::string content = ReadEn... | subq $0x48, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpl $-0x1, 0x4(%rax)
je 0x56532b
xorl %eax, %eax
movl %eax, %edi
callq 0x327aa0
movq 0x10(%rsp), %rax
movl 0x4(%rax), %edi
movl (%rax), %esi
callq 0x327be0
mov... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest-all.cc |
testing::Message& testing::Message::operator<<<testing::Message>(testing::Message const&) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x4db250
movq %rax, %rdi
addq $0x10, %rdi
movq 0x8(%rsp), %rsi
callq 0x571e20
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest.h |
testing::Message& testing::Message::operator<<<char [22]>(char const (&) [22]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x4db250
movq %rax, %rdi
addq $0x10, %rdi
movq 0x8(%rsp), %rsi
callq 0x327c20
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest.h |
void testing::internal::PrintCharAndCodeTo<wchar_t, wchar_t>(wchar_t, std::ostream*) | void PrintCharAndCodeTo(Char c, ostream* os) {
// First, print c as a literal in the most readable form we can find.
*os << ((sizeof(c) > 1) ? "L'" : "'");
const CharFormat format = PrintAsCharLiteralTo<UnsignedChar>(c, os);
*os << "'";
// To aid user debugging, we also print c's code in decimal, unless
//... | subq $0x58, %rsp
movl %edi, 0x54(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
leaq 0x2fea08(%rip), %rsi # 0x864151
callq 0x327c20
movl 0x54(%rsp), %edi
movq 0x48(%rsp), %rsi
callq 0x55d9d0
movl %eax, 0x44(%rsp)
movq 0x48(%rsp), %rdi
leaq 0x2fe9e6(%rip), %rsi # 0x864152
callq 0x327c20
cmpl $0x0, 0x54(%rsp)
jn... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest-all.cc |
testing::Message& testing::Message::operator<<<char [25]>(char const (&) [25]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x4db250
movq %rax, %rdi
addq $0x10, %rdi
movq 0x8(%rsp), %rsi
callq 0x327c20
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest.h |
testing::internal::MutexBase::Unlock() | void Unlock() {
// Since the lock is being released the owner_ field should no longer be
// considered valid. We don't protect writing to has_owner_ here, as it's
// the caller's responsibility to ensure that the current thread holds the
// mutex when this is called.
has_owner_ = false;
GTEST_CH... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movb $0x0, 0x28(%rdi)
callq 0x327560
movl %eax, 0x2c(%rsp)
cmpl $0x0, 0x2c(%rsp)
je 0x566342
leaq 0x2fd589(%rip), %rdx # 0x863846
leaq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x3, %esi
movl $0x99f, %ecx # imm = 0x99F
callq 0x55b020
movq 0x8(... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest.h |
testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::ValueHolder* testing::internal::CheckedDowncastToActualType<testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::ValueHolder, testi... | Derived* CheckedDowncastToActualType(Base* base) {
#if GTEST_HAS_RTTI
GTEST_CHECK_(typeid(*base) == typeid(Derived));
return dynamic_cast<Derived*>(base); // NOLINT
#else
return static_cast<Derived*>(base); // Poor man's downcast.
#endif
} | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
jne 0x566f7e
callq 0x328310
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq -0x8(%rax), %rdi
leaq 0x2ea6c6f(%rip), %rsi # 0x340dc00
callq 0x5670d0
movzbl %al, %edi
andl $0x1, %edi
callq 0x5416e0
testb $0x1, %al
jne 0x566fa... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest.h |
testing::internal::StreamingListener::SocketWriter::Send(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | virtual void Send(const string& message) {
GTEST_CHECK_(sockfd_ != -1)
<< "Send() can be called only when there is a connection.";
const int len = static_cast<int>(message.length());
if (write(sockfd_, message.c_str(), len) != len) {
GTEST_LOG_(WARNING)
<< "stream_result... | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x40(%rsp)
cmpl $-0x1, 0x8(%rax)
setne %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x5416e0
testb $0x1, %al
jne 0x568eb0
jmp 0x568eb2
jmp 0x568f2e
leaq 0x2f9569(%rip), %rdx # 0x862422
leaq 0x64(%rsp), %rdi
movq %rdi, 0x30(%r... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest-all.cc |
testing::internal::StreamingListener::SocketWriter::CloseConnection() | void CloseConnection() {
GTEST_CHECK_(sockfd_ != -1)
<< "CloseConnection() can be called only when there is a connection.";
close(sockfd_);
sockfd_ = -1;
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpl $-0x1, 0x8(%rax)
setne %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x5416e0
testb $0x1, %al
jne 0x56905b
jmp 0x56905d
jmp 0x5690d4
leaq 0x2f93be(%rip), %rdx # 0x862422
leaq 0x2c(%rsp), %rdi
movq %rdi, (%rsp)
movl $0x3, %esi
movl $... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest-all.cc |
testing::Message& testing::Message::operator<<<char [53]>(char const (&) [53]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x4db250
movq %rax, %rdi
addq $0x10, %rdi
movq 0x8(%rsp), %rsi
callq 0x327c20
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest.h |
testing::internal::UniversalPrinter<std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>>::Print(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&, std::ostream*) | static void Print(const T& value, ::std::ostream* os) {
// By default, ::testing::internal::PrintTo() is used for printing
// the value.
//
// Thanks to Koenig look-up, if T is a class and has its own
// PrintTo() function defined in its namespace, that function will
// be visible here. Since i... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x56abb0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest.h |
testing::Message& testing::Message::operator<<<char [14]>(char const (&) [14]) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x4db250
movq %rax, %rdi
addq $0x10, %rdi
movq 0x8(%rsp), %rsi
callq 0x327c20
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest.h |
testing::Message& testing::Message::operator<<<double>(double const&) | inline Message& operator <<(const T& val) {
// Some libraries overload << for STL containers. These
// overloads are defined in the global namespace instead of ::std.
//
// C++'s symbol lookup rule (i.e. Koenig lookup) says that these
// overloads are visible in either the std namespace or the glob... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x4db250
movq %rax, %rdi
addq $0x10, %rdi
movq 0x8(%rsp), %rax
vmovsd (%rax), %xmm0
callq 0x328100
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
| /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest.h |
testing::internal::FloatingPoint<double>::SignAndMagnitudeToBiased(unsigned long long const&) | static Bits SignAndMagnitudeToBiased(const Bits &sam) {
if (kSignBitMask & sam) {
// sam represents a negative number.
return ~sam + 1;
} else {
// sam represents a positive number.
return kSignBitMask | sam;
}
} | movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rcx
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
andq (%rcx), %rax
cmpq $0x0, %rax
je 0x56b724
movq -0x10(%rsp), %rax
movq (%rax), %rax
xorq $-0x1, %rax
addq $0x1, %rax
movq %rax, -0x8(%rsp)
jmp 0x56b73b
movq -0x10(%rsp), %rcx
movabsq $-0x8000000000000000, %rax... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest.h |
void testing_internal::DefaultPrintNonContainerTo<long long>(long long const&, std::ostream*) | void DefaultPrintNonContainerTo(const T& value, ::std::ostream* os) {
// With the following statement, during unqualified name lookup,
// testing::internal2::operator<< appears as if it was declared in
// the nearest enclosing namespace that contains both
// ::testing_internal and ::testing::internal2, i.e. the... | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
callq 0x327c60
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest.h |
testing::TestPartResult::TestPartResult(testing::TestPartResult const&) | class GTEST_API_ TestPartResult {
public:
// The possible outcomes of a test part (i.e. an assertion or an
// explicit SUCCEED(), FAIL(), or ADD_FAILURE()).
enum Type {
kSuccess, // Succeeded.
kNonFatalFailure, // Failed but the test can continue.
kFatalFailure // Failed and the test s... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x28(%rsp), %rax
movl (%rax), %eax
movl %eax, (%rdi)
addq $0x8, %rdi
movq %rdi, (%rsp)
movq 0x28(%rsp), %rsi
addq $0x8, %rsi
callq 0x3272e0
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rax
movl 0x28(%rax), %eax
movl %... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest.h |
void testing::internal::HandleSehExceptionsInMethodIfSupported<testing::Test, void>(testing::Test*, void (testing::Test::*)(), char const*) | Result HandleSehExceptionsInMethodIfSupported(
T* object, Result (T::*method)(), const char* location) {
#if GTEST_HAS_SEH
__try {
return (object->*method)();
} __except (internal::UnitTestOptions::GTestShouldProcessSEH( // NOLINT
GetExceptionCode())) {
// We create the exception message on the h... | subq $0x48, %rsp
movq %rsi, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rdx
movq %rdi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rax, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdx
addq %rdx, %rcx
movq %rcx, 0x10(%rsp)
an... | /anderslanglands[P]pbrt-v4/src/ext/gtest/gtest-all.cc |
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.