name string | code string | asm string | file string |
|---|---|---|---|
testing::AssertionResult& testing::AssertionResult::operator<<<char [2]>(char const (&) [2]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xf68a
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x8210
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x85f0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2ec22
movq 0x8(%rs... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [12]>(char const (&) [12]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xf68a
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x8210
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x85f0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2ec22
movq 0x8(%rs... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [13]>(char const (&) [13]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xf68a
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x8210
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x85f0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2ec22
movq 0x8(%rs... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/include/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... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r13
addq $0x8, %rdi
leaq 0x18(%r13), %rax
movq %rax, 0x28(%rsp)
movq %rax, 0x8(%r13)
xorl %eax, %eax
movq %rax, 0x10(%r13)
movb %al, 0x18(%r13)
leaq 0x28(%r13), %rcx
movq %rcx, 0x8(%rsp)
leaq 0x38(%r13), %rcx
movq %rcx, 0x20(... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest-internal-inl.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 == nullptr ? "" : a_file_name),
line_number_(a_line_number),
summary_(ExtractSummary(a_message)),
message_(a_message) {} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movl %ecx, %ebp
movq %rdi, %r14
movl %esi, (%rdi)
leaq 0x8(%rdi), %rbx
testq %rdx, %rdx
leaq 0x10f10(%rip), %r12 # 0x3d7e3
cmovneq %rdx, %r12
leaq 0x18(%rdi), %r13
movq %r13, 0x8(%rdi)
movq %r12, %rdi
callq 0x8210
leaq (%rax... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/include/gtest/gtest-test-part.h |
testing::TestPartResult::~TestPartResult() | 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... | pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
leaq 0x60(%rbx), %rax
cmpq %rax, %rdi
je 0x2c96c
callq 0x84a0
movq 0x30(%rbx), %rdi
leaq 0x40(%rbx), %rax
cmpq %rax, %rdi
je 0x2c97e
callq 0x84a0
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x2c991
popq %rbx
jmp 0x84a0
popq %rbx
retq
nop
| /jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/include/gtest/gtest-test-part.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> testing::internal::StreamableToString<long>(long const&) | std::string StreamableToString(const T& streamable) {
return (Message() << streamable).GetString();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xf68a
movq (%rbx), %rbx
leaq 0x10(%rbx), %rdi
movq (%r15), %rsi
callq 0x84b0
movq %r14, %rdi
movq %rbx, %rsi
callq 0xf8c7
testq %rbx, %rbx
je 0x2cb90
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/include/gtest/gtest-message.h |
testing::internal::UnitTestImpl::Passed() const | bool Passed() const { return !Failed(); } | pushq %rbx
movq %rdi, %rbx
callq 0xefa8
testl %eax, %eax
jle 0x2cc31
xorl %eax, %eax
jmp 0x2cc42
addq $0x178, %rbx # imm = 0x178
movq %rbx, %rdi
callq 0x12d58
xorb $0x1, %al
popq %rbx
retq
| /jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest-internal-inl.h |
testing::TestProperty::TestProperty(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | TestProperty(const std::string& a_key, const std::string& a_value) :
key_(a_key), value_(a_value) {
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0xad5e
leaq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
movq %rax, 0x20(%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
callq 0xad... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/include/gtest/gtest.h |
testing::internal::ScopedPrematureExitFile::ScopedPrematureExitFile(char const*) | explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
: premature_exit_filepath_(premature_exit_filepath ?
premature_exit_filepath : "") {
// If a path to the premature-exit file is specified...
if (!premature_exit_filepath_.empty()) {
// create the f... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
leaq 0x10b02(%rip), %r15 # 0x3d7e3
cmovneq %rsi, %r15
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq %r15, %rdi
callq 0x8210
leaq (%rax,%r15), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0xb728
cmpq $0x0, 0x8(%r14)
je 0x2cd36
leaq 0x1351... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest.cc |
testing::internal::ScopedPrematureExitFile::~ScopedPrematureExitFile() | ~ScopedPrematureExitFile() {
#if !defined GTEST_OS_ESP8266
if (!premature_exit_filepath_.empty()) {
int retval = remove(premature_exit_filepath_.c_str());
if (retval) {
GTEST_LOG_(ERROR) << "Failed to remove premature exit filepath \""
<< premature_exit_filepath_ << "\"... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x2cf2f
movq (%rbx), %rdi
callq 0x8a50
testl %eax, %eax
je 0x2cf2f
movl %eax, %ebp
leaq 0xfd07(%rip), %rdx # 0x3cbcc
leaq 0xc(%rsp), %rdi
movl $0x2, %esi
movl $0x13a2, %ecx # imm = 0x13A2
callq 0x27da0
movq 0x28100(... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest.cc |
testing::internal::StreamingListener::StreamingListener(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | StreamingListener(const std::string& host, const std::string& port)
: socket_writer_(new SocketWriter(host, port)) {
Start();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x275dc(%rip), %rax # 0x54768
movq %rax, (%rdi)
movl $0x50, %edi
callq 0x84e0
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x2f68c
movq %r15, 0x8(%rbx)
movq %rbx, %rdi
callq 0x2f730
a... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest-internal-inl.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;
} | pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
leal -0x1(%rbx), %eax
cmpl $0x1869f, %eax # imm = 0x1869F
jb 0x2d487
leaq 0x114b9(%rip), %rdx # 0x3e8ac
leaq 0x4(%rsp), %rdi
movl $0x3, %esi
movl $0x96, %ecx
callq 0x27da0
movq 0x27bd2(%rip), %rdi # 0x54fe0
leaq 0x1187e(%rip), %rsi # 0x3ec93
movl $0x... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest-internal-inl.h |
testing::Message::Message(testing::Message const&) | Message(const Message& msg) : ss_(new ::std::stringstream) { // NOLINT
*ss_ << msg.GetString();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x188, %edi # imm = 0x188
callq 0x84e0
movq %rax, %r15
movq %rax, %rdi
callq 0x8360
movq %r15, (%rbx)
movq (%r14), %rsi
movq %rsp, %rdi
callq 0xf8c7
addq $0x10, %r15
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r15, %rdi
... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/include/gtest/gtest-message.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 <= ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %r12d
movl %esi, %ebp
movq %rdi, %r14
movq 0x8(%rcx), %r15
subq (%rcx), %r15
shrq $0x2, %r15
testl %esi, %esi
js 0x2d5cd
cmpl %ebp, %r15d
jge 0x2d666
leaq 0x112d8(%rip), %rdx # 0x3e8ac
leaq 0x4(%rsp), %rdi
movl $... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest-internal-inl.h |
void testing::internal::ParseGoogleTestFlagsOnlyImpl<char>(int*, char**) | void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) {
for (int i = 1; i < *argc; i++) {
const std::string arg_string = StreamableToString(argv[i]);
const char* const arg = arg_string.c_str();
using internal::ParseBoolFlag;
using internal::ParseInt32Flag;
using internal::ParseStringFlag;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x2, (%rdi)
jl 0x2d8bb
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsi), %rax
movq %rax, (%rsp)
movl $0x1, %r13d
leaq 0x8(%rsp), %r15
movslq %r13d, %r12
leaq (%rbx,%r12,8), %rsi
movq %r15, %rdi
callq 0x33c57
movq 0x8(%rsp), %rbp
movq... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest.cc |
void testing::internal::InitGoogleTestImpl<char>(int*, char**) | void InitGoogleTestImpl(int* argc, CharType** argv) {
// We don't want to run the initialization code twice.
if (GTestIsInitialized()) return;
if (*argc <= 0) return;
g_argvs.clear();
for (int i = 0; i != *argc; i++) {
g_argvs.push_back(StreamableToString(argv[i]));
}
#if GTEST_HAS_ABSL
absl::Initi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r13
movq %rdi, %r14
leaq 0x28106(%rip), %rsi # 0x55b70
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x2ac7a
movq 0x8(%r15), %rbx
movq (%r15), %r12
movq %r15, %rdi
callq 0x2ac36
cmpq %r12, %rbx
jne 0x2db13
cmpl $0x0, (%r14)
... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest.cc |
testing::internal::UniversalTersePrinter<wchar_t const*>::Print(wchar_t const*, std::ostream*) | static void Print(const wchar_t* str, ::std::ostream* os) {
if (str == nullptr) {
*os << "NULL";
} else {
UniversalPrint(::std::wstring(str), os);
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
testq %rdi, %rdi
je 0x31363
movq %rdi, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
callq 0x8430
leaq (%r14,%rax,4), %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3139c
movq (%r15), %rdi
movq 0x8(%r15), %rsi
movq %rbx,... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/include/gtest/gtest-printers.h |
testing::internal::ThreadLocal<testing::TestPartResultReporterInterface*>::ValueHolder* testing::internal::CheckedDowncastToActualType<testing::internal::ThreadLocal<testing::TestPartResultReporterInterface*>::ValueHolder, testing::internal::ThreadLocalValueHolderBase>(testing::internal::ThreadLocalValueHolderBase*) | Derived* CheckedDowncastToActualType(Base* base) {
#if GTEST_HAS_RTTI
GTEST_CHECK_(typeid(*base) == typeid(Derived));
#endif
#if GTEST_HAS_DOWNCAST_
return ::down_cast<Derived*>(base);
#elif GTEST_HAS_RTTI
return dynamic_cast<Derived*>(base); // NOLINT
#else
return static_cast<Derived*>(base); // Poor man's ... | pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x31bc0
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0xdfb6(%rip), %rax # 0x3fb02
cmpq %rax, %rdi
je 0x31ba3
cmpb $0x2a, (%rdi)
je 0x31b66
leaq 0xdfa5(%rip), %rsi # 0x3fb02
callq 0x87f0
testl %eax, %eax
je 0x31ba3
leaq 0xcb6e... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/include/gtest/internal/gtest-port.h |
testing::internal::FloatingPoint<float>::AlmostEquals(testing::internal::FloatingPoint<float> const&) const | Bits exponent_bits() const { return kExponentBitMask & u_.bits_; } | movl (%rdi), %eax
movl %eax, %ecx
notl %ecx
testl $0x7f800000, %ecx # imm = 0x7F800000
sete %cl
testl $0x7fffff, %eax # imm = 0x7FFFFF
setne %dl
testb %dl, %cl
jne 0x3232f
movl (%rsi), %ecx
movl %ecx, %edx
notl %edx
testl $0x7f800000, %edx # imm = 0x7F800000
sete %dl
testl $0x7fffff, %ecx # ... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/include/gtest/internal/gtest-internal.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [16]>(char const (&) [16]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xf68a
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x8210
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x85f0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2ec22
movq 0x8(%rs... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult& testing::AssertionResult::operator<<<std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>>(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xf68a
movq %r15, %rdi
movq %r14, %rsi
callq 0xf7dc
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2ec22
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x32524
movq (%rdi), %rax
callq *0x8(%rax)
movq %rb... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/include/gtest/gtest.h |
void __gnu_cxx::new_allocator<testing::TestPartResult>::construct<testing::TestPartResult, testing::TestPartResult>(testing::TestPartResult*, testing::TestPartResult&&) | 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... | movl (%rdx), %eax
movl %eax, (%rsi)
leaq 0x18(%rsi), %rcx
movq %rcx, 0x8(%rsi)
movq 0x8(%rdx), %rdi
leaq 0x18(%rdx), %rax
cmpq %rax, %rdi
je 0x32878
movq %rdi, 0x8(%rsi)
movq (%rax), %rcx
movq %rcx, 0x18(%rsi)
jmp 0x3287e
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x10(%rdx), %rcx
movq %rcx, 0x10(%rsi)
movq %rax, 0... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/include/gtest/gtest-test-part.h |
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) = ... | pushq %rbx
movq %rdi, %rbx
movb (%rdi), %al
movb %al, 0x22c1b(%rip) # 0x55aa3
movb 0x1(%rdi), %al
movb %al, 0x22c13(%rip) # 0x55aa4
movb 0x2(%rdi), %al
movb %al, 0x22c0b(%rip) # 0x55aa5
leaq 0x8(%rdi), %rsi
leaq 0x22c03(%rip), %rdi # 0x55aa8
callq 0x82a0
leaq 0x28(%rbx), %rsi
leaq 0x22d4b(%rip), %rdi... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/src/gtest-internal-inl.h |
testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::CreateKey() | static pthread_key_t CreateKey() {
pthread_key_t key;
// When a thread exits, DeleteThreadLocalValue() will be called on
// the object managed for that thread.
GTEST_CHECK_POSIX_SUCCESS_(
pthread_key_create(&key, &DeleteThreadLocalValue));
return key;
} | pushq %rbx
subq $0x10, %rsp
leaq -0x4a(%rip), %rsi # 0x33828
leaq 0xc(%rsp), %rdi
callq 0x8920
testl %eax, %eax
je 0x338e5
movl %eax, %ebx
leaq 0xae52(%rip), %rdx # 0x3e6db
leaq 0x8(%rsp), %rdi
movl $0x3, %esi
movl $0x706, %ecx # imm = 0x706
callq 0x27da0
movq 0x2173c(%rip), %rdi # 0x54fe0
lea... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/include/gtest/internal/gtest-port.h |
testing::internal::SharedPayload<testing::internal::EqMatcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::Destroy(testing::internal::SharedPayloadBase*) | static void Destroy(SharedPayloadBase* shared) {
delete static_cast<SharedPayload*>(shared);
} | testq %rdi, %rdi
je 0x33e9c
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x33e93
callq 0x84a0
movq %rbx, %rdi
popq %rbx
jmp 0x84a0
retq
nop
| /jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/include/gtest/gtest-matchers.h |
decltype(testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::ValuePolicy<testing::internal::EqMatcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, false>::Get(fp).MatchAndExplain(fp0, fp1->stream())) testing::internal::Match... | static const M& Get(const MatcherBase& m) {
return static_cast<Shared*>(m.buffer_.shared)->value;
} | movq 0x10(%rdi), %rax
movq 0x8(%rsi), %rdx
cmpq 0x10(%rax), %rdx
jne 0x33f53
testq %rdx, %rdx
je 0x33f56
pushq %rax
movq 0x8(%rax), %rax
movq (%rsi), %rdi
movq %rax, %rsi
callq 0x8530
testl %eax, %eax
sete %al
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
movb $0x1, %al
retq
nop
| /jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/include/gtest/gtest-matchers.h |
testing::MatcherDescriberInterface const* testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::GetDescriberImpl<testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::ValuePolicy<testing::internal::EqMatc... | static const MatcherDescriberInterface* GetDescriberImpl(
const MatcherBase& m) {
// If the impl is a MatcherDescriberInterface, then return it.
// Otherwise use MatcherBase itself.
// This allows us to implement the GetDescriber() function without support
// from the impl, but some users really w... | movq %rdi, %rax
retq
| /jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/include/gtest/gtest-matchers.h |
testing::Cardinality::DescribeActualCallCountTo(int, std::ostream*) | void Cardinality::DescribeActualCallCountTo(int actual_call_count,
::std::ostream* os) {
if (actual_call_count > 0) {
*os << "called " << FormatTimes(actual_call_count);
} else {
*os << "never called";
}
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
testl %edi, %edi
jle 0x3419d
movl %edi, %ebp
leaq 0xbc09(%rip), %rsi # 0x3fd61
movl $0x7, %edx
movq %rbx, %rdi
callq 0x85f0
movq %rsp, %r14
movq %r14, %rdi
movl %ebp, %esi
callq 0x341d7
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googlemock/src/gmock-cardinalities.cc |
testing::Between(int, int) | GTEST_API_ Cardinality Between(int min, int max) {
return Cardinality(new BetweenCardinalityImpl(min, max));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movl %edx, %r15d
movl %esi, %ebp
movq %rdi, %r14
movl $0x10, %edi
callq 0x84e0
movq %rax, %rbx
leaq 0x20840(%rip), %rax # 0x54b28
movq %rax, (%rbx)
xorl %eax, %eax
testl %ebp, %ebp
cmovgl %ebp, %eax
movl %eax, 0x8(%rbx... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googlemock/src/gmock-cardinalities.cc |
testing::internal::GetFailureReporter() | GTEST_API_ FailureReporterInterface* GetFailureReporter() {
// Points to the global failure reporter used by Google Mock. gcc
// guarantees that the following use of failure_reporter is
// thread-safe. We may need to add additional synchronization to
// protect failure_reporter if we port Google Mock to other... | pushq %rbx
movb 0x214f9(%rip), %al # 0x55c98
testb %al, %al
je 0x347ac
movq 0x214e6(%rip), %rax # 0x55c90
popq %rbx
retq
leaq 0x214e5(%rip), %rdi # 0x55c98
callq 0x8a70
testl %eax, %eax
je 0x347a3
movl $0x8, %edi
callq 0x84e0
leaq 0x2047b(%rip), %rcx # 0x54c48
movq %rcx, (%rax)
movq %rax, 0x214b9(%rip)... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googlemock/src/gmock-internal-utils.cc |
testing::internal::Log(testing::internal::LogSeverity, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) | GTEST_API_ void Log(LogSeverity severity, const std::string& message,
int stack_frames_to_skip) {
if (!LogIsVisible(severity))
return;
// Ensures that logs from different threads don't interleave.
MutexLock l(&g_log_mutex);
if (severity == kWarning) {
// Prints a GMOCK WARNING mark... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebx
movq %rsi, %r14
movl %edi, %ebp
callq 0x347fc
testb %al, %al
je 0x34956
leaq 0x21461(%rip), %rdi # 0x55cc0
callq 0x2ecde
cmpl $0x1, %ebp
jne 0x34881
movq 0x20748(%rip), %rdi # 0x54fb8
leaq 0xb4ff(%rip), %rsi # 0x3fd76
movl $0xf, %edx
callq 0... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googlemock/src/gmock-internal-utils.cc |
testing::internal::FormatMatcherDescription(bool, char const*, 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>>>> const&) | GTEST_API_ std::string FormatMatcherDescription(bool negation,
const char* matcher_name,
const Strings& param_values) {
std::string result = ConvertIdentifierNameToWords(matcher_name);
if (param_values.size() >= 1) resul... | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rcx, %r15
movl %esi, %ebx
movq %rdi, %r14
leaq 0x20(%rsp), %rdi
movq %rdx, %rsi
callq 0x34692
movq 0x8(%r15), %rax
cmpq (%r15), %rax
je 0x34ae3
leaq 0x40(%rsp), %rdi
movq %r15, %rsi
callq 0x34592
leaq 0x85b0(%rip), %rcx # 0x3d006
leaq 0x40(%rsp), %rdi
movl $0... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googlemock/src/gmock-matchers.cc |
testing::internal::MatchMatrix::NextGraph() | bool MatchMatrix::NextGraph() {
for (size_t ilhs = 0; ilhs < LhsSize(); ++ilhs) {
for (size_t irhs = 0; irhs < RhsSize(); ++irhs) {
char& b = matched_[SpaceIndex(ilhs, irhs)];
if (!b) {
b = 1;
return true;
}
b = 0;
}
}
return false;
} | cmpq $0x0, (%rdi)
setne %al
je 0x34ccb
xorl %ecx, %ecx
movq 0x8(%rdi), %rsi
testq %rsi, %rsi
setne %dl
je 0x34cc0
imulq %rcx, %rsi
movq 0x10(%rdi), %r8
cmpb $0x0, (%r8,%rsi)
sete (%r8,%rsi)
je 0x34cbc
movl $0x1, %esi
movq 0x8(%rdi), %r8
cmpq %r8, %rsi
setb %dl
jae 0x34cc0
imulq %rcx, %r8
addq 0x10(%rdi), %r8
cmpb $0x0,... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googlemock/src/gmock-matchers.cc |
testing::internal::UnorderedElementsAreMatcherImplBase::DescribeNegationToImpl(std::ostream*) const | void UnorderedElementsAreMatcherImplBase::DescribeNegationToImpl(
::std::ostream* os) const {
switch (match_flags()) {
case UnorderedMatcherRequire::ExactMatch:
if (matcher_describers_.empty()) {
*os << "isn't empty";
return;
}
if (matcher_describers_.size() == 1) {
*... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl (%rdi), %eax
cmpl $0x1, %eax
je 0x35208
cmpl $0x2, %eax
je 0x351fa
cmpl $0x3, %eax
jne 0x3521c
movq 0x8(%r14), %rax
movq 0x10(%r14), %r15
cmpq %r15, %rax
je 0x352e5
subq %rax, %r15
leaq 0xaea0(%rip), ... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googlemock/src/gmock-matchers.cc |
testing::internal::LogElementMatcherPairVec(std::vector<std::pair<unsigned long, unsigned long>, std::allocator<std::pair<unsigned long, unsigned long>>> const&, std::ostream*) | static void LogElementMatcherPairVec(const ElementMatcherPairs& pairs,
::std::ostream* stream) {
typedef ElementMatcherPairs::const_iterator Iter;
::std::ostream& os = *stream;
os << "{";
const char* sep = "";
for (Iter it = pairs.begin(); it != pairs.end(); ++it) {
os... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xaf5d(%rip), %rsi # 0x40826
movl $0x1, %edx
movq %rbx, %rdi
callq 0x85f0
movq (%r14), %r13
cmpq 0x8(%r14), %r13
je 0x3599a
leaq 0x7ef9(%rip), %r12 # 0x3d7e3
leaq 0xa981(%rip), %r15 # 0x40272... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googlemock/src/gmock-matchers.cc |
testing::internal::ExpectationBase::AllPrerequisitesAreSatisfied() const | GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
g_gmock_mutex.AssertHeld();
::std::vector<const ExpectationBase*> expectations(1, this);
while (!expectations.empty()) {
const ExpectationBase* exp = expectations.back();
expectations.pop_back();
for (ExpectationSet::const_iterator it =
exp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x1ff26(%rip), %rdi # 0x55cf8
callq 0x38a5a
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movl $0x8, %edi
callq 0x84e0
movq %rax, (%rsp)
movq %rax, 0x8(%rsp)
leaq 0x8(%rax), %rcx
movq %rcx, 0x10(%... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googlemock/src/gmock-spec-builders.cc |
testing::internal::ExpectationBase::DescribeCallCountTo(std::ostream*) const | GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
g_gmock_mutex.AssertHeld();
// Describes how many times the function is expected to be called.
*os << " Expected: to be ";
cardinality().DescribeTo(os);
*os << "\n Actual: ";
Cardinality::DescribeActualCallCountTo(call_count(), os);
// De... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1fcb6(%rip), %r15 # 0x55cf8
movq %r15, %rdi
callq 0x38a5a
leaq 0xa16f(%rip), %rsi # 0x401c0
movl $0x19, %edx
movq %rbx, %rdi
callq 0x85f0
movq 0x40(%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x30(%rax)
leaq 0xa168(%rip), %rsi ... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googlemock/src/gmock-spec-builders.cc |
testing::internal::ExpectationBase::UntypedTimes(testing::Cardinality const&) | void ExpectationBase::UntypedTimes(const Cardinality& a_cardinality) {
if (last_clause_ == kTimes) {
ExpectSpecProperty(false,
".Times() cannot appear "
"more than once in an EXPECT_CALL().");
} else {
ExpectSpecProperty(last_clause_ < kTimes,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0xa4(%rdi), %ebp
leaq 0x10(%rsp), %r12
cmpl $0x2, %ebp
jne 0x364ce
movq %r12, -0x10(%r12)
leaq 0x9df0(%rip), %rsi # 0x4028c
leaq 0x9e23(%rip), %rdx # 0x402c6
movq %rsp, %rdi
callq 0xb728
movl 0x10(%r14... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googlemock/src/gmock-spec-builders.cc |
testing::internal::ReportUninterestingCall(testing::internal::CallReaction, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void ReportUninterestingCall(CallReaction reaction, const std::string& msg) {
// Include a stack trace only if --gmock_verbose=info is specified.
const int stack_frames_to_skip =
GMOCK_FLAG(verbose) == kInfoVerbosity ? 3 : -1;
switch (reaction) {
case kAllow:
Log(kInfo, msg, stack_frames_to_skip);... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movl %edi, %ebp
leaq 0x1f714(%rip), %rdi # 0x55ca0
leaq 0xa525(%rip), %rsi # 0x40ab8
callq 0x8160
xorl %ebx, %ebx
negl %eax
sbbl %ebx, %ebx
orl $0x3, %ebx
cmpl $0x1, %ebp
je 0x365c0
testl %ebp, %ebp
jne 0x3661a
xorl %edi, %edi
movq %r... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googlemock/src/gmock-spec-builders.cc |
testing::Mock::Register(void const*, testing::internal::UntypedFunctionMockerBase*) | GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
internal::MutexLock l(&internal::g_gmock_mutex);
g_mock_object_registry.states()[mock_obj].function_mockers.insert(mocker);
} | pushq %rbx
subq $0x10, %rsp
leaq 0x8(%rsp), %rbx
movq %rdi, (%rbx)
movq %rsi, (%rsp)
leaq 0x1f5ec(%rip), %rdi # 0x55cf8
callq 0x2ecde
movq %rbx, %rdi
callq 0x37908
addq $0x58, %rax
movq %rsp, %rsi
movq %rax, %rdi
callq 0x39d88
leaq 0x1f5c9(%rip), %rdi # 0x55cf8
callq 0x2ed7c
addq $0x10, %rsp
popq %rbx
retq
jmp ... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googlemock/src/gmock-spec-builders.cc |
testing::internal::UntypedFunctionMockerBase::VerifyAndClearExpectationsLocked() | GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
g_gmock_mutex.AssertHeld();
bool expectations_met = true;
for (UntypedExpectations::const_iterator it =
untyped_expectations_.begin();
it != untyped_expectations_.end(); ++it) {
ExpectationBase* const untyped_expectation = it->get();
if (un... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rdi, %rbx
leaq 0x1e9a3(%rip), %rdi # 0x55cf8
callq 0x38a5a
movq 0x30(%rbx), %rbp
movq 0x38(%rbx), %rax
cmpq %rax, %rbp
je 0x374a9
leaq 0x30(%rsp), %r14
movb $0x1, %r12b
movq %rsp, %r15
movq (%rbp), %r1... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googlemock/src/gmock-spec-builders.cc |
testing::Mock::VerifyAndClear(void*) | GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
internal::MutexLock l(&internal::g_gmock_mutex);
ClearDefaultActionsLocked(mock_obj);
return VerifyAndClearExpectationsLocked(mock_obj);
} | pushq %rbx
movq %rdi, %rbx
leaq 0x1e117(%rip), %rdi # 0x55cf8
callq 0x2ecde
movq %rbx, %rdi
callq 0x37c2a
movq %rbx, %rdi
callq 0x37b2c
movl %eax, %ebx
leaq 0x1e0f9(%rip), %rdi # 0x55cf8
callq 0x2ed7c
movl %ebx, %eax
popq %rbx
retq
jmp 0x37c21
movq %rax, %rbx
leaq 0x1e0e4(%rip), %rdi # 0x55cf8
callq 0x2ed7c... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googlemock/src/gmock-spec-builders.cc |
testing::Mock::RegisterUseByOnCallOrExpectCall(void const*, char const*, int) | GTEST_LOCK_EXCLUDED_(internal::g_gmock_mutex) {
internal::MutexLock l(&internal::g_gmock_mutex);
MockObjectState& state = g_mock_object_registry.states()[mock_obj];
if (state.first_used_file == nullptr) {
state.first_used_file = file;
state.first_used_line = line;
const TestInfo* const test_info =
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rsp, %rbx
movq %rdi, (%rbx)
leaq 0x1dff5(%rip), %rdi # 0x55cf8
callq 0x2ecde
movq %rbx, %rdi
callq 0x37908
movq %rax, %rbx
cmpq $0x0, (%rax)
jne 0x37d84
movq %r14, (%rbx)
movl %ebp, 0x8(%rbx)
callq 0xb... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googlemock/src/gmock-spec-builders.cc |
testing::InSequence::InSequence() | InSequence::InSequence() {
if (internal::g_gmock_implicit_sequence.get() == nullptr) {
internal::g_gmock_implicit_sequence.set(new Sequence);
sequence_created_ = true;
} else {
sequence_created_ = false;
}
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1de2a(%rip), %rdi # 0x55d30
callq 0x39fb6
cmpq $0x0, (%rax)
je 0x37f15
xorl %eax, %eax
jmp 0x37f55
movl $0x10, %edi
callq 0x84e0
movq %rax, %r14
movl $0x10, %edi
callq 0x84e0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rax, (%r14)
movq %r14, %rdi
addq $0x8, ... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googlemock/src/gmock-spec-builders.cc |
testing::InSequence::~InSequence() | InSequence::~InSequence() {
if (sequence_created_) {
delete internal::g_gmock_implicit_sequence.get();
internal::g_gmock_implicit_sequence.set(nullptr);
}
} | pushq %rbx
cmpb $0x1, (%rdi)
jne 0x37fb5
leaq 0x1ddb1(%rip), %rdi # 0x55d30
callq 0x39fb6
movq (%rax), %rbx
testq %rbx, %rbx
je 0x37fa2
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x37f9a
callq 0x393c6
movq %rbx, %rdi
callq 0x84a0
leaq 0x1dd87(%rip), %rdi # 0x55d30
callq 0x39fb6
movq $0x0, (%rax)
popq %rbx
retq
mo... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googlemock/src/gmock-spec-builders.cc |
testing::(anonymous namespace)::BetweenCardinalityImpl::DescribeTo(std::ostream*) const | void BetweenCardinalityImpl::DescribeTo(::std::ostream* os) const {
if (min_ == 0) {
if (max_ == 0) {
*os << "never called";
} else if (max_ == INT_MAX) {
*os << "called any number of times";
} else {
*os << "called at most " << FormatTimes(max_);
}
} else if (min_ == max_) {
*... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %ecx
movl 0xc(%rdi), %eax
testl %ecx, %ecx
je 0x3806c
cmpl %eax, %ecx
jne 0x38090
leaq 0x7d27(%rip), %rsi # 0x3fd61
movl $0x7, %edx
movq %rbx, %rdi
callq 0x85f0
movl 0x8(%r14), %esi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googlemock/src/gmock-cardinalities.cc |
bool testing::internal::ParseGoogleMockStringFlag<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*) | static bool ParseGoogleMockStringFlag(const char* str, const char* flag,
String* value) {
// Gets the value of the flag as a string.
const char* const value_str = ParseGoogleMockFlagValue(str, flag, false);
// Aborts if the parsing failed.
if (value_str == nullptr) return ... | pushq %r15
pushq %r14
pushq %rbx
leaq 0x87b7(%rip), %rsi # 0x40a8d
xorl %edx, %edx
callq 0x383be
movq %rax, %rbx
testq %rax, %rax
je 0x3830e
movq 0x1d9bc(%rip), %r14 # 0x55ca8
leaq 0x1d9ad(%rip), %r15 # 0x55ca0
movq %rbx, %rdi
callq 0x8210
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %rbx, %rcx
mov... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googlemock/src/gmock.cc |
testing::internal::ParseGoogleMockIntFlag(char const*, char const*, int*) | static bool ParseGoogleMockIntFlag(const char* str, const char* flag,
int32_t* value) {
// Gets the value of the flag as a string.
const char* const value_str = ParseGoogleMockFlagValue(str, flag, true);
// Aborts if the parsing failed.
if (value_str == nullptr) return false;... | pushq %r14
pushq %rbx
pushq %rax
leaq 0x8770(%rip), %rsi # 0x40a95
movl $0x1, %edx
callq 0x383be
testq %rax, %rax
je 0x38398
movq %rax, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0xf68a
movq (%r14), %rdi
addq $0x10, %rdi
leaq 0x5c37(%rip), %rsi # 0x3df87
movl $0x14, %edx
callq 0x85f0
movq (%rsp), %rdi
addq $0... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googlemock/src/gmock.cc |
testing::internal::MaxBipartiteMatchState::MaxBipartiteMatchState(testing::internal::MatchMatrix const&) | explicit MaxBipartiteMatchState(const MatchMatrix& graph)
: graph_(&graph),
left_(graph_->LhsSize(), kUnused),
right_(graph_->RhsSize(), kUnused) {} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq %rsi, (%rdi)
leaq 0x8(%rdi), %rbx
movq (%rsi), %rsi
leaq 0x85c3(%rip), %r15 # 0x40ac8
leaq 0xf(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rdx
callq 0x3904a
movq (%r14), %rax
addq $0x20, %r14
movq 0x8(%rax), %rsi
leaq 0xe(%rsp), %rcx
movq %r14, %rd... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googlemock/src/gmock-matchers.cc |
testing::internal::ExpectationBase::IsOverSaturated() const | GTEST_EXCLUSIVE_LOCK_REQUIRED_(g_gmock_mutex) {
g_gmock_mutex.AssertHeld();
return cardinality().IsOverSaturatedByCallCount(call_count_);
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1d1d9(%rip), %rdi # 0x55cf8
callq 0x38a5a
movl 0x80(%rbx), %ebp
movq 0x40(%rbx), %rdi
movq (%rdi), %rax
movl %ebp, %esi
callq *0x28(%rax)
testb %al, %al
je 0x38b4a
movq 0x40(%rbx), %rdi
movq (%rdi), %rax
movl %ebp, %esi
callq *0x20(%rax)
xorb $0x1, %al
jmp 0x3... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googlemock/include/gmock/gmock-spec-builders.h |
void testing::internal::InitGoogleMockImpl<char>(int*, char**) | void InitGoogleMockImpl(int* argc, CharType** argv) {
// Makes sure Google Test is initialized. InitGoogleTest() is
// idempotent, so it's fine if the user has already called it.
InitGoogleTest(argc, argv);
if (*argc <= 0) return;
for (int i = 1; i != *argc; i++) {
const std::string arg_string = Streama... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x20ec1
cmpl $0x0, (%r14)
jle 0x38de8
cmpl $0x1, (%r14)
je 0x38de8
leaq 0x8(%rbx), %rax
movq %rax, (%rsp)
movl $0x1, %ebp
leaq 0x8(%rsp), %r15
movslq %ebp, %r13
leaq (%rbx,%r13,8), %rsi
movq %r15, %r... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googlemock/src/gmock.cc |
void testing::internal::InitGoogleMockImpl<wchar_t>(int*, wchar_t**) | void InitGoogleMockImpl(int* argc, CharType** argv) {
// Makes sure Google Test is initialized. InitGoogleTest() is
// idempotent, so it's fine if the user has already called it.
InitGoogleTest(argc, argv);
if (*argc <= 0) return;
for (int i = 1; i != *argc; i++) {
const std::string arg_string = Streama... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x20ec6
cmpl $0x0, (%r14)
jle 0x38ed2
cmpl $0x1, (%r14)
je 0x38ed2
leaq 0x8(%rbx), %rax
movq %rax, (%rsp)
movl $0x1, %ebp
leaq 0x8(%rsp), %r15
movslq %ebp, %r13
leaq (%rbx,%r13,8), %rsi
movq %r15, %r... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googlemock/src/gmock.cc |
testing::internal::MaxBipartiteMatchState::TryAugment(unsigned long, std::vector<char, std::allocator<char>>*) | bool TryAugment(size_t ilhs, ::std::vector<char>* seen) {
for (size_t irhs = 0; irhs < graph_->RhsSize(); ++irhs) {
if ((*seen)[irhs]) continue;
if (!graph_->HasEdge(ilhs, irhs)) continue;
// There's an available edge from ilhs to irhs.
(*seen)[irhs] = 1;
// Next a search is performed ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rdi), %rax
movq 0x8(%rax), %rcx
testq %rcx, %rcx
setne %bpl
je 0x3914c
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
movq (%r15), %rdx
cmpb $0x0, (%rdx,%r12)
jne 0x39127
imulq %rbx, %rcx
addq 0x10(%rax), %rcx
cmpb $0x1, (%r12,%rcx)
jne 0x... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googlemock/src/gmock-matchers.cc |
testing::internal::ThreadLocal<testing::Sequence*>::CreateKey() | static pthread_key_t CreateKey() {
pthread_key_t key;
// When a thread exits, DeleteThreadLocalValue() will be called on
// the object managed for that thread.
GTEST_CHECK_POSIX_SUCCESS_(
pthread_key_create(&key, &DeleteThreadLocalValue));
return key;
} | pushq %rbx
subq $0x10, %rsp
leaq -0x617a(%rip), %rsi # 0x33828
leaq 0xc(%rsp), %rdi
callq 0x8920
testl %eax, %eax
je 0x39a15
movl %eax, %ebx
leaq 0x4d22(%rip), %rdx # 0x3e6db
leaq 0x8(%rsp), %rdi
movl $0x3, %esi
movl $0x706, %ecx # imm = 0x706
callq 0x27da0
movq 0x1b60c(%rip), %rdi # 0x54fe0
lea... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/include/gtest/internal/gtest-port.h |
testing::internal::ThreadLocal<testing::Sequence*>::ValueHolder* testing::internal::CheckedDowncastToActualType<testing::internal::ThreadLocal<testing::Sequence*>::ValueHolder, testing::internal::ThreadLocalValueHolderBase>(testing::internal::ThreadLocalValueHolderBase*) | Derived* CheckedDowncastToActualType(Base* base) {
#if GTEST_HAS_RTTI
GTEST_CHECK_(typeid(*base) == typeid(Derived));
#endif
#if GTEST_HAS_DOWNCAST_
return ::down_cast<Derived*>(base);
#elif GTEST_HAS_RTTI
return dynamic_cast<Derived*>(base); // NOLINT
#else
return static_cast<Derived*>(base); // Poor man's ... | pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x3a130
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x6cc2(%rip), %rax # 0x40d68
cmpq %rax, %rdi
je 0x3a0b4
cmpb $0x2a, (%rdi)
jne 0x3a0b8
xorl %eax, %eax
jmp 0x3a0c9
movb $0x1, %al
jmp 0x3a0c9
leaq 0x6ca9(%rip), %rsi # 0x40... | /jupp0r[P]prometheus-cpp/3rdparty/googletest/googletest/include/gtest/internal/gtest-port.h |
get_object_item | static cJSON *get_object_item(const cJSON * const object, const char * const name, const cJSON_bool case_sensitive)
{
cJSON *current_element = NULL;
if ((object == NULL) || (name == NULL))
{
return NULL;
}
current_element = object->child;
if (case_sensitive)
{
while ((curre... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x43d9
cmpq $0x0, -0x18(%rbp)
jne 0x43e6
movq $0x0, -0x8(%rbp)
jmp 0x44ac
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x1c... | /FSMaxB[P]cJSON/tests/../cJSON.c |
add_item_to_object | static cJSON_bool add_item_to_object(cJSON * const object, const char * const string, cJSON * const item, const internal_hooks * const hooks, const cJSON_bool constant_key)
{
char *new_key = NULL;
int new_type = cJSON_Invalid;
if ((object == NULL) || (string == NULL) || (item == NULL))
{
return... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq $0x0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4670
cmpq $0x0, -0x18(%rbp)
je 0x4670
cmpq $0x0, -0x20(%rbp)
jne 0x467c
movl $0x0, -0x4... | /FSMaxB[P]cJSON/tests/../cJSON.c |
cJSON_CreateString | CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string)
{
cJSON *item = cJSON_New_Item(&global_hooks);
if(item)
{
item->type = cJSON_String;
item->valuestring = (char*)cJSON_strdup((const unsigned char*)string, &global_hooks);
if(!item->valuestring)
{
cJSON_D... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0xb3c5(%rip), %rdi # 0x100c8
callq 0x3760
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4d59
movq -0x18(%rbp), %rax
movl $0x10, 0x18(%rax)
movq -0x10(%rbp), %rdi
leaq 0xb39f(%rip), %rsi # 0x100c8
callq 0x54b0
movq %rax, %rcx
movq -0x... | /FSMaxB[P]cJSON/tests/../cJSON.c |
cJSON_strdup | static unsigned char* cJSON_strdup(const unsigned char* string, const internal_hooks * const hooks)
{
size_t length = 0;
unsigned char *copy = NULL;
if (string == NULL)
{
return NULL;
}
length = strlen((const char*)string) + sizeof("");
copy = (unsigned char*)hooks->allocate(length... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x54e1
movq $0x0, -0x8(%rbp)
jmp 0x552d
movq -0x10(%rbp), %rdi
callq 0x30a0
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
m... | /FSMaxB[P]cJSON/tests/../cJSON.c |
parse_hex4_should_parse_mixed_case | static void parse_hex4_should_parse_mixed_case(void)
{
TEST_ASSERT_EQUAL_INT(0xBEEF, parse_hex4((const unsigned char*)"beef"));
TEST_ASSERT_EQUAL_INT(0xBEEF, parse_hex4((const unsigned char*)"beeF"));
TEST_ASSERT_EQUAL_INT(0xBEEF, parse_hex4((const unsigned char*)"beEf"));
TEST_ASSERT_EQUAL_INT(0xBEEF, ... | pushq %rbp
movq %rsp, %rbp
leaq 0x59f3(%rip), %rdi # 0xc2ae
callq 0x7970
movl %eax, %eax
movl %eax, %esi
movl $0xbeef, %edi # imm = 0xBEEF
xorl %eax, %eax
movl %eax, %edx
movl $0x31, %ecx
movl $0x14, %r8d
callq 0x9310
leaq 0x59cf(%rip), %rdi # 0xc2b3
callq 0x7970
movl %eax, %eax
movl %eax, %esi
movl... | /FSMaxB[P]cJSON/tests/parse_hex4.c |
UnityAssertEqualFloatArray | void UnityAssertEqualFloatArray(UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* expected,
UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* actual,
const UNITY_UINT32 num_elements,
const char* msg,
const UNITY_LI... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
cmp... | /FSMaxB[P]cJSON/tests/unity/src/unity.c |
UnityAssertFloatSpecial | void UnityAssertFloatSpecial(const UNITY_FLOAT actual,
const char* msg,
const UNITY_LINE_TYPE lineNumber,
const UNITY_FLOAT_TRAIT_T style)
{
const char* trait_names[] = {UnityStrInf, UnityStrNegInf, UnityStrNaN, UnityStrDet};
... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %fs:0x28, %rax
movq %rax, -0x8(%rbp)
movss %xmm0, -0x34(%rbp)
movq %rdi, -0x40(%rbp)
movq %rsi, -0x48(%rbp)
movl %edx, -0x4c(%rbp)
movq 0x5ff1(%rip), %rax # 0xfd70
movq %rax, -0x30(%rbp)
movq 0x5fee(%rip), %rax # 0xfd78
movq %rax, -0x28(%rbp)
movq 0x5feb(%rip),... | /FSMaxB[P]cJSON/tests/unity/src/unity.c |
main | int main(void) {
unsigned char pk[CRYPTO_PUBLICKEYBYTES] = {0};
unsigned char sk[CRYPTO_SECRETKEYBYTES] = {0};
const unsigned char message[50] = {0};
unsigned char omessage[sizeof(message)] = {0};
unsigned char sm[sizeof(message) + CRYPTO_BYTES] = {0};
int ret = ... | subq $0x1eee8, %rsp # imm = 0x1EEE8
movl $0x0, 0x1eee4(%rsp)
leaq 0x1eea0(%rsp), %rdi
xorl %esi, %esi
movl $0x41, %edx
callq 0x1060
leaq 0x1ee30(%rsp), %rdi
xorl %esi, %esi
movl $0x61, %edx
callq 0x1060
leaq 0x1edf0(%rsp), %rdi
xorl %esi, %esi
movl $0x32, %edx
callq 0x1060
leaq 0x1edb0(%rsp), %rdi
xorl %esi, %... | /IAIK[P]Picnic/tests/api_test.c |
embree::TutorialApplication::displayFunc() | void TutorialApplication::displayFunc()
{
double t0 = getSeconds();
const float time = g_motion_blur ? float(t0-time0) : (animate ? 0.5 * sinf(fabsf(float(t0-time0))) + 0.5 : render_time);
/* update camera */
camera.move(moveDelta.x*speed, moveDelta.y*speed, moveDelta.z*speed);
/* update ani... | pushq %r15
pushq %r14
pushq %rbx
subq $0x210, %rsp # imm = 0x210
movq %rdi, %rbx
callq 0xdc332
cmpb $0x1, 0x1a8ef5(%rip) # 0x1d1024
movsd %xmm0, 0x8(%rsp)
jne 0x28150
movsd 0x188(%rbx), %xmm2
movapd %xmm0, %xmm1
subsd %xmm2, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
jmp 0x2819e
cmpb $0x1, 0x1c0(%rbx)... | /embree[P]embree/tutorials/common/tutorial/tutorial.cpp |
progressStart | void progressStart()
{
progressDots = 0;
progressWidth = max(3,getTerminalWidth());
std::cout << "[" << std::flush;
} | pushq %rbx
xorl %eax, %eax
xchgq %rax, 0x1a80b1(%rip) # 0x1d1d98
callq 0xdc300
cmpl $0x4, %eax
movl $0x3, %ecx
cmovgel %eax, %ecx
movl %ecx, 0x1a8093(%rip) # 0x1d1d90
movq 0x1a72bc(%rip), %rbx # 0x1d0fc0
leaq 0x12b9c0(%rip), %rsi # 0x1556cb
movl $0x1, %edx
movq %rbx, %rdi
callq 0x17d70
movq %rbx, %rdi
popq ... | /embree[P]embree/tutorials/common/tutorial/tutorial.cpp |
embree::CommandLineParser::CommandLineOptionClosure<embree::TutorialApplication::TutorialApplication(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, int, int)::$_3>::~CommandLineOptionClosure() | CommandLineOptionClosure (std::string description, const F& f)
: CommandLineOption(description), f(f) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x1a1729(%rip), %rax # 0x1cb9f0
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x2a2dc
callq 0x17b20
movq %rbx, %rdi
popq %rbx
jmp 0x17b20
nop
| /embree[P]embree/tutorials/common/tutorial/application.h |
embree::CommandLineParser::CommandLineOptionClosure<embree::TutorialApplication::TutorialApplication(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, int, int)::$_9>::parse(embree::Ref<embree::ParseStream>, embree::FileName const&) | virtual void parse(Ref<ParseStream> cin, const FileName& path) {
f(cin,path);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rsi), %rbx
testq %rbx, %rbx
je 0x2a68c
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq 0x30(%r14), %r14
movq %rbx, %rdi
callq 0x33cfa
movss %xmm0, 0x110(%r14)
movb $0x1, 0x1c8(%r14)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
addq $0x8, %rsp
popq ... | /embree[P]embree/tutorials/common/tutorial/application.h |
embree::CommandLineParser::CommandLineOptionClosure<embree::TutorialApplication::TutorialApplication(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, int, int)::$_10>::~CommandLineOptionClosure() | CommandLineOptionClosure (std::string description, const F& f)
: CommandLineOption(description), f(f) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x1a1307(%rip), %rax # 0x1cb9f0
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x2a6fe
callq 0x17b20
movq %rbx, %rdi
popq %rbx
jmp 0x17b20
nop
| /embree[P]embree/tutorials/common/tutorial/application.h |
embree::CommandLineParser::CommandLineOptionClosure<embree::TutorialApplication::TutorialApplication(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, int, int)::$_14>::~CommandLineOptionClosure() | CommandLineOptionClosure (std::string description, const F& f)
: CommandLineOption(description), f(f) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x1a1107(%rip), %rax # 0x1cb9f0
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x2a8fe
callq 0x17b20
movq %rbx, %rdi
popq %rbx
jmp 0x17b20
nop
| /embree[P]embree/tutorials/common/tutorial/application.h |
embree::CommandLineParser::CommandLineOptionClosure<embree::TutorialApplication::TutorialApplication(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, int, int)::$_18>::~CommandLineOptionClosure() | CommandLineOptionClosure (std::string description, const F& f)
: CommandLineOption(description), f(f) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x1a0f0b(%rip), %rax # 0x1cb9f0
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x2aafa
callq 0x17b20
movq %rbx, %rdi
popq %rbx
jmp 0x17b20
nop
| /embree[P]embree/tutorials/common/tutorial/application.h |
embree::CommandLineParser::CommandLineOptionClosure<embree::TutorialApplication::TutorialApplication(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, int, int)::$_20>::~CommandLineOptionClosure() | CommandLineOptionClosure (std::string description, const F& f)
: CommandLineOption(description), f(f) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x1a0df7(%rip), %rax # 0x1cb9f0
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x2ac0e
callq 0x17b20
movq %rbx, %rdi
popq %rbx
jmp 0x17b20
nop
| /embree[P]embree/tutorials/common/tutorial/application.h |
embree::CommandLineParser::CommandLineOptionClosure<embree::TutorialApplication::TutorialApplication(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, int, int)::$_21>::~CommandLineOptionClosure() | CommandLineOptionClosure (std::string description, const F& f)
: CommandLineOption(description), f(f) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x1a0d55(%rip), %rax # 0x1cb9f0
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x2acb0
callq 0x17b20
movq %rbx, %rdi
popq %rbx
jmp 0x17b20
nop
| /embree[P]embree/tutorials/common/tutorial/application.h |
embree::CommandLineParser::CommandLineOptionClosure<embree::SceneLoadingTutorialApplication::SceneLoadingTutorialApplication(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)::$_38>::~CommandLineOptionClosure() | CommandLineOptionClosure (std::string description, const F& f)
: CommandLineOption(description), f(f) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x19fbd9(%rip), %rax # 0x1cb9f0
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x2be2c
callq 0x17b20
movq %rbx, %rdi
popq %rbx
jmp 0x17b20
nop
| /embree[P]embree/tutorials/common/tutorial/application.h |
embree::CommandLineParser::CommandLineOptionClosure<embree::SceneLoadingTutorialApplication::SceneLoadingTutorialApplication(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)::$_40>::~CommandLineOptionClosure() | CommandLineOptionClosure (std::string description, const F& f)
: CommandLineOption(description), f(f) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x19faad(%rip), %rax # 0x1cb9f0
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x2bf58
callq 0x17b20
movq %rbx, %rdi
popq %rbx
jmp 0x17b20
nop
| /embree[P]embree/tutorials/common/tutorial/application.h |
embree::CommandLineParser::CommandLineOptionClosure<embree::SceneLoadingTutorialApplication::SceneLoadingTutorialApplication(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)::$_6>::parse(embree::Ref<embree::ParseStream>, embree::FileName const&) | virtual void parse(Ref<ParseStream> cin, const FileName& path) {
f(cin,path);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %r14
movq (%rsi), %rbx
testq %rbx, %rbx
je 0x2d821
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq 0x30(%r14), %r14
leaq 0x24(%rsp), %rdi
movq %rbx, %rsi
callq 0x341b4
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x341b4
leaq 0x8(%rsp), %rd... | /embree[P]embree/tutorials/common/tutorial/application.h |
embree::CommandLineParser::CommandLineOptionClosure<embree::SceneLoadingTutorialApplication::SceneLoadingTutorialApplication(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)::$_13>::parse(embree::Ref<embree::ParseStream>, embree::FileName const&) | virtual void parse(Ref<ParseStream> cin, const FileName& path) {
f(cin,path);
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %r14
movq (%rsi), %rbx
testq %rbx, %rbx
je 0x2f69c
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq 0x30(%r14), %r14
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x341b4
movq %rbx, %rdi
callq 0x33cfa
movss %xmm0, 0xc(%rsp)
movq %rbx, %rdi
callq 0x1b056... | /embree[P]embree/tutorials/common/tutorial/application.h |
embree::CommandLineParser::CommandLineOptionClosure<embree::SceneLoadingTutorialApplication::SceneLoadingTutorialApplication(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)::$_14>::parse(embree::Ref<embree::ParseStream>, embree::FileName const&) | virtual void parse(Ref<ParseStream> cin, const FileName& path) {
f(cin,path);
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %r14
movq (%rsi), %rbx
testq %rbx, %rbx
je 0x2fa5c
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq 0x30(%r14), %r14
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x341b4
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x341b4
movq %rbx, %rdi
callq 0x33cfa
... | /embree[P]embree/tutorials/common/tutorial/application.h |
embree::CommandLineParser::CommandLineOptionClosure<embree::SceneLoadingTutorialApplication::SceneLoadingTutorialApplication(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)::$_20>::~CommandLineOptionClosure() | CommandLineOptionClosure (std::string description, const F& f)
: CommandLineOption(description), f(f) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x19a6d3(%rip), %rax # 0x1cb9f0
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x31332
callq 0x17b20
movq %rbx, %rdi
popq %rbx
jmp 0x17b20
nop
| /embree[P]embree/tutorials/common/tutorial/application.h |
embree::SceneGraph::GroupNode::bezier_to_bspline() | void bspline_to_bezier()
{
for (size_t i=0; i<children.size(); i++)
children[i] = convert_bspline_to_bezier(children[i]);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq 0x68(%rdi), %rax
cmpq %rax, 0x70(%rdi)
je 0x32dc4
movq %rdi, %rbx
xorl %r12d, %r12d
leaq 0x8(%rsp), %r14
movq %rsp, %r15
movq (%rax,%r12,8), %rdi
movq %rdi, (%rsp)
testq %rdi, %rdi
je 0x32d6c
movq (%rdi), %rax
callq *0x10(%rax)
movq %r14, %rdi... | /embree[P]embree/tutorials/common/tutorial/../scenegraph/scenegraph.h |
embree::CommandLineParser::CommandLineOptionClosure<embree::Application::Application(int)::$_0>::~CommandLineOptionClosure() | CommandLineOptionClosure (std::string description, const F& f)
: CommandLineOption(description), f(f) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x194a35(%rip), %rax # 0x1cb9f0
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x36fd0
callq 0x17b20
movq %rbx, %rdi
popq %rbx
jmp 0x17b20
nop
| /embree[P]embree/tutorials/common/tutorial/application.h |
embree::TutorialScene::materialID(embree::Ref<embree::SceneGraph::MaterialNode>) | unsigned TutorialScene::materialID(Ref<SceneGraph::MaterialNode> material)
{
if (material->id == -1) {
materials.push_back(material);
material->id = unsigned(materials.size()-1);
}
return material->id;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %rax
cmpl $-0x1, 0x5c(%rax)
jne 0x380ff
movq %rdi, %r14
addq $0x18, %rdi
movq %rbx, %rsi
callq 0x384f2
movq 0x20(%r14), %rax
subq 0x18(%r14), %rax
shrq $0x3, %rax
decl %eax
movq (%rbx), %rcx
movl %eax, 0x5c(%rcx)
movq (%rbx), %rax
movl 0x5c(%rax), %eax
addq ... | /embree[P]embree/tutorials/common/tutorial/scene.cpp |
embree::ISPCScene::convertLight(embree::Ref<embree::SceneGraph::LightNode>) | Light* ISPCScene::convertLight(Ref<SceneGraph::LightNode> in)
{
Light* l = createLight(in);
updateLight(in->get(0.0f),l);
return l;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r15
movq (%rdi), %r14
movq %r14, 0x8(%rsp)
testq %r14, %r14
je 0x39fd6
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
leaq 0x8(%rsp), %rdi
callq 0x3a0be
movq %rax, %rbx
testq %r14, %r14
je 0x39ff1
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq... | /embree[P]embree/tutorials/common/tutorial/scene_device.cpp |
embree::ISPCTriangleMesh::ISPCTriangleMesh(RTCDeviceTy*, embree::TutorialScene*, embree::Ref<embree::SceneGraph::TriangleMeshNode>) | ISPCTriangleMesh::ISPCTriangleMesh (RTCDevice device, TutorialScene* scene_in, Ref<SceneGraph::TriangleMeshNode> in)
: geom(TRIANGLE_MESH), positions(nullptr), normals(nullptr)
{
geom.geometry = rtcNewGeometry (device, RTC_GEOMETRY_TYPE_TRIANGLE);
positions = (Vec3fa**) alignedUSMMalloc(sizeof(Vec3fa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
movl $0x0, (%rdi)
movq $0x0, 0x8(%rdi)
movl $0xffffffff, 0x10(%rdi) # imm = 0xFFFFFFFF
movb $0x0, 0x14(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movq %rsi, %rdi
xorl %esi, %esi
callq 0x18... | /embree[P]embree/tutorials/common/tutorial/scene_device.cpp |
embree::getVec3f(char const*&) | static inline Vec3f getVec3f(const char*& token) {
float x = getFloat(token);
token += strspn(token, " \t");
if (*token == 0) return Vec3f(x);
float y = getFloat(token);
float z = getFloat(token);
return Vec3f(x,y,z);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
leaq 0x11766a(%rip), %r12 # 0x15661c
movq %r15, %rdi
movq %r12, %rsi
callq 0x17490
movq %rax, %r13
addq %r15, %r13
movq %r13, (%r14)
movq %r13, %rdi
callq 0x17ef0
cvtsd2ss %xmm0, %xmm0... | /embree[P]embree/tutorials/common/scenegraph/obj_loader.cpp |
embree::OBJLoader::loadMTL(embree::FileName const&) | void OBJLoader::loadMTL(const FileName &fileName)
{
std::ifstream cin;
cin.open(fileName.c_str());
if (!cin.is_open()) {
std::cerr << "cannot open " << fileName.str() << std::endl;
return;
}
std::string name;
ExtObjMaterial cur;
while (cin.peek() != -1)
{
/* load ne... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4c8, %rsp # imm = 0x4C8
movq %rsi, %rbx
movq %rdi, %r13
leaq 0x2c0(%rsp), %r14
movq %r14, %rdi
callq 0x17d60
movq (%rbx), %rsi
movq %r14, %rdi
movl $0x8, %edx
callq 0x176d0
leaq 0x338(%rsp), %rdi
callq 0x17210
testb %al, %al
je 0x409ac... | /embree[P]embree/tutorials/common/scenegraph/obj_loader.cpp |
embree::SceneGraph::TriangleMeshNode::TriangleMeshNode(embree::Ref<embree::SceneGraph::MaterialNode>, embree::BBox<float>, unsigned long) | TriangleMeshNode (Ref<MaterialNode> material, const BBox1f time_range = BBox1f(0,1), size_t numTimeSteps = 0)
: Node(true), time_range(time_range), material(material)
{
for (size_t i=0; i<numTimeSteps; i++)
positions.push_back(avector<Vertex>());
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r15
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x8(%rdi)
leaq 0x20(%rdi), %rcx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movb %al, 0x20(%rdi)
leaq 0x40(%rdi), %rcx
movq %rcx, 0x30(%rdi)
movq %rax, 0x38(%rdi)
movb %al, 0x40(%rdi)
movq ... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.h |
embree::MetalMaterial::MetalMaterial(embree::Vec3fa const&, embree::Vec3fa const&, embree::Vec3fa const&) | MetalMaterial (const Vec3fa& reflectance, const Vec3fa& eta, const Vec3fa& k)
: base(MATERIAL_REFLECTIVE_METAL), reflectance(reflectance), eta(eta), k(k), roughness(0.0f) {} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x112a1a(%rip), %rdx # 0x15661e
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %rdx, %rsi
callq 0x1e8d0
movq %r14, %rdi
movq ... | /embree[P]embree/tutorials/common/scenegraph/materials.h |
embree::MatteMaterial::~MatteMaterial() | struct PREFIX(MatteMaterial) MATERIAL_BASE_CLASS
{
#if !defined(ISPC) && !defined(CPPTUTORIAL)
MatteMaterial (const Vec3fa& reflectance)
: base(MATERIAL_MATTE), reflectance(reflectance) {}
virtual Material* material() { return &base; }
#endif
PREFIX(Material) base;
Vec3fa reflectance;
} | pushq %rbx
movq %rdi, %rbx
callq 0x34eac
movq %rbx, %rdi
callq 0xd8839
popq %rbx
retq
movq %rax, %rdi
callq 0x1a679
nop
| /embree[P]embree/tutorials/common/scenegraph/materials.h |
embree::SceneGraph::QuadMeshNode::calculateStatistics(embree::SceneGraph::Statistics&) | void SceneGraph::QuadMeshNode::calculateStatistics(Statistics& stat)
{
indegree++;
if (indegree == 1) {
stat.numQuadMeshes++;
stat.numQuads += numPrimitives();
stat.numQuadBytes += numBytes();
material->calculateStatistics(stat);
}
} | movq 0x50(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x50(%rdi)
testq %rax, %rax
je 0x48328
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
incq 0x18(%rsi)
movq (%rdi), %rax
callq *0x70(%rax)
addq %rax, 0x20(%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x70(%rax)
movq 0x70(%r14), %rcx
movq 0x78... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.cpp |
embree::SceneGraph::PointSetNode::calculateStatistics(embree::SceneGraph::Statistics&) | void SceneGraph::PointSetNode::calculateStatistics(Statistics& stat)
{
indegree++;
if (indegree == 1) {
stat.numCurveSets++;
stat.numCurves += numPrimitives();
stat.numCurveBytes += numBytes();
material->calculateStatistics(stat);
}
} | movq 0x50(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x50(%rdi)
testq %rax, %rax
je 0x48492
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
incq 0x48(%rsi)
movq (%rdi), %rax
callq *0x70(%rax)
addq %rax, 0x50(%rbx)
movq 0x78(%r14), %rax
movq 0x80(%r14), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
imulq 0... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.cpp |
embree::SceneGraph::calculateStatistics(embree::Ref<embree::SceneGraph::Node>) | SceneGraph::Statistics SceneGraph::calculateStatistics(Ref<Node> node)
{
SceneGraph::Statistics stat;
node->calculateStatistics(stat);
node->resetInDegree();
return stat;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0xb8, %edx
xorl %esi, %esi
callq 0x17600
movq (%rbx), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x48(%rax)
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /embree[P]embree/tutorials/common/scenegraph/scenegraph.cpp |
embree::SceneGraph::MultiTransformNode::calculateInDegree() | void SceneGraph::MultiTransformNode::calculateInDegree()
{
indegree++;
if (indegree == 1) {
child->calculateInDegree();
for (size_t i = 0; i < spaces.size(); ++i)
if (spaces[i].size() > 1) child->calculateInDegree(); // break instance up when motion blur is used
}
} | movq 0x50(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x50(%rdi)
testq %rax, %rax
je 0x48f1c
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x80(%rdi), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movq 0x68(%rbx), %rax
cmpq %rax, 0x70(%rbx)
je 0x48f84
movl $0x10, %r14d
xorl %r15d, %r15d
mo... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.cpp |
embree::SceneGraph::optimize_animation(embree::Ref<embree::SceneGraph::Node>) | void SceneGraph::optimize_animation(Ref<SceneGraph::Node> node)
{
if (Ref<SceneGraph::TransformNode> xfmNode = node.dynamicCast<SceneGraph::TransformNode>())
optimize_animation(xfmNode->child);
else if (Ref<SceneGraph::GroupNode> groupNode = node.dynamicCast<SceneGraph::GroupNode>())
{
for ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbp
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x4bf15
leaq 0x182436(%rip), %rsi # 0x1ce338
leaq 0x182637(%rip), %rdx # 0x1ce540
xorl %ecx, %ecx
callq 0x17d50
movq %rax, %rbx
jmp 0x4bf17
xorl %ebx, %ebx
testq %rbx, %rbx
je 0... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.cpp |
embree::SceneGraph::convert_triangles_to_quads(embree::Ref<embree::SceneGraph::Node>, float) | Ref<SceneGraph::Node> SceneGraph::convert_triangles_to_quads(Ref<SceneGraph::Node> node, float prop)
{
if (Ref<SceneGraph::TransformNode> xfmNode = node.dynamicCast<SceneGraph::TransformNode>()) {
xfmNode->child = convert_triangles_to_quads(xfmNode->child,prop);
}
else if (Ref<SceneGraph::MultiTran... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movss %xmm0, 0xc(%rsp)
movq %rsi, %r12
movq %rdi, %r15
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x4f21f
leaq 0x17f12c(%rip), %rsi # 0x1ce338
leaq 0x17f32d(%rip), %rdx # 0x1ce540
xorl %ecx, %ecx
callq 0x17d50
movq %rax, %rbx
jmp 0x4f22... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.cpp |
embree::SceneGraph::convert_quads_to_grids(embree::Ref<embree::SceneGraph::Node>, unsigned int, unsigned int) | Ref<SceneGraph::Node> SceneGraph::convert_quads_to_grids(Ref<SceneGraph::Node> node, const unsigned int resX, const unsigned int resY )
{
if (Ref<SceneGraph::TransformNode> xfmNode = node.dynamicCast<SceneGraph::TransformNode>()) {
xfmNode->child = convert_quads_to_grids(xfmNode->child, resX, resY);
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, %ebp
movl %edx, %r13d
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x4fbc5
leaq 0x17e786(%rip), %rsi # 0x1ce338
leaq 0x17e987(%rip), %rdx # 0x1ce540
xorl %ecx, %ecx
callq 0x17d50
movq %rax, %rbx
... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.cpp |
embree::SceneGraph::convert_grids_to_quads(embree::Ref<embree::SceneGraph::Node>) | Ref<SceneGraph::Node> SceneGraph::convert_grids_to_quads(Ref<SceneGraph::Node> node)
{
if (Ref<SceneGraph::TransformNode> xfmNode = node.dynamicCast<SceneGraph::TransformNode>()) {
xfmNode->child = convert_grids_to_quads(xfmNode->child);
}
else if (Ref<SceneGraph::MultiTransformNode> xfmNode = node.... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r12
movq %rdi, %r15
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x50277
leaq 0x17e0d4(%rip), %rsi # 0x1ce338
leaq 0x17e2d5(%rip), %rdx # 0x1ce540
xorl %ecx, %ecx
callq 0x17d50
movq %rax, %rbx
jmp 0x50279
xorl %ebx, %ebx
testq... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.cpp |
embree::SceneGraph::flatten(embree::Ref<embree::SceneGraph::GroupNode>, embree::SceneGraph::InstancingMode) | Ref<SceneGraph::GroupNode> SceneGraph::flatten(Ref<SceneGraph::GroupNode> node, SceneGraph::InstancingMode mode) {
return flatten(node.dynamicCast<SceneGraph::Node>(),mode).dynamicCast<SceneGraph::GroupNode>();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rdi, %r14
movq (%rsi), %rbx
movq %rbx, 0x8(%rsp)
testq %rbx, %rbx
je 0x54e0f
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movl %ebp, %edx
callq 0x54d46
movq 0x10(%rsp), %r15
testq %r15, %... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.cpp |
embree::SceneGraph::QuadMeshNode::QuadMeshNode(embree::Ref<embree::SceneGraph::MaterialNode>, embree::BBox<float>, unsigned long) | QuadMeshNode (Ref<MaterialNode> material, const BBox1f time_range = BBox1f(0,1), size_t numTimeSteps = 0 )
: Node(true), time_range(time_range), material(material)
{
for (size_t i=0; i<numTimeSteps; i++)
positions.push_back(avector<Vertex>());
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r15
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x8(%rdi)
leaq 0x20(%rdi), %rcx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movb %al, 0x20(%rdi)
leaq 0x40(%rdi), %rcx
movq %rcx, 0x30(%rdi)
movq %rax, 0x38(%rdi)
movb %al, 0x40(%rdi)
movq ... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.h |
embree::SceneGraph::AnimatedPerspectiveCameraNode::get(float) const | virtual PerspectiveCameraData get(float time) const
{
time = frac((time-time_range.lower)/time_range.size());
time = (cameras.size()-1)*time;
int itime = (int)floor(time);
itime = min(max(itime,0),(int)cameras.size()-2);
float ftime = time - (float)itime;
return l... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movss 0xb0(%rsi), %xmm2
movss 0xb4(%rsi), %xmm1
subss %xmm2, %xmm0
subss %xmm2, %xmm1
divss %xmm1, %xmm0
movss %xmm0, 0xc(%rsp)
callq 0x17420
movss 0xc(%rsp), %xmm1
subss %xmm0, %xmm1
movq 0xc0(%r14), %r12
movq 0xb8(%r14), %r15... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.h |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.