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(%rsp), %rdi
testq %rdi, %rdi
je 0x2b7aa
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2b7ca
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x8a20
|
/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(%rsp), %rdi
testq %rdi, %rdi
je 0x2bd8c
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2bdac
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x8a20
|
/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(%rsp), %rdi
testq %rdi, %rdi
je 0x2be0a
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2be2a
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x8a20
|
/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(death_test_use_fork);
fail_fast_ = GTEST_FLAG(fail_fast);
filter_ = GTEST_FLAG(filter);
internal_run_death_test_ = GTEST_FLAG(internal_run_death_test);
list_tests_ = GTEST_FLAG(list_tests);
output_ = GTEST_FLAG(output);
brief_ = GTEST_FLAG(brief);
print_time_ = GTEST_FLAG(print_time);
print_utf8_ = GTEST_FLAG(print_utf8);
random_seed_ = GTEST_FLAG(random_seed);
repeat_ = GTEST_FLAG(repeat);
shuffle_ = GTEST_FLAG(shuffle);
stack_trace_depth_ = GTEST_FLAG(stack_trace_depth);
stream_result_to_ = GTEST_FLAG(stream_result_to);
throw_on_failure_ = GTEST_FLAG(throw_on_failure);
}
|
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(%rsp)
movq %rcx, 0x28(%r13)
movq %rax, 0x30(%r13)
movb %al, 0x38(%r13)
leaq 0x50(%r13), %rcx
movq %rcx, (%rsp)
leaq 0x60(%r13), %rcx
movq %rcx, 0x18(%rsp)
movq %rcx, 0x50(%r13)
movq %rax, 0x58(%r13)
movb %al, 0x60(%r13)
leaq 0x70(%r13), %r12
leaq 0x80(%r13), %rcx
movq %rcx, 0x10(%rsp)
movq %rcx, 0x70(%r13)
movq %rax, 0x78(%r13)
movb %al, 0x80(%r13)
leaq 0x98(%r13), %rbp
leaq 0xa8(%r13), %r15
movq %r15, 0x98(%r13)
movq %rax, 0xa0(%r13)
movb %al, 0xa8(%r13)
leaq 0xd0(%r13), %rbx
leaq 0xe0(%r13), %r14
movq %r14, 0xd0(%r13)
movq %rax, 0xd8(%r13)
movb %al, 0xe0(%r13)
movb 0x29791(%rip), %al # 0x55aa3
movb %al, (%r13)
movb 0x29788(%rip), %al # 0x55aa4
movb %al, 0x1(%r13)
movb 0x2977f(%rip), %al # 0x55aa5
movb %al, 0x2(%r13)
leaq 0x29777(%rip), %rsi # 0x55aa8
movq %rdi, 0x30(%rsp)
callq 0x82a0
leaq 0x298be(%rip), %rsi # 0x55c00
movq 0x8(%rsp), %rdi
callq 0x82a0
movb 0x298ce(%rip), %al # 0x55c20
movb %al, 0x48(%r13)
movb 0x29746(%rip), %al # 0x55aa2
movb %al, 0x49(%r13)
leaq 0x29761(%rip), %rsi # 0x55ac8
movq (%rsp), %rdi
callq 0x82a0
leaq 0x29869(%rip), %rsi # 0x55be0
movq %r12, %rdi
callq 0x82a0
movb 0x29764(%rip), %al # 0x55ae9
movb %al, 0x90(%r13)
leaq 0x2975d(%rip), %rsi # 0x55af0
movq %rbp, %rdi
callq 0x82a0
movb 0x2976f(%rip), %al # 0x55b10
movb %al, 0xb8(%r13)
movb 0x29763(%rip), %al # 0x55b11
movb %al, 0xb9(%r13)
movb 0x29757(%rip), %al # 0x55b12
movb %al, 0xba(%r13)
movl 0x2974c(%rip), %eax # 0x55b14
movl %eax, 0xbc(%r13)
movl 0x29743(%rip), %eax # 0x55b18
movl %eax, 0xc0(%r13)
movb 0x2973b(%rip), %al # 0x55b1d
movb %al, 0xc4(%r13)
movl 0x29731(%rip), %eax # 0x55b20
movl %eax, 0xc8(%r13)
leaq 0x2972b(%rip), %rsi # 0x55b28
movq %rbx, %rdi
callq 0x82a0
movb 0x2973d(%rip), %al # 0x55b48
movb %al, 0xf0(%r13)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r13
movq (%rbx), %rdi
cmpq %r14, %rdi
je 0x2c431
callq 0x84a0
movq (%rbp), %rdi
cmpq %r15, %rdi
je 0x2c43f
callq 0x84a0
movq (%r12), %rdi
cmpq 0x10(%rsp), %rdi
je 0x2c44f
callq 0x84a0
movq (%rsp), %rax
movq (%rax), %rdi
cmpq 0x18(%rsp), %rdi
je 0x2c462
callq 0x84a0
movq 0x8(%rsp), %rax
movq (%rax), %rdi
cmpq 0x20(%rsp), %rdi
je 0x2c476
callq 0x84a0
movq 0x30(%rsp), %rax
movq (%rax), %rdi
cmpq 0x28(%rsp), %rdi
je 0x2c48a
callq 0x84a0
movq %r13, %rdi
callq 0x8a20
|
/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,%r12), %rdx
movq %rbx, %rdi
movq %r12, %rsi
callq 0xb728
movl %ebp, 0x28(%r14)
leaq 0x30(%r14), %rdi
movq %r15, %rsi
callq 0x28d10
leaq 0x50(%r14), %rdi
leaq 0x7(%rsp), %rdx
movq %r15, %rsi
callq 0x81f0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq 0x30(%r14), %rdi
addq $0x40, %r14
cmpq %r14, %rdi
je 0x2c940
callq 0x84a0
jmp 0x2c940
movq %rax, %r15
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x2c94d
callq 0x84a0
movq %r15, %rdi
callq 0x8a20
nop
|
/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 should be terminated.
kSkip // Skipped.
};
// C'tor. TestPartResult does NOT have a default constructor.
// Always use this constructor (with parameters) to create a
// TestPartResult object.
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) {}
// Gets the outcome of the test part.
Type type() const { return type_; }
// Gets the name of the source file where the test part took place, or
// NULL if it's unknown.
const char* file_name() const {
return file_name_.empty() ? nullptr : file_name_.c_str();
}
// Gets the line in the source file where the test part took place,
// or -1 if it's unknown.
int line_number() const { return line_number_; }
// Gets the summary of the failure message.
const char* summary() const { return summary_.c_str(); }
// Gets the message associated with the test part.
const char* message() const { return message_.c_str(); }
// Returns true if and only if the test part was skipped.
bool skipped() const { return type_ == kSkip; }
// Returns true if and only if the test part passed.
bool passed() const { return type_ == kSuccess; }
// Returns true if and only if the test part non-fatally failed.
bool nonfatally_failed() const { return type_ == kNonFatalFailure; }
// Returns true if and only if the test part fatally failed.
bool fatally_failed() const { return type_ == kFatalFailure; }
// Returns true if and only if the test part failed.
bool failed() const { return fatally_failed() || nonfatally_failed(); }
private:
Type type_;
// Gets the summary of the failure message by omitting the stack
// trace in it.
static std::string ExtractSummary(const char* message);
// The name of the source file where the test part took place, or
// "" if the source file is unknown.
std::string file_name_;
// The line in the source file where the test part took place, or -1
// if the line number is unknown.
int line_number_;
std::string summary_; // The test failure summary.
std::string message_; // The test failure message.
}
|
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(%rax)
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
testq %rbx, %rbx
je 0x2cbae
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r14, %rdi
callq 0x8a20
|
/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 0xad5e
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x2cc99
callq 0x84a0
movq %r14, %rdi
callq 0x8a20
nop
|
/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 file with a single "0" character in it. I/O
// errors are ignored as there's nothing better we can do and we
// don't want to fail the test because of this.
FILE* pfile = posix::FOpen(premature_exit_filepath, "w");
fwrite("0", 1, 1, pfile);
fclose(pfile);
}
}
|
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 0x13518(%rip), %rsi # 0x40229
movq %rbx, %rdi
callq 0x8650
movq %rax, %rbx
movl $0x30, %edi
movq %rax, %rsi
callq 0x86e0
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x84d0
popq %rbx
popq %r14
popq %r15
retq
|
/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_ << "\" with error "
<< retval;
}
}
#endif
}
|
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(%rip), %rdi # 0x54fe0
leaq 0x11b7a(%rip), %rsi # 0x3ea61
movl $0x2a, %edx
callq 0x85f0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x280e1(%rip), %rdi # 0x54fe0
callq 0x85f0
movq %rax, %r14
leaq 0x11b7e(%rip), %rsi # 0x3ea8c
movl $0xd, %edx
movq %rax, %rdi
callq 0x85f0
movq %r14, %rdi
movl %ebp, %esi
callq 0x89d0
leaq 0xc(%rsp), %rdi
callq 0x27ed2
movq (%rbx), %rdi
addq $0x10, %rbx
addq $0x10, %rsp
cmpq %rbx, %rdi
je 0x2cf48
popq %rbx
popq %r14
popq %rbp
jmp 0x84a0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rdi
callq 0x2acfd
nop
|
/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
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2d1d4
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rbx)
jmp 0x2d1e9
movq %rax, %r14
movq %r15, %rdi
callq 0x84a0
movq %r14, %rdi
callq 0x8a20
|
/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 $0x36, %edx
callq 0x85f0
movq 0x27bba(%rip), %rdi # 0x54fe0
leaq 0x1189d(%rip), %rsi # 0x3ecca
movl $0x14, %edx
callq 0x85f0
movq 0x27ba2(%rip), %rdi # 0x54fe0
movl %ebx, %esi
callq 0x89d0
movq %rax, %r14
leaq 0x11890(%rip), %rsi # 0x3ecdf
movl $0x12, %edx
movq %rax, %rdi
callq 0x85f0
movq %r14, %rdi
movl $0x1869f, %esi # imm = 0x1869F
callq 0x89d0
leaq 0x11882(%rip), %rsi # 0x3ecf2
movl $0x2, %edx
movq %rax, %rdi
callq 0x85f0
leaq 0x4(%rsp), %rdi
callq 0x27ed2
leal 0x1(%rbx), %ecx
cmpl $0x1869f, %ebx # imm = 0x1869F
movl $0x1, %eax
cmovll %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
callq 0x27ed2
movq %rbx, %rdi
callq 0x8a20
nop
|
/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
callq 0x85f0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d510
callq 0x84a0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2d535
callq 0x84a0
jmp 0x2d535
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2d543
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rbx)
jmp 0x2d557
movq %rax, %r14
movq %r15, %rdi
callq 0x84a0
movq %r14, %rdi
callq 0x8a20
nop
|
/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 <= end && end <= size)
<< "Invalid shuffle range finish " << end << ": must be in range ["
<< begin << ", " << size << "].";
// Fisher-Yates shuffle, from
// http://en.wikipedia.org/wiki/Fisher-Yates_shuffle
for (int range_width = end - begin; range_width >= 2; range_width--) {
const int last_in_range = begin + range_width - 1;
const int selected =
begin +
static_cast<int>(random->Generate(static_cast<uint32_t>(range_width)));
std::swap((*v)[static_cast<size_t>(selected)],
(*v)[static_cast<size_t>(last_in_range)]);
}
}
|
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 $0x3, %esi
movl $0x142, %ecx # imm = 0x142
callq 0x27da0
movq 0x279f1(%rip), %rdi # 0x54fe0
leaq 0x11c53(%rip), %rsi # 0x3f249
movl $0x2e, %edx
callq 0x85f0
movq 0x279d9(%rip), %rdi # 0x54fe0
leaq 0x11c6a(%rip), %rsi # 0x3f278
movl $0x1c, %edx
callq 0x85f0
movq 0x279c1(%rip), %rdi # 0x54fe0
movl %ebp, %esi
callq 0x89d0
movq %rax, %r13
leaq 0x11c65(%rip), %rsi # 0x3f295
movl $0x17, %edx
movq %rax, %rdi
callq 0x85f0
movq %r13, %rdi
movl %r15d, %esi
callq 0x89d0
leaq 0x116a3(%rip), %rsi # 0x3ecf2
movl $0x2, %edx
movq %rax, %rdi
callq 0x85f0
leaq 0x4(%rsp), %rdi
callq 0x27ed2
movl %r12d, %r13d
subl %ebp, %r13d
jl 0x2d677
cmpl %r12d, %r15d
jge 0x2d72e
leaq 0x1122e(%rip), %rdx # 0x3e8ac
movq %rsp, %rdi
movl $0x3, %esi
movl $0x145, %ecx # imm = 0x145
callq 0x27da0
movq 0x27949(%rip), %rdi # 0x54fe0
leaq 0x11c0f(%rip), %rsi # 0x3f2ad
movl $0x2e, %edx
callq 0x85f0
movq 0x27931(%rip), %rdi # 0x54fe0
leaq 0x11c26(%rip), %rsi # 0x3f2dc
movl $0x1d, %edx
callq 0x85f0
movq 0x27919(%rip), %rdi # 0x54fe0
movl %r12d, %esi
callq 0x89d0
movq %rax, %r12
leaq 0x11c21(%rip), %rsi # 0x3f2fa
movl $0x14, %edx
movq %rax, %rdi
callq 0x85f0
movq %r12, %rdi
movl %ebp, %esi
callq 0x89d0
movq %rax, %r12
leaq 0x12fcd(%rip), %rsi # 0x406c7
movl $0x2, %edx
movq %rax, %rdi
callq 0x85f0
movq %r12, %rdi
movl %r15d, %esi
callq 0x89d0
leaq 0x115d9(%rip), %rsi # 0x3ecf2
movl $0x2, %edx
movq %rax, %rdi
callq 0x85f0
movq %rsp, %rdi
callq 0x27ed2
cmpl $0x2, %r13d
jl 0x2d773
movl %r13d, %r15d
movslq %ebp, %rax
leaq -0x4(,%rax,4), %r12
movq %r14, %rdi
movl %r15d, %esi
callq 0xbaf6
addl %ebp, %eax
cltq
movq (%rbx), %rcx
leaq (%rcx,%r12), %rdx
movl (%rcx,%rax,4), %esi
movl (%rdx,%r15,4), %edi
movl %edi, (%rcx,%rax,4)
movl %esi, (%rdx,%r15,4)
leaq -0x1(%r15), %rax
cmpq $0x2, %r15
movq %rax, %r15
jg 0x2d742
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x4(%rsp), %rdi
jmp 0x2d792
movq %rax, %rbx
movq %rsp, %rdi
callq 0x27ed2
movq %rbx, %rdi
callq 0x8a20
|
/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;
bool remove_flag = false;
if (ParseGoogleTestFlag(arg)) {
remove_flag = true;
#if GTEST_USE_OWN_FLAGFILE_FLAG_
} else if (ParseStringFlag(arg, kFlagfileFlag, >EST_FLAG(flagfile))) {
LoadFlagsFromFile(GTEST_FLAG(flagfile));
remove_flag = true;
#endif // GTEST_USE_OWN_FLAGFILE_FLAG_
} else if (arg_string == "--help" || arg_string == "-h" ||
arg_string == "-?" || arg_string == "/?" ||
HasGoogleTestFlagPrefix(arg)) {
// Both help flag and unrecognized Google Test flags (excluding
// internal ones) trigger help display.
g_help_flag = true;
}
if (remove_flag) {
// Shift the remainder of the argv list left by one. Note
// that argv has (*argc + 1) elements, the last one always being
// NULL. The following loop moves the trailing NULL element as
// well.
for (int j = i; j != *argc; j++) {
argv[j] = argv[j + 1];
}
// Decrements the argument count.
(*argc)--;
// We also need to decrement the iterator as we just removed
// an element.
i--;
}
}
if (g_help_flag) {
// We print the help here instead of in RUN_ALL_TESTS(), as the
// latter may not be called at all if the user is using Google
// Test with another testing framework.
PrintColorEncoded(kColorEncodedHelpMessage);
}
}
|
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 %rbp, %rdi
callq 0x2a47d
testb %al, %al
jne 0x2d80e
movq %rbp, %rdi
leaq 0xe2f8(%rip), %rsi # 0x3baf1
leaq 0x28350(%rip), %rdx # 0x55b50
callq 0x2a6bf
testb %al, %al
je 0x2d83c
callq 0x2a701
movl (%r14), %eax
movl %eax, %ecx
subl %r13d, %ecx
je 0x2d832
movq (%rsp), %rdx
leaq (%rdx,%r12,8), %rdx
xorl %esi, %esi
movq (%rdx,%rsi,8), %rdi
movq %rdi, -0x8(%rdx,%rsi,8)
incq %rsi
cmpl %esi, %ecx
jne 0x2d822
decl %eax
movl %eax, (%r14)
decl %r13d
jmp 0x2d89b
movq %r15, %rdi
leaq 0x11ac9(%rip), %rsi # 0x3f30f
callq 0x8160
testl %eax, %eax
je 0x2d894
movq %r15, %rdi
leaq 0x11abd(%rip), %rsi # 0x3f316
callq 0x8160
testl %eax, %eax
je 0x2d894
movq %r15, %rdi
leaq 0x11aad(%rip), %rsi # 0x3f319
callq 0x8160
testl %eax, %eax
je 0x2d894
movq %r15, %rdi
leaq 0x11a9d(%rip), %rsi # 0x3f31c
callq 0x8160
testl %eax, %eax
je 0x2d894
movq %rbp, %rdi
callq 0x2a869
testb %al, %al
je 0x2d89b
movb $0x1, 0x28206(%rip) # 0x55aa1
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2d8af
callq 0x84a0
incl %r13d
cmpl (%r14), %r13d
jl 0x2d7cf
cmpb $0x0, 0x281df(%rip) # 0x55aa1
je 0x2d8c9
callq 0x2a8e5
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2d8ef
callq 0x84a0
movq %rbx, %rdi
callq 0x8a20
|
/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::InitializeSymbolizer(g_argvs[0].c_str());
#endif // GTEST_HAS_ABSL
ParseGoogleTestFlagsOnly(argc, argv);
GetUnitTestImpl()->PostFlagParsingInit();
}
|
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)
jle 0x2db13
movq %r13, (%rsp)
leaq 0x280d0(%rip), %rdi # 0x55b70
callq 0x33d56
cmpl $0x0, (%r14)
je 0x2daf6
leaq 0x18(%rsp), %rbp
xorl %ebx, %ebx
leaq 0x8(%rsp), %r15
leaq 0x280b2(%rip), %r12 # 0x55b70
movq (%rsp), %r13
movq %r15, %rdi
movq %r13, %rsi
callq 0x33c57
movq %r12, %rdi
movq %r15, %rsi
callq 0x31bda
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2dae7
callq 0x84a0
incq %rbx
movl (%r14), %eax
addq $0x8, %r13
cmpq %rax, %rbx
jne 0x2dac2
movq %r14, %rdi
movq (%rsp), %rsi
callq 0x2d79f
callq 0xbdbe
movq 0x280c2(%rip), %rdi # 0x55bd0
callq 0x1fea0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2db34
callq 0x84a0
movq %rbx, %rdi
callq 0x8a20
|
/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, %rdx
callq 0x28c2f
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x31357
callq 0x84a0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x9e27(%rip), %rsi # 0x3b191
movl $0x4, %edx
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x85f0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x31394
callq 0x84a0
movq %rbx, %rdi
callq 0x8a20
|
/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 downcast.
#endif
}
|
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(%rip), %rdx # 0x3e6db
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x45e, %ecx # imm = 0x45E
callq 0x27da0
movq 0x23458(%rip), %rdi # 0x54fe0
leaq 0xce9e(%rip), %rsi # 0x3ea2d
movl $0x33, %edx
callq 0x85f0
leaq 0xc(%rsp), %rdi
callq 0x27ed2
leaq 0x22b86(%rip), %rsi # 0x54730
leaq 0x22d0f(%rip), %rdx # 0x548c0
movq %rbx, %rdi
xorl %ecx, %ecx
addq $0x10, %rsp
popq %rbx
jmp 0x85e0
callq 0x8590
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x27ed2
movq %rbx, %rdi
callq 0x8a20
|
/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 # imm = 0x7FFFFF
setne %sil
testb %sil, %dl
je 0x32332
xorl %eax, %eax
retq
movl %eax, %edx
negl %edx
movl $0x80000000, %esi # imm = 0x80000000
movl %eax, %edi
orl %esi, %edi
testl %eax, %eax
cmovsl %edx, %edi
movl %ecx, %eax
negl %eax
orl %ecx, %esi
testl %ecx, %ecx
cmovsl %eax, %esi
movl %edi, %eax
subl %esi, %eax
negl %eax
subl %esi, %edi
cmovbl %eax, %edi
cmpl $0x5, %edi
setb %al
retq
nop
|
/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(%rsp), %rdi
testq %rdi, %rdi
je 0x3244c
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3246c
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x8a20
|
/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 %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x32544
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x8a20
|
/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 should be terminated.
kSkip // Skipped.
};
// C'tor. TestPartResult does NOT have a default constructor.
// Always use this constructor (with parameters) to create a
// TestPartResult object.
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) {}
// Gets the outcome of the test part.
Type type() const { return type_; }
// Gets the name of the source file where the test part took place, or
// NULL if it's unknown.
const char* file_name() const {
return file_name_.empty() ? nullptr : file_name_.c_str();
}
// Gets the line in the source file where the test part took place,
// or -1 if it's unknown.
int line_number() const { return line_number_; }
// Gets the summary of the failure message.
const char* summary() const { return summary_.c_str(); }
// Gets the message associated with the test part.
const char* message() const { return message_.c_str(); }
// Returns true if and only if the test part was skipped.
bool skipped() const { return type_ == kSkip; }
// Returns true if and only if the test part passed.
bool passed() const { return type_ == kSuccess; }
// Returns true if and only if the test part non-fatally failed.
bool nonfatally_failed() const { return type_ == kNonFatalFailure; }
// Returns true if and only if the test part fatally failed.
bool fatally_failed() const { return type_ == kFatalFailure; }
// Returns true if and only if the test part failed.
bool failed() const { return fatally_failed() || nonfatally_failed(); }
private:
Type type_;
// Gets the summary of the failure message by omitting the stack
// trace in it.
static std::string ExtractSummary(const char* message);
// The name of the source file where the test part took place, or
// "" if the source file is unknown.
std::string file_name_;
// The line in the source file where the test part took place, or -1
// if the line number is unknown.
int line_number_;
std::string summary_; // The test failure summary.
std::string message_; // The test failure message.
}
|
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, 0x8(%rdx)
movq $0x0, 0x10(%rdx)
movb $0x0, 0x18(%rdx)
movl 0x28(%rdx), %eax
movl %eax, 0x28(%rsi)
leaq 0x40(%rsi), %rcx
movq %rcx, 0x30(%rsi)
movq 0x30(%rdx), %rdi
leaq 0x40(%rdx), %rax
cmpq %rax, %rdi
je 0x328be
movq %rdi, 0x30(%rsi)
movq (%rax), %rcx
movq %rcx, 0x40(%rsi)
jmp 0x328c4
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x38(%rdx), %rcx
movq %rcx, 0x38(%rsi)
movq %rax, 0x30(%rdx)
movq $0x0, 0x38(%rdx)
movb $0x0, 0x40(%rdx)
leaq 0x60(%rsi), %rcx
movq %rcx, 0x50(%rsi)
movq 0x50(%rdx), %rdi
leaq 0x60(%rdx), %rax
cmpq %rax, %rdi
je 0x328fe
movq %rdi, 0x50(%rsi)
movq (%rax), %rcx
movq %rcx, 0x60(%rsi)
jmp 0x32904
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x58(%rdx), %rcx
movq %rcx, 0x58(%rsi)
movq %rax, 0x50(%rdx)
movq $0x0, 0x58(%rdx)
movb $0x0, 0x60(%rdx)
retq
nop
|
/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) = death_test_use_fork_;
GTEST_FLAG(filter) = filter_;
GTEST_FLAG(fail_fast) = fail_fast_;
GTEST_FLAG(internal_run_death_test) = internal_run_death_test_;
GTEST_FLAG(list_tests) = list_tests_;
GTEST_FLAG(output) = output_;
GTEST_FLAG(brief) = brief_;
GTEST_FLAG(print_time) = print_time_;
GTEST_FLAG(print_utf8) = print_utf8_;
GTEST_FLAG(random_seed) = random_seed_;
GTEST_FLAG(repeat) = repeat_;
GTEST_FLAG(shuffle) = shuffle_;
GTEST_FLAG(stack_trace_depth) = stack_trace_depth_;
GTEST_FLAG(stream_result_to) = stream_result_to_;
GTEST_FLAG(throw_on_failure) = throw_on_failure_;
}
|
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 # 0x55c00
callq 0x82a0
movb 0x48(%rbx), %al
movb %al, 0x22d5d(%rip) # 0x55c20
leaq 0x50(%rbx), %rsi
leaq 0x22bfa(%rip), %rdi # 0x55ac8
callq 0x82a0
movb 0x49(%rbx), %al
movb %al, 0x22bc6(%rip) # 0x55aa2
leaq 0x70(%rbx), %rsi
leaq 0x22cf9(%rip), %rdi # 0x55be0
callq 0x82a0
movb 0x90(%rbx), %al
movb %al, 0x22bf1(%rip) # 0x55ae9
leaq 0x98(%rbx), %rsi
leaq 0x22bea(%rip), %rdi # 0x55af0
callq 0x82a0
movb 0xb8(%rbx), %al
movb %al, 0x22bf9(%rip) # 0x55b10
movb 0xb9(%rbx), %al
movb %al, 0x22bee(%rip) # 0x55b11
movb 0xba(%rbx), %al
movb %al, 0x22be3(%rip) # 0x55b12
movl 0xbc(%rbx), %eax
movl %eax, 0x22bd9(%rip) # 0x55b14
movl 0xc0(%rbx), %eax
movl %eax, 0x22bd1(%rip) # 0x55b18
movb 0xc4(%rbx), %al
movb %al, 0x22bca(%rip) # 0x55b1d
movl 0xc8(%rbx), %eax
movl %eax, 0x22bc1(%rip) # 0x55b20
leaq 0xd0(%rbx), %rsi
leaq 0x22bbb(%rip), %rdi # 0x55b28
callq 0x82a0
movb 0xf0(%rbx), %al
movb %al, 0x22bca(%rip) # 0x55b48
movq 0xd0(%rbx), %rdi
leaq 0xe0(%rbx), %rax
cmpq %rax, %rdi
je 0x32f96
callq 0x84a0
movq 0x98(%rbx), %rdi
leaq 0xa8(%rbx), %rax
cmpq %rax, %rdi
je 0x32fae
callq 0x84a0
movq 0x70(%rbx), %rdi
leaq 0x80(%rbx), %rax
cmpq %rax, %rdi
je 0x32fc3
callq 0x84a0
movq 0x50(%rbx), %rdi
leaq 0x60(%rbx), %rax
cmpq %rax, %rdi
je 0x32fd5
callq 0x84a0
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x32fe7
callq 0x84a0
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x32ffa
popq %rbx
jmp 0x84a0
popq %rbx
retq
movq %rax, %rdi
callq 0x2acfd
|
/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
leaq 0xb953(%rip), %rsi # 0x3f1fe
movl $0x31, %edx
callq 0x85f0
movq 0x21724(%rip), %rdi # 0x54fe0
leaq 0xaec1(%rip), %rsi # 0x3e784
movl $0x12, %edx
callq 0x85f0
movq 0x2170c(%rip), %rdi # 0x54fe0
movl %ebx, %esi
callq 0x89d0
leaq 0x8(%rsp), %rdi
callq 0x27ed2
movl 0xc(%rsp), %eax
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x27ed2
movq %rbx, %rdi
callq 0x8a20
|
/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::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::MatchAndExplainImpl<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>>(testing::internal::MatcherBase<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&, testing::MatchResultListener*)
|
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::EqMatcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, false>>(testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&)
|
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 want to get their impl back when
// they call GetDescriber().
// We use std::get on a tuple as a workaround of not having `if constexpr`.
return std::get<(
std::is_convertible<decltype(&P::Get(m)),
const MatcherDescriberInterface*>::value
? 1
: 0)>(std::make_tuple(&m, &P::Get(m)));
}
|
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 0x85f0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x34194
callq 0x84a0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xbbc5(%rip), %rsi # 0x3fd69
movl $0xc, %edx
movq %rbx, %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x85f0
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x341cf
callq 0x84a0
movq %rbx, %rdi
callq 0x8a20
|
/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)
cmpl %r15d, %eax
cmovlel %r15d, %eax
movl %eax, 0xc(%rbx)
leaq 0x28(%rsp), %rdi
callq 0x8360
testl %ebp, %ebp
js 0x343b2
testl %r15d, %r15d
js 0x34430
cmpl %r15d, %ebp
jle 0x344c0
leaq 0x38(%rsp), %r12
leaq 0xc39b(%rip), %rsi # 0x406ca
movl $0x1c, %edx
movq %r12, %rdi
callq 0x85f0
movq %r12, %rdi
movl %r15d, %esi
callq 0x89d0
movq %rax, %r15
leaq 0xc396(%rip), %rsi # 0x406e7
movl $0x29, %edx
movq %rax, %rdi
callq 0x85f0
movq %r15, %rdi
movl %ebp, %esi
callq 0x89d0
leaq 0xbf55(%rip), %rsi # 0x402c4
movl $0x2, %edx
movq %rax, %rdi
callq 0x85f0
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x8930
callq 0x34798
movq (%rax), %r9
leaq 0xc282(%rip), %rdx # 0x4061c
leaq 0x8(%rsp), %r8
movq %rax, %rdi
xorl %esi, %esi
movl $0x43, %ecx
callq *0x10(%r9)
jmp 0x344ad
leaq 0x38(%rsp), %r15
leaq 0xc223(%rip), %rsi # 0x405e1
movl $0x29, %edx
movq %r15, %rdi
callq 0x85f0
leaq 0xc239(%rip), %rsi # 0x4060b
movl $0x10, %edx
movq %r15, %rdi
callq 0x85f0
movq %r15, %rdi
movl %ebp, %esi
callq 0x89d0
leaq 0x9790(%rip), %rsi # 0x3db80
movl $0x1, %edx
movq %rax, %rdi
callq 0x85f0
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x8930
callq 0x34798
movq (%rax), %r9
leaq 0xc201(%rip), %rdx # 0x4061c
leaq 0x8(%rsp), %r8
movq %rax, %rdi
xorl %esi, %esi
movl $0x3a, %ecx
callq *0x10(%r9)
jmp 0x344ad
leaq 0x38(%rsp), %r12
leaq 0xc264(%rip), %rsi # 0x406a0
movl $0x29, %edx
movq %r12, %rdi
callq 0x85f0
leaq 0xc1bb(%rip), %rsi # 0x4060b
movl $0x10, %edx
movq %r12, %rdi
callq 0x85f0
movq %r12, %rdi
movl %r15d, %esi
callq 0x89d0
leaq 0x9711(%rip), %rsi # 0x3db80
movl $0x1, %edx
movq %rax, %rdi
callq 0x85f0
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x8930
callq 0x34798
movq (%rax), %r9
leaq 0xc182(%rip), %rdx # 0x4061c
leaq 0x8(%rsp), %r8
movq %rax, %rdi
xorl %esi, %esi
movl $0x3e, %ecx
callq *0x10(%r9)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x344c0
callq 0x84a0
movq 0x20ab1(%rip), %rsi # 0x54f78
leaq 0x28(%rsp), %rdi
callq 0x83b0
leaq 0xa8(%rsp), %rdi
callq 0x8190
movq %rbx, (%r14)
movq %r14, %rdi
addq $0x8, %rdi
movq %rbx, %rsi
callq 0x38f02
movq %r14, %rax
addq $0x1b0, %rsp # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3452a
jmp 0x3452a
jmp 0x3452a
jmp 0x3450d
jmp 0x3450d
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3452d
callq 0x84a0
jmp 0x3452d
movq %rax, %r14
jmp 0x3454b
movq %rax, %r14
movq 0x20a44(%rip), %rsi # 0x54f78
leaq 0x28(%rsp), %rdi
callq 0x83b0
leaq 0xa8(%rsp), %rdi
callq 0x8190
movq %rbx, %rdi
callq 0x84a0
movq %r14, %rdi
callq 0x8a20
|
/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
// compilers.
static FailureReporterInterface* const failure_reporter =
new GoogleTestFailureReporter();
return failure_reporter;
}
|
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) # 0x55c90
leaq 0x214ba(%rip), %rdi # 0x55c98
callq 0x8320
jmp 0x347a3
movq %rax, %rbx
leaq 0x214a9(%rip), %rdi # 0x55c98
callq 0x8310
movq %rbx, %rdi
callq 0x8a20
|
/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 marker to make the warnings easily searchable.
std::cout << "\nGMOCK WARNING:";
}
// Pre-pends a new-line to message if it doesn't start with one.
if (message.empty() || message[0] != '\n') {
std::cout << "\n";
}
std::cout << message;
if (stack_frames_to_skip >= 0) {
#ifdef NDEBUG
// In opt mode, we have to be conservative and skip no stack frame.
const int actual_to_skip = 0;
#else
// In dbg mode, we can do what the caller tell us to do (plus one
// for skipping this function's stack frame).
const int actual_to_skip = stack_frames_to_skip + 1;
#endif // NDEBUG
// Appends a new-line to message if it doesn't end with one.
if (!message.empty() && *message.rbegin() != '\n') {
std::cout << "\n";
}
std::cout << "Stack trace:\n"
<< ::testing::internal::GetCurrentOsStackTraceExceptTop(
::testing::UnitTest::GetInstance(), actual_to_skip);
}
std::cout << ::std::flush;
}
|
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 0x85f0
cmpq $0x0, 0x8(%r14)
je 0x34890
movq (%r14), %rax
cmpb $0xa, (%rax)
je 0x348a8
movq 0x20721(%rip), %rdi # 0x54fb8
leaq 0x8f44(%rip), %rsi # 0x3d7e2
movl $0x1, %edx
callq 0x85f0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x20702(%rip), %rdi # 0x54fb8
callq 0x85f0
testl %ebx, %ebx
js 0x3493e
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x348ea
movq (%r14), %rcx
cmpb $0xa, -0x1(%rcx,%rax)
je 0x348ea
movq 0x206df(%rip), %rdi # 0x54fb8
leaq 0x8f02(%rip), %rsi # 0x3d7e2
movl $0x1, %edx
callq 0x85f0
movq 0x206c7(%rip), %rdi # 0x54fb8
leaq 0xb48e(%rip), %rsi # 0x3fd86
movl $0xd, %edx
callq 0x85f0
callq 0xbdbe
incl %ebx
movq %rsp, %rdi
movq %rax, %rsi
movl %ebx, %edx
callq 0x20bee
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x20692(%rip), %rdi # 0x54fb8
callq 0x85f0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3493e
callq 0x84a0
movq 0x20673(%rip), %rdi # 0x54fb8
callq 0x8340
leaq 0x2136f(%rip), %rdi # 0x55cc0
callq 0x2ed7c
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x34980
callq 0x84a0
jmp 0x34980
jmp 0x3497d
jmp 0x34994
jmp 0x3497d
movq %rax, %rbx
leaq 0x21339(%rip), %rdi # 0x55cc0
callq 0x2ed7c
movq %rbx, %rdi
callq 0x8a20
movq %rax, %rdi
callq 0x2acfd
|
/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) result += " " + JoinAsTuple(param_values);
return negation ? "not (" + result + ")" : result;
}
|
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 $0x1, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x85d0
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x34a90
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x34a97
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x20(%rsp), %rdi
callq 0x8170
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x34ad0
callq 0x84a0
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x34ae3
callq 0x84a0
testb %bl, %bl
je 0x34b2c
leaq 0xb3ad(%rip), %rsi # 0x3fe9b
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x2ab4b
leaq 0xb770(%rip), %rsi # 0x40272
movq %rsp, %rdi
callq 0x8af0
leaq 0x10(%r14), %rdx
movq %rdx, (%r14)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x34b4a
movq %rsi, (%r14)
movq (%rcx), %rdx
movq %rdx, 0x10(%r14)
jmp 0x34b50
leaq 0x10(%r14), %rax
movq %rax, (%r14)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0xad5e
jmp 0x34b67
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%r14)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
testb %bl, %bl
je 0x34b7e
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x34b7e
callq 0x84a0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x34b91
callq 0x84a0
movq %r14, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movb $0x1, %bl
jmp 0x34bef
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x34bbb
callq 0x84a0
jmp 0x34bbb
movq %rax, %r14
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x34bf1
callq 0x84a0
jmp 0x34bf1
movq %rax, %r14
jmp 0x34bf1
movq %rax, %r14
testb %bl, %bl
je 0x34bef
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x34bef
callq 0x84a0
testb %bl, %bl
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x34c04
callq 0x84a0
movq %r14, %rdi
callq 0x8a20
|
/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, (%rsi,%r8)
sete (%rsi,%r8)
leaq 0x1(%rsi), %rsi
jne 0x34c98
testb %dl, %dl
jne 0x34ccb
incq %rcx
cmpq (%rdi), %rcx
setb %al
jb 0x34c73
andb $0x1, %al
retq
|
/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) {
*os << "doesn't have " << Elements(1) << ", or has " << Elements(1)
<< " that ";
matcher_describers_[0]->DescribeNegationTo(os);
return;
}
*os << "doesn't have " << Elements(matcher_describers_.size())
<< ", or there exists no permutation of elements such that:\n";
break;
case UnorderedMatcherRequire::Superset:
*os << "no surjection from elements to requirements exists such that:\n";
break;
case UnorderedMatcherRequire::Subset:
*os << "no injection from elements to requirements exists such that:\n";
break;
}
const char* sep = "";
for (size_t i = 0; i != matcher_describers_.size(); ++i) {
*os << sep;
if (match_flags() == UnorderedMatcherRequire::ExactMatch) {
*os << " - element #" << i << " ";
} else {
*os << " - an element ";
}
matcher_describers_[i]->DescribeTo(os);
if (match_flags() == UnorderedMatcherRequire::ExactMatch) {
sep = ", and\n";
} else {
sep = "\n";
}
}
}
|
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), %rsi # 0x3ff9c
movl $0xd, %edx
movq %rbx, %rdi
callq 0x85f0
cmpq $0x8, %r15
jne 0x35307
leaq 0x8(%rsp), %r15
movl $0x1, %esi
movq %r15, %rdi
callq 0x38752
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0xf8b6
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x85f0
movq %rax, %r15
leaq 0x28(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x3515b
callq 0x84a0
leaq 0xae48(%rip), %rsi # 0x3ffaa
movl $0x9, %edx
movq %r15, %rdi
callq 0x85f0
leaq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x38752
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0xf8b6
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq %r15, %rdi
callq 0x85f0
movq %rax, %r15
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0x351b1
callq 0x84a0
leaq 0xadfc(%rip), %rsi # 0x3ffb4
movl $0x6, %edx
movq %r15, %rdi
callq 0x85f0
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x351d5
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x351e5
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%r14), %rax
movq (%rax), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x18(%rax)
jmp 0x352d6
leaq 0xae32(%rip), %rsi # 0x40033
movl $0x3d, %edx
jmp 0x35214
leaq 0xade5(%rip), %rsi # 0x3fff4
movl $0x3e, %edx
movq %rbx, %rdi
callq 0x85f0
movq 0x10(%r14), %rax
cmpq 0x8(%r14), %rax
je 0x352d6
leaq 0x85b2(%rip), %r12 # 0x3d7e3
xorl %r15d, %r15d
leaq 0x7f4c(%rip), %r13 # 0x3d187
leaq 0x85a0(%rip), %rbp # 0x3d7e2
movq %r12, %rdi
callq 0x8210
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x85f0
cmpl $0x3, (%r14)
jne 0x3528e
movl $0xc, %edx
movq %rbx, %rdi
leaq 0xad07(%rip), %rsi # 0x3ff74
callq 0x85f0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8330
movl $0x1, %edx
movq %rax, %rdi
leaq 0x7d7a(%rip), %rsi # 0x3d006
jmp 0x3529d
movl $0xe, %edx
movq %rbx, %rdi
leaq 0xace4(%rip), %rsi # 0x3ff81
callq 0x85f0
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
cmpl $0x3, (%r14)
movq %rbp, %r12
cmoveq %r13, %r12
incq %r15
movq 0x10(%r14), %rax
subq 0x8(%r14), %rax
sarq $0x3, %rax
cmpq %rax, %r15
jne 0x35242
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xaca4(%rip), %rsi # 0x3ff90
movl $0xb, %edx
movq %rbx, %rdi
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x85f0
movq 0x10(%r14), %rsi
subq 0x8(%r14), %rsi
sarq $0x3, %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x38752
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0xf8b6
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x85f0
movq %rax, %r15
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x35355
callq 0x84a0
leaq 0xac5f(%rip), %rsi # 0x3ffbb
movl $0x38, %edx
movq %r15, %rdi
callq 0x85f0
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x3521c
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x3521c
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0x353b5
callq 0x84a0
jmp 0x353b5
jmp 0x353d2
jmp 0x3539a
movq %rax, %rbx
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x353d5
callq 0x84a0
jmp 0x353d5
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x353c5
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x10(%rsp)
jmp 0x353d5
jmp 0x353d2
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x353e5
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x8a20
nop
|
/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 << sep << "\n ("
<< "element #" << it->first << ", "
<< "matcher #" << it->second << ")";
sep = ",";
}
os << "\n}";
}
|
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
leaq 0x8ec1(%rip), %rbp # 0x3e7b9
movq %r12, %rdi
callq 0x8210
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x85f0
movl $0x4, %edx
movq %rbx, %rdi
leaq 0xaf0b(%rip), %rsi # 0x40828
callq 0x85f0
movl $0x9, %edx
movq %rbx, %rdi
leaq 0xa646(%rip), %rsi # 0x3ff77
callq 0x85f0
movq (%r13), %rsi
movq %rbx, %rdi
callq 0x8330
movq %rax, %r12
movl $0x2, %edx
movq %rax, %rdi
leaq 0xad73(%rip), %rsi # 0x406c7
callq 0x85f0
movl $0x9, %edx
movq %r12, %rdi
leaq 0xa84e(%rip), %rsi # 0x401b6
callq 0x85f0
movq 0x8(%r13), %rsi
movq %r12, %rdi
callq 0x8330
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x85f0
addq $0x10, %r13
movq %rbp, %r12
cmpq 0x8(%r14), %r13
jne 0x358f8
leaq 0xae8c(%rip), %rsi # 0x4082d
movl $0x2, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x85f0
|
/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->immediate_prerequisites_.begin();
it != exp->immediate_prerequisites_.end(); ++it) {
const ExpectationBase* next = it->expectation_base().get();
if (!next->IsSatisfied()) return false;
expectations.push_back(next);
}
}
return true;
}
|
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(%rsp)
movq %rbx, (%rax)
movq %rcx, 0x8(%rsp)
cmpq %rcx, (%rsp)
sete %bl
je 0x35eb3
leaq 0x1fed9(%rip), %r14 # 0x55cf8
leaq 0x20(%rsp), %r12
movq -0x8(%rcx), %r15
addq $-0x8, %rcx
movq %rcx, 0x8(%rsp)
movq 0x68(%r15), %r13
addq $0x58, %r15
cmpq %r15, %r13
je 0x35ea1
movq 0x20(%r13), %rbp
movq %rbp, 0x20(%rsp)
movq %r14, %rdi
callq 0x38a5a
movl 0x80(%rbp), %esi
movq 0x40(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movl %eax, %ebp
testb %al, %al
je 0x35eb3
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x35e81
movq 0x20(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rsp)
jmp 0x35e8c
movq %rsp, %rdi
movq %r12, %rdx
callq 0x3987c
testb %bpl, %bpl
je 0x35eb3
movq %r13, %rdi
callq 0x8610
movq %rax, %r13
cmpq %r15, %rax
jne 0x35e3e
movq 0x8(%rsp), %rcx
cmpq %rcx, (%rsp)
sete %bl
jne 0x35e24
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x35ec1
callq 0x84a0
andb $0x1, %bl
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x35ee6
callq 0x84a0
movq %rbx, %rdi
callq 0x8a20
|
/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);
// Describes the state of the expectation (e.g. is it satisfied?
// is it active?).
*os << " - " << (IsOverSaturated() ? "over-saturated" :
IsSaturated() ? "saturated" :
IsSatisfied() ? "satisfied" : "unsatisfied")
<< " and "
<< (is_retired() ? "retired" : "active");
}
|
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 # 0x401da
movl $0x14, %edx
movq %rbx, %rdi
callq 0x85f0
movq %r15, %rdi
callq 0x38a5a
movl 0x80(%r14), %edi
movq %rbx, %rsi
callq 0x34140
leaq 0xa152(%rip), %rsi # 0x401ef
movl $0x3, %edx
movq %rbx, %rdi
callq 0x85f0
movq %r14, %rdi
callq 0x38b12
testb %al, %al
je 0x360bf
leaq 0xa136(%rip), %r15 # 0x401f3
jmp 0x3611a
leaq 0x1fc32(%rip), %rdi # 0x55cf8
callq 0x38a5a
movl 0x80(%r14), %esi
movq 0x40(%r14), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
testb %al, %al
je 0x360e9
leaq 0xa111(%rip), %r15 # 0x401f8
jmp 0x3611a
leaq 0x1fc08(%rip), %rdi # 0x55cf8
callq 0x38a5a
movl 0x80(%r14), %esi
movq 0x40(%r14), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
leaq 0xa0f7(%rip), %rcx # 0x40204
leaq 0xa0ee(%rip), %r15 # 0x40202
testb %al, %al
cmovneq %rcx, %r15
movq %r15, %rdi
callq 0x8210
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x85f0
leaq 0x6f38(%rip), %rsi # 0x3d06f
movl $0x5, %edx
movq %rbx, %rdi
callq 0x85f0
leaq 0x1fbad(%rip), %rdi # 0x55cf8
callq 0x38a5a
movzbl 0x84(%r14), %edx
leaq 0xa0af(%rip), %rax # 0x4020e
leaq 0xa0b0(%rip), %rsi # 0x40216
testq %rdx, %rdx
cmovneq %rax, %rsi
orq $0x6, %rdx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x85f0
|
/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,
".Times() cannot appear after "
".InSequence(), .WillOnce(), .WillRepeatedly(), "
"or .RetiresOnSaturation().");
}
last_clause_ = kTimes;
SpecifyCardinality(a_cardinality);
}
|
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), %ebp
movq 0x8(%r14), %r15
callq 0x34798
movq (%rax), %r9
movq %rsp, %r8
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
movl %ebp, %ecx
callq *0x10(%r9)
jmp 0x3650f
movq %r12, -0x10(%r12)
leaq 0x9ded(%rip), %rsi # 0x402c7
leaq 0x9e4c(%rip), %rdx # 0x4032d
movq %rsp, %rdi
callq 0xb728
cmpl $0x2, %ebp
jl 0x3650f
movl 0x10(%r14), %ebp
movq 0x8(%r14), %r15
callq 0x34798
movq (%rax), %r9
movq %rsp, %r8
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
movl %ebp, %ecx
callq *0x10(%r9)
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x3651d
callq 0x84a0
movl $0x2, 0xa4(%r14)
movb $0x1, 0x38(%r14)
movq (%rbx), %rax
movq %rax, 0x40(%r14)
addq $0x48, %r14
addq $0x8, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x39436
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3655d
jmp 0x36558
movq %rax, %rbx
jmp 0x3656e
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x3656e
callq 0x84a0
movq %rbx, %rdi
callq 0x8a20
|
/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);
break;
case kWarn:
Log(kWarning,
msg +
"\nNOTE: You can safely ignore the above warning unless this "
"call should not happen. Do not suppress it by blindly adding "
"an EXPECT_CALL() if you don't mean to enforce the call. "
"See "
"https://github.com/google/googletest/blob/master/docs/"
"gmock_cook_book.md#"
"knowing-when-to-expect for details.\n",
stack_frames_to_skip);
break;
default: // FAIL
Expect(false, nullptr, -1, msg);
}
}
|
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 %r14, %rsi
movl %ebx, %edx
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3483c
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xad5e
leaq 0x9d47(%rip), %rsi # 0x4032e
movq %r14, %rdi
callq 0x8af0
leaq 0x8(%rsp), %rsi
movl $0x1, %edi
movl %ebx, %edx
callq 0x3483c
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x3660f
callq 0x84a0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x34798
movq (%rax), %rcx
movq 0x10(%rcx), %r9
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
movq %r14, %r8
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%r9
jmp 0x36644
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x36656
callq 0x84a0
movq %rbx, %rdi
callq 0x8a20
|
/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 0x36753
movq %rax, %rbx
leaq 0x1f5b2(%rip), %rdi # 0x55cf8
callq 0x2ed7c
movq %rbx, %rdi
callq 0x8a20
movq %rax, %rdi
callq 0x2acfd
nop
|
/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 (untyped_expectation->IsOverSaturated()) {
// There was an upper-bound violation. Since the error was
// already reported when it occurred, there is no need to do
// anything here.
expectations_met = false;
} else if (!untyped_expectation->IsSatisfied()) {
expectations_met = false;
::std::stringstream ss;
ss << "Actual function call count doesn't match "
<< untyped_expectation->source_text() << "...\n";
// No need to show the source file location of the expectation
// in the description, as the Expect() call that follows already
// takes care of it.
untyped_expectation->MaybeDescribeExtraMatcherTo(&ss);
untyped_expectation->DescribeCallCountTo(&ss);
Expect(false, untyped_expectation->file(),
untyped_expectation->line(), ss.str());
}
}
// Deleting our expectations may trigger other mock objects to be deleted, for
// example if an action contains a reference counted smart pointer to that
// mock object, and that is the last reference. So if we delete our
// expectations within the context of the global mutex we may deadlock when
// this method is called again. Instead, make a copy of the set of
// expectations to delete, clear our set within the mutex, and then clear the
// copied set outside of it.
UntypedExpectations expectations_to_delete;
untyped_expectations_.swap(expectations_to_delete);
g_gmock_mutex.Unlock();
expectations_to_delete.clear();
g_gmock_mutex.Lock();
return expectations_met;
}
|
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), %r13
movq %r13, %rdi
callq 0x38b12
testb %al, %al
jne 0x37493
leaq 0x1e967(%rip), %rdi # 0x55cf8
callq 0x38a5a
movl 0x80(%r13), %esi
movq 0x40(%r13), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
testb %al, %al
jne 0x37496
leaq 0x20(%rsp), %rdi
callq 0x8360
movl $0x29, %edx
movq %r14, %rdi
leaq 0x91dc(%rip), %rsi # 0x405a4
callq 0x85f0
movq 0x18(%r13), %r12
testq %r12, %r12
je 0x373ee
movq %r12, %rdi
callq 0x8210
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x85f0
jmp 0x37407
movq 0x30(%rsp), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x50(%rsp,%rax), %esi
orl $0x1, %esi
callq 0x89b0
movl $0x4, %edx
movq %r14, %rdi
leaq 0x8e2c(%rip), %rsi # 0x40242
callq 0x85f0
movq (%r13), %rax
movq %r13, %rdi
movq %r14, %rsi
callq *0x10(%rax)
movq %r13, %rdi
movq %r14, %rsi
callq 0x36030
movq 0x8(%r13), %r12
movl 0x10(%r13), %r13d
movq %r15, %rdi
leaq 0x38(%rsp), %rsi
callq 0x8930
callq 0x34798
movq (%rax), %r9
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
movl %r13d, %ecx
movq %r15, %r8
callq *0x10(%r9)
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x37475
callq 0x84a0
leaq 0x20(%rsp), %rdi
movq 0x1daf7(%rip), %rsi # 0x54f78
callq 0x83b0
leaq 0xa0(%rsp), %rdi
callq 0x8190
xorl %r12d, %r12d
addq $0x10, %rbp
movq 0x38(%rbx), %rax
cmpq %rax, %rbp
jne 0x37376
jmp 0x374ac
movb $0x1, %r12b
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
xorl %ecx, %ecx
movq %rcx, 0x30(%rsp)
movq 0x30(%rbx), %rdx
movq 0x40(%rbx), %rsi
movq %rcx, 0x30(%rbx)
movq 0x28(%rsp), %rcx
movq %rcx, 0x38(%rbx)
movq 0x30(%rsp), %rcx
movq %rcx, 0x40(%rbx)
movq %rdx, 0x20(%rsp)
movq %rax, 0x28(%rsp)
movq %rsi, 0x30(%rsp)
leaq 0x1e809(%rip), %rdi # 0x55cf8
callq 0x2ed7c
movq 0x20(%rsp), %rbx
movq 0x28(%rsp), %r14
cmpq %rbx, %r14
je 0x37522
movq %rbx, %r15
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x37514
callq 0x393c6
addq $0x10, %r15
cmpq %r14, %r15
jne 0x37506
movq %rbx, 0x28(%rsp)
leaq 0x1e7cf(%rip), %rdi # 0x55cf8
callq 0x2ecde
leaq 0x20(%rsp), %rdi
callq 0x38c80
andb $0x1, %r12b
movl %r12d, %eax
addq $0x1a8, %rsp # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x38c80
jmp 0x3759b
jmp 0x3757a
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x3757d
callq 0x84a0
jmp 0x3757d
movq %rax, %rbx
movq 0x1d9f4(%rip), %rsi # 0x54f78
leaq 0x20(%rsp), %rdi
callq 0x83b0
leaq 0xa0(%rsp), %rdi
callq 0x8190
movq %rbx, %rdi
callq 0x8a20
|
/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
movq %rbx, %rdi
callq 0x8a20
movq %rax, %rdi
callq 0x2acfd
nop
|
/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 =
UnitTest::GetInstance()->current_test_info();
if (test_info != nullptr) {
state.first_used_test_suite = test_info->test_suite_name();
state.first_used_test = test_info->name();
}
}
}
|
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 0xbdbe
movq %rax, %rdi
callq 0x1f49e
movq %rax, %r14
testq %rax, %rax
je 0x37d84
movq (%r14), %r15
leaq 0x10(%rbx), %r12
movq 0x18(%rbx), %r13
movq %r15, %rdi
callq 0x8210
movq %r12, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %r15, %rcx
movq %rax, %r8
callq 0x8900
movq 0x20(%r14), %r14
movq %rbx, %r15
addq $0x30, %r15
movq 0x38(%rbx), %rbx
movq %r14, %rdi
callq 0x8210
movq %r15, %rdi
xorl %esi, %esi
movq %rbx, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x8900
leaq 0x1df6d(%rip), %rdi # 0x55cf8
callq 0x2ed7c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x37dba
jmp 0x37da3
movq %rax, %rbx
leaq 0x1df4b(%rip), %rdi # 0x55cf8
callq 0x2ed7c
movq %rbx, %rdi
callq 0x8a20
movq %rax, %rdi
callq 0x2acfd
|
/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, %rdi
movq %rax, %rsi
callq 0x39648
leaq 0x1dde5(%rip), %rdi # 0x55d30
callq 0x39fb6
movq %r14, (%rax)
movb $0x1, %al
movb %al, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x84a0
movq %rbx, %rdi
callq 0x8a20
|
/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
movq %rax, %rdi
callq 0x2acfd
|
/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_) {
*os << "called " << FormatTimes(min_);
} else if (max_ == INT_MAX) {
*os << "called at least " << FormatTimes(min_);
} else {
// 0 < min_ < max_ < INT_MAX
*os << "called between " << min_ << " and " << max_ << " times";
}
}
|
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 0x341d7
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x85f0
jmp 0x38173
cmpl $0x7fffffff, %eax # imm = 0x7FFFFFFF
je 0x38124
testl %eax, %eax
jne 0x3813f
leaq 0x7ce3(%rip), %rsi # 0x3fd69
movl $0xc, %edx
jmp 0x38130
cmpl $0x7fffffff, %eax # imm = 0x7FFFFFFF
jne 0x380d0
leaq 0x869e(%rip), %rsi # 0x4073c
movl $0x10, %edx
movq %rbx, %rdi
callq 0x85f0
movl 0x8(%r14), %esi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x341d7
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x85f0
jmp 0x38173
leaq 0x8676(%rip), %rsi # 0x4074d
movl $0xf, %edx
movq %rbx, %rdi
callq 0x85f0
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x89d0
movq %rax, %rbx
leaq 0x4f75(%rip), %rsi # 0x3d06f
movl $0x5, %edx
movq %rax, %rdi
callq 0x85f0
movl 0xc(%r14), %esi
movq %rbx, %rdi
callq 0x89d0
leaq 0x860b(%rip), %rsi # 0x40725
movl $0x6, %edx
movq %rax, %rdi
jmp 0x38133
leaq 0x85e6(%rip), %rsi # 0x40711
movl $0x1a, %edx
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
jmp 0x85f0
leaq 0x85e6(%rip), %rsi # 0x4072c
movl $0xf, %edx
movq %rbx, %rdi
callq 0x85f0
movl 0xc(%r14), %esi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x341d7
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x85f0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x38186
callq 0x84a0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x38192
jmp 0x38192
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x381a8
callq 0x84a0
movq %rbx, %rdi
callq 0x8a20
|
/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 false;
// Sets *value to the value of the flag.
*value = value_str;
return true;
}
|
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
movq %rax, %r8
callq 0x8900
testq %rbx, %rbx
setne %al
popq %rbx
popq %r14
popq %r15
retq
|
/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;
// Sets *value to the value of the flag.
return ParseInt32(Message() << "The value of flag --" << flag,
value_str, value);
}
|
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 $0x10, %rdi
leaq 0x872c(%rip), %rsi # 0x40a95
movl $0x15, %edx
callq 0x85f0
leaq 0x1d246(%rip), %rdx # 0x555c0
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x208d4
movl %eax, %ebx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x3839a
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x3839a
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x383b6
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x8a20
|
/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, %rdi
movq %r15, %rdx
callq 0x3904a
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3854a
callq 0x84a0
movq %r14, %rdi
callq 0x8a20
|
/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 0x38b4c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
|
/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 = StreamableToString(argv[i]);
const char* const arg = arg_string.c_str();
// Do we see a Google Mock flag?
if (ParseGoogleMockBoolFlag(arg, "catch_leaked_mocks",
&GMOCK_FLAG(catch_leaked_mocks)) ||
ParseGoogleMockStringFlag(arg, "verbose", &GMOCK_FLAG(verbose)) ||
ParseGoogleMockIntFlag(arg, "default_mock_behavior",
&GMOCK_FLAG(default_mock_behavior))) {
// Yes. Shift the remainder of the argv list left by one. Note
// that argv has (*argc + 1) elements, the last one always being
// NULL. The following loop moves the trailing NULL element as
// well.
for (int j = i; j != *argc; j++) {
argv[j] = argv[j + 1];
}
// Decrements the argument count.
(*argc)--;
// We also need to decrement the iterator as we just removed
// an element.
i--;
}
}
}
|
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, %rdi
callq 0x33c57
movq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x38290
testb %al, %al
jne 0x38da3
movq %r12, %rdi
callq 0x382ca
testb %al, %al
jne 0x38da3
movq %r12, %rdi
callq 0x3831a
testb %al, %al
je 0x38dcd
movl (%r14), %eax
movl %eax, %ecx
subl %ebp, %ecx
je 0x38dc6
movq (%rsp), %rdx
leaq (%rdx,%r13,8), %rdx
xorl %esi, %esi
movq (%rdx,%rsi,8), %rdi
movq %rdi, -0x8(%rdx,%rsi,8)
incq %rsi
cmpl %esi, %ecx
jne 0x38db6
decl %eax
movl %eax, (%r14)
decl %ebp
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x38de1
callq 0x84a0
incl %ebp
cmpl (%r14), %ebp
jne 0x38d6b
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x38e0e
callq 0x84a0
movq %rbx, %rdi
callq 0x8a20
|
/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 = StreamableToString(argv[i]);
const char* const arg = arg_string.c_str();
// Do we see a Google Mock flag?
if (ParseGoogleMockBoolFlag(arg, "catch_leaked_mocks",
&GMOCK_FLAG(catch_leaked_mocks)) ||
ParseGoogleMockStringFlag(arg, "verbose", &GMOCK_FLAG(verbose)) ||
ParseGoogleMockIntFlag(arg, "default_mock_behavior",
&GMOCK_FLAG(default_mock_behavior))) {
// Yes. Shift the remainder of the argv list left by one. Note
// that argv has (*argc + 1) elements, the last one always being
// NULL. The following loop moves the trailing NULL element as
// well.
for (int j = i; j != *argc; j++) {
argv[j] = argv[j + 1];
}
// Decrements the argument count.
(*argc)--;
// We also need to decrement the iterator as we just removed
// an element.
i--;
}
}
}
|
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, %rdi
callq 0x33cea
movq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x38290
testb %al, %al
jne 0x38e8d
movq %r12, %rdi
callq 0x382ca
testb %al, %al
jne 0x38e8d
movq %r12, %rdi
callq 0x3831a
testb %al, %al
je 0x38eb7
movl (%r14), %eax
movl %eax, %ecx
subl %ebp, %ecx
je 0x38eb0
movq (%rsp), %rdx
leaq (%rdx,%r13,8), %rdx
xorl %esi, %esi
movq (%rdx,%rsi,8), %rdi
movq %rdi, -0x8(%rdx,%rsi,8)
incq %rsi
cmpl %esi, %ecx
jne 0x38ea0
decl %eax
movl %eax, (%r14)
decl %ebp
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x38ecb
callq 0x84a0
incl %ebp
cmpl (%r14), %ebp
jne 0x38e55
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x38ef8
callq 0x84a0
movq %rbx, %rdi
callq 0x8a20
|
/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 to determine whether
// this edge is a dead end or leads to the sink.
//
// right_[irhs] == kUnused means that there is residual flow from
// right node irhs to the sink, so we can use that to finish this
// flow path and return success.
//
// Otherwise there is residual flow to some ilhs. We push flow
// along that path and call ourselves recursively to see if this
// ultimately leads to sink.
if (right_[irhs] == kUnused || TryAugment(right_[irhs], seen)) {
// Add flow from left_[ilhs] to right_[irhs].
left_[ilhs] = irhs;
right_[irhs] = ilhs;
return true;
}
}
return false;
}
|
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 0x39127
movb $0x1, (%rdx,%r12)
movq 0x20(%r14), %rax
movq (%rax,%r12,8), %rsi
cmpq $-0x1, %rsi
je 0x3913c
movq %r14, %rdi
movq %r15, %rdx
callq 0x390c8
testb %al, %al
jne 0x3913c
incq %r12
movq (%r14), %rax
movq 0x8(%rax), %rcx
cmpq %rcx, %r12
setb %bpl
jb 0x390ec
jmp 0x3914c
movq 0x8(%r14), %rax
movq %r12, (%rax,%rbx,8)
movq 0x20(%r14), %rax
movq %rbx, (%rax,%r12,8)
andb $0x1, %bpl
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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
leaq 0x5823(%rip), %rsi # 0x3f1fe
movl $0x31, %edx
callq 0x85f0
movq 0x1b5f4(%rip), %rdi # 0x54fe0
leaq 0x4d91(%rip), %rsi # 0x3e784
movl $0x12, %edx
callq 0x85f0
movq 0x1b5dc(%rip), %rdi # 0x54fe0
movl %ebx, %esi
callq 0x89d0
leaq 0x8(%rsp), %rdi
callq 0x27ed2
movl 0xc(%rsp), %eax
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x27ed2
movq %rbx, %rdi
callq 0x8a20
|
/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 downcast.
#endif
}
|
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 # 0x40d68
callq 0x87f0
testl %eax, %eax
sete %al
movzbl %al, %edi
callq 0xbc5c
testb %al, %al
jne 0x3a112
leaq 0x45ff(%rip), %rdx # 0x3e6db
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x45e, %ecx # imm = 0x45E
callq 0x27da0
movq 0x1aee9(%rip), %rdi # 0x54fe0
leaq 0x492f(%rip), %rsi # 0x3ea2d
movl $0x33, %edx
callq 0x85f0
leaq 0xc(%rsp), %rdi
callq 0x27ed2
leaq 0x1a617(%rip), %rsi # 0x54730
leaq 0x1ac28(%rip), %rdx # 0x54d48
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x85e0
addq $0x10, %rsp
popq %rbx
retq
callq 0x8590
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x27ed2
movq %rbx, %rdi
callq 0x8a20
|
/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 ((current_element != NULL) && (current_element->string != NULL) && (strcmp(name, current_element->string) != 0))
{
current_element = current_element->next;
}
}
else
{
while ((current_element != NULL) && (case_insensitive_strcmp((const unsigned char*)name, (const unsigned char*)(current_element->string)) != 0))
{
current_element = current_element->next;
}
}
if ((current_element == NULL) || (current_element->string == NULL)) {
return NULL;
}
return current_element;
}
|
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(%rbp)
je 0x4448
jmp 0x43fa
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x29(%rbp)
je 0x4430
movq -0x28(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x38(%rcx)
movb %al, -0x29(%rbp)
je 0x4430
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x30e0
cmpl $0x0, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x4439
jmp 0x4446
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x43fa
jmp 0x4488
jmp 0x444a
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x2a(%rbp)
je 0x4470
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x38(%rax), %rsi
callq 0x8760
cmpl $0x0, %eax
setne %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
testb $0x1, %al
jne 0x4479
jmp 0x4486
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x444a
jmp 0x4488
cmpq $0x0, -0x28(%rbp)
je 0x449a
movq -0x28(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x44a4
movq $0x0, -0x8(%rbp)
jmp 0x44ac
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/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 false;
}
if (constant_key)
{
new_key = (char*)cast_away_const(string);
new_type = item->type | cJSON_StringIsConst;
}
else
{
new_key = (char*)cJSON_strdup((const unsigned char*)string, hooks);
if (new_key == NULL)
{
return false;
}
new_type = item->type & ~cJSON_StringIsConst;
}
if (!(item->type & cJSON_StringIsConst) && (item->string != NULL))
{
hooks->deallocate(item->string);
}
item->string = new_key;
item->type = new_type;
return add_item_to_array(object, item);
}
|
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(%rbp)
jmp 0x4724
cmpl $0x0, -0x2c(%rbp)
je 0x46a0
movq -0x18(%rbp), %rdi
callq 0x5590
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
orl $0x200, %eax # imm = 0x200
movl %eax, -0x3c(%rbp)
jmp 0x46d0
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x54b0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x46c1
movl $0x0, -0x4(%rbp)
jmp 0x4724
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
andl $0xfffffdff, %eax # imm = 0xFFFFFDFF
movl %eax, -0x3c(%rbp)
movq -0x20(%rbp), %rax
movl 0x18(%rax), %eax
andl $0x200, %eax # imm = 0x200
cmpl $0x0, %eax
jne 0x46fe
movq -0x20(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x46fe
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x38(%rcx), %rdi
callq *%rax
movq -0x38(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x38(%rax)
movl -0x3c(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x4560
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
|
/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_Delete(item);
return NULL;
}
}
return item;
}
|
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 -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x4d57
movq -0x18(%rbp), %rdi
callq 0x3430
movq $0x0, -0x8(%rbp)
jmp 0x4d61
jmp 0x4d59
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
|
/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);
if (copy == NULL)
{
return NULL;
}
memcpy(copy, string, length);
return copy;
}
|
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
movq -0x20(%rbp), %rdi
callq *%rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x5514
movq $0x0, -0x8(%rbp)
jmp 0x552d
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x3100
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
|
/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, 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, 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, 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, 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, parse_hex4((const unsigned char*)"BEEF"));
}
|
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 $0xbeef, %edi # imm = 0xBEEF
xorl %eax, %eax
movl %eax, %edx
movl $0x32, %ecx
movl $0x14, %r8d
callq 0x9310
leaq 0x59ab(%rip), %rdi # 0xc2b8
callq 0x7970
movl %eax, %eax
movl %eax, %esi
movl $0xbeef, %edi # imm = 0xBEEF
xorl %eax, %eax
movl %eax, %edx
movl $0x33, %ecx
movl $0x14, %r8d
callq 0x9310
leaq 0x5987(%rip), %rdi # 0xc2bd
callq 0x7970
movl %eax, %eax
movl %eax, %esi
movl $0xbeef, %edi # imm = 0xBEEF
xorl %eax, %eax
movl %eax, %edx
movl $0x34, %ecx
movl $0x14, %r8d
callq 0x9310
leaq 0x5963(%rip), %rdi # 0xc2c2
callq 0x7970
movl %eax, %eax
movl %eax, %esi
movl $0xbeef, %edi # imm = 0xBEEF
xorl %eax, %eax
movl %eax, %edx
movl $0x35, %ecx
movl $0x14, %r8d
callq 0x9310
leaq 0x593f(%rip), %rdi # 0xc2c7
callq 0x7970
movl %eax, %eax
movl %eax, %esi
movl $0xbeef, %edi # imm = 0xBEEF
xorl %eax, %eax
movl %eax, %edx
movl $0x36, %ecx
movl $0x14, %r8d
callq 0x9310
leaq 0x591b(%rip), %rdi # 0xc2cc
callq 0x7970
movl %eax, %eax
movl %eax, %esi
movl $0xbeef, %edi # imm = 0xBEEF
xorl %eax, %eax
movl %eax, %edx
movl $0x37, %ecx
movl $0x14, %r8d
callq 0x9310
leaq 0x58f7(%rip), %rdi # 0xc2d1
callq 0x7970
movl %eax, %eax
movl %eax, %esi
movl $0xbeef, %edi # imm = 0xBEEF
xorl %eax, %eax
movl %eax, %edx
movl $0x38, %ecx
movl $0x14, %r8d
callq 0x9310
leaq 0x58d3(%rip), %rdi # 0xc2d6
callq 0x7970
movl %eax, %eax
movl %eax, %esi
movl $0xbeef, %edi # imm = 0xBEEF
xorl %eax, %eax
movl %eax, %edx
movl $0x39, %ecx
movl $0x14, %r8d
callq 0x9310
leaq 0x58af(%rip), %rdi # 0xc2db
callq 0x7970
movl %eax, %eax
movl %eax, %esi
movl $0xbeef, %edi # imm = 0xBEEF
xorl %eax, %eax
movl %eax, %edx
movl $0x3a, %ecx
movl $0x14, %r8d
callq 0x9310
leaq 0x588b(%rip), %rdi # 0xc2e0
callq 0x7970
movl %eax, %eax
movl %eax, %esi
movl $0xbeef, %edi # imm = 0xBEEF
xorl %eax, %eax
movl %eax, %edx
movl $0x3b, %ecx
movl $0x14, %r8d
callq 0x9310
leaq 0x5867(%rip), %rdi # 0xc2e5
callq 0x7970
movl %eax, %eax
movl %eax, %esi
movl $0xbeef, %edi # imm = 0xBEEF
xorl %eax, %eax
movl %eax, %edx
movl $0x3c, %ecx
movl $0x14, %r8d
callq 0x9310
leaq 0x5843(%rip), %rdi # 0xc2ea
callq 0x7970
movl %eax, %eax
movl %eax, %esi
movl $0xbeef, %edi # imm = 0xBEEF
xorl %eax, %eax
movl %eax, %edx
movl $0x3d, %ecx
movl $0x14, %r8d
callq 0x9310
leaq 0x581f(%rip), %rdi # 0xc2ef
callq 0x7970
movl %eax, %eax
movl %eax, %esi
movl $0xbeef, %edi # imm = 0xBEEF
xorl %eax, %eax
movl %eax, %edx
movl $0x3e, %ecx
movl $0x14, %r8d
callq 0x9310
leaq 0x57fb(%rip), %rdi # 0xc2f4
callq 0x7970
movl %eax, %eax
movl %eax, %esi
movl $0xbeef, %edi # imm = 0xBEEF
xorl %eax, %eax
movl %eax, %edx
movl $0x3f, %ecx
movl $0x14, %r8d
callq 0x9310
leaq 0x57d7(%rip), %rdi # 0xc2f9
callq 0x7970
movl %eax, %eax
movl %eax, %esi
movl $0xbeef, %edi # imm = 0xBEEF
xorl %eax, %eax
movl %eax, %edx
movl $0x40, %ecx
movl $0x14, %r8d
callq 0x9310
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/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_LINE_TYPE lineNumber,
const UNITY_FLAGS_T flags)
{
UNITY_UINT32 elements = num_elements;
UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* ptr_expected = expected;
UNITY_PTR_ATTRIBUTE const UNITY_FLOAT* ptr_actual = actual;
RETURN_IF_FAIL_OR_IGNORE;
if (elements == 0)
{
UnityPrintPointlessAndBail();
}
if (expected == actual) return; /* Both are NULL or same pointer */
if (UnityIsOneArrayNull((UNITY_INTERNAL_PTR)expected, (UNITY_INTERNAL_PTR)actual, lineNumber, msg))
UNITY_FAIL_AND_BAIL;
while (elements--)
{
if (!UnityFloatsWithin(*ptr_expected * UNITY_FLOAT_PRECISION, *ptr_expected, *ptr_actual))
{
UnityTestResultsFailBegin(lineNumber);
UnityPrint(UnityStrElement);
UnityPrintNumberUnsigned(num_elements - elements - 1);
UNITY_PRINT_EXPECTED_AND_ACTUAL_FLOAT((UNITY_DOUBLE)*ptr_expected, (UNITY_DOUBLE)*ptr_actual);
UnityAddMsgIfSpecified(msg);
UNITY_FAIL_AND_BAIL;
}
if (flags == UNITY_ARRAY_TO_ARRAY)
{
ptr_expected++;
}
ptr_actual++;
}
}
|
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)
cmpq $0x0, 0x687b(%rip) # 0x10148
jne 0x98d9
cmpq $0x0, 0x6879(%rip) # 0x10150
je 0x98de
jmp 0x9a5c
cmpl $0x0, -0x30(%rbp)
jne 0x9922
movq -0x28(%rbp), %rdi
callq 0x9250
leaq 0x2b4c(%rip), %rdi # 0xc440
callq 0x8870
movq -0x20(%rbp), %rdi
callq 0x9290
movq $0x1, 0x683b(%rip) # 0x10148
leaq 0x67f4(%rip), %rdi # 0x10108
addq $0x50, %rdi
movl $0x1, %esi
callq 0x3140
movq -0x8(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x9931
jmp 0x9a5c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x97f0
cmpl $0x0, %eax
je 0x996b
movq $0x1, 0x67f2(%rip) # 0x10148
leaq 0x67ab(%rip), %rdi # 0x10108
addq $0x50, %rdi
movl $0x1, %esi
callq 0x3140
jmp 0x996d
movl -0x30(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x30(%rbp)
cmpl $0x0, %eax
je 0x9a5c
movq -0x38(%rbp), %rax
movss 0x29ab(%rip), %xmm0 # 0xc338
mulss (%rax), %xmm0
movq -0x38(%rbp), %rax
movss (%rax), %xmm1
movq -0x40(%rbp), %rax
movss (%rax), %xmm2
callq 0x9a70
cmpl $0x0, %eax
jne 0x9a39
movq -0x28(%rbp), %rdi
callq 0x9250
leaq 0x2ab8(%rip), %rdi # 0xc477
callq 0x8870
movl -0x14(%rbp), %eax
subl -0x30(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x8b90
leaq 0x2a06(%rip), %rdi # 0xc3e3
callq 0x8870
movq -0x38(%rbp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x8c90
leaq 0x29f4(%rip), %rdi # 0xc3ee
callq 0x8870
movq -0x40(%rbp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x8c90
movq -0x20(%rbp), %rdi
callq 0x9290
movq $0x1, 0x6724(%rip) # 0x10148
leaq 0x66dd(%rip), %rdi # 0x10108
addq $0x50, %rdi
movl $0x1, %esi
callq 0x3140
cmpl $0x1, -0x2c(%rbp)
jne 0x9a4b
movq -0x38(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x40(%rbp)
jmp 0x996d
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
|
/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};
UNITY_INT should_be_trait = ((UNITY_INT)style & 1);
UNITY_INT is_trait = !should_be_trait;
UNITY_INT trait_index = (UNITY_INT)(style >> 1);
RETURN_IF_FAIL_OR_IGNORE;
switch (style)
{
case UNITY_FLOAT_IS_INF:
case UNITY_FLOAT_IS_NOT_INF:
is_trait = isinf(actual) && (actual > 0);
break;
case UNITY_FLOAT_IS_NEG_INF:
case UNITY_FLOAT_IS_NOT_NEG_INF:
is_trait = isinf(actual) && (actual < 0);
break;
case UNITY_FLOAT_IS_NAN:
case UNITY_FLOAT_IS_NOT_NAN:
is_trait = isnan(actual) ? 1 : 0;
break;
case UNITY_FLOAT_IS_DET: /* A determinate number is non infinite and not NaN. */
case UNITY_FLOAT_IS_NOT_DET:
is_trait = !isinf(actual) && !isnan(actual);
break;
default:
trait_index = 0;
trait_names[0] = UnityStrInvalidFloatTrait;
break;
}
if (is_trait != should_be_trait)
{
UnityTestResultsFailBegin(lineNumber);
UnityPrint(UnityStrExpected);
if (!should_be_trait)
UnityPrint(UnityStrNot);
UnityPrint(trait_names[trait_index]);
UnityPrint(UnityStrWas);
#ifndef UNITY_EXCLUDE_FLOAT_PRINT
UnityPrintFloat((UNITY_DOUBLE)actual);
#else
if (should_be_trait)
UnityPrint(UnityStrNot);
UnityPrint(trait_names[trait_index]);
#endif
UnityAddMsgIfSpecified(msg);
UNITY_FAIL_AND_BAIL;
}
}
|
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), %rax # 0xfd80
movq %rax, -0x20(%rbp)
movq 0x5fe8(%rip), %rax # 0xfd88
movq %rax, -0x18(%rbp)
movl -0x4c(%rbp), %eax
andq $0x1, %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
movq %rax, -0x60(%rbp)
movl -0x4c(%rbp), %eax
shrl %eax
movl %eax, %eax
movq %rax, -0x68(%rbp)
cmpq $0x0, 0x6371(%rip) # 0x10148
jne 0x9de3
cmpq $0x0, 0x636f(%rip) # 0x10150
je 0x9de8
jmp 0xa06d
movl -0x4c(%rbp), %eax
movq %rax, -0x70(%rbp)
subq $0x7, %rax
ja 0x9fd7
movq -0x70(%rbp), %rax
leaq 0x253c(%rip), %rcx # 0xc340
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movss -0x34(%rbp), %xmm0
subss -0x34(%rbp), %xmm0
movss -0x34(%rbp), %xmm1
subss -0x34(%rbp), %xmm1
ucomiss %xmm1, %xmm0
jne 0x9e2a
jp 0x9e2a
jmp 0x9e38
xorl %eax, %eax
movb $0x1, %cl
testb $0x1, %cl
movb %al, -0x71(%rbp)
jne 0x9e43
jmp 0x9e7c
xorl %eax, %eax
testb $0x1, %al
movb %al, -0x71(%rbp)
jne 0x9e43
jmp 0x9e7c
movss -0x34(%rbp), %xmm0
ucomiss -0x34(%rbp), %xmm0
jne 0x9e52
jp 0x9e52
jmp 0x9e60
xorl %eax, %eax
movb $0x1, %cl
testb $0x1, %cl
movb %al, -0x71(%rbp)
jne 0x9e7c
jmp 0x9e6b
xorl %eax, %eax
testb $0x1, %al
movb %al, -0x71(%rbp)
jne 0x9e7c
jmp 0x9e6b
movss -0x34(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
seta %al
movb %al, -0x71(%rbp)
movb -0x71(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cltq
movq %rax, -0x60(%rbp)
jmp 0x9fea
movss -0x34(%rbp), %xmm0
subss -0x34(%rbp), %xmm0
movss -0x34(%rbp), %xmm1
subss -0x34(%rbp), %xmm1
ucomiss %xmm1, %xmm0
jne 0x9eac
jp 0x9eac
jmp 0x9eba
xorl %eax, %eax
movb $0x1, %cl
testb $0x1, %cl
movb %al, -0x72(%rbp)
jne 0x9ec5
jmp 0x9efa
xorl %eax, %eax
testb $0x1, %al
movb %al, -0x72(%rbp)
jne 0x9ec5
jmp 0x9efa
movss -0x34(%rbp), %xmm0
ucomiss -0x34(%rbp), %xmm0
jne 0x9ed4
jp 0x9ed4
jmp 0x9ee2
xorl %eax, %eax
movb $0x1, %cl
testb $0x1, %cl
movb %al, -0x72(%rbp)
jne 0x9efa
jmp 0x9eed
xorl %eax, %eax
testb $0x1, %al
movb %al, -0x72(%rbp)
jne 0x9efa
jmp 0x9eed
xorps %xmm0, %xmm0
ucomiss -0x34(%rbp), %xmm0
seta %al
movb %al, -0x72(%rbp)
movb -0x72(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cltq
movq %rax, -0x60(%rbp)
jmp 0x9fea
movss -0x34(%rbp), %xmm0
movss -0x34(%rbp), %xmm1
xorl %edx, %edx
movl $0x1, %eax
ucomiss %xmm1, %xmm0
setp %sil
setne %cl
orb %sil, %cl
cmovnel %eax, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
cltq
movq %rax, -0x60(%rbp)
jmp 0x9fea
movss -0x34(%rbp), %xmm0
subss -0x34(%rbp), %xmm0
movss -0x34(%rbp), %xmm1
subss -0x34(%rbp), %xmm1
ucomiss %xmm1, %xmm0
jne 0x9f63
jp 0x9f63
jmp 0x9f6b
movb $0x1, %al
testb $0x1, %al
jne 0x9f73
jmp 0x9f9b
xorl %eax, %eax
testb $0x1, %al
jne 0x9f73
jmp 0x9f9b
movss -0x34(%rbp), %xmm0
ucomiss -0x34(%rbp), %xmm0
jne 0x9f82
jp 0x9f82
jmp 0x9f90
xorl %eax, %eax
movb $0x1, %cl
testb $0x1, %cl
movb %al, -0x73(%rbp)
jne 0x9f9b
jmp 0x9fc7
xorl %eax, %eax
testb $0x1, %al
movb %al, -0x73(%rbp)
jne 0x9f9b
jmp 0x9fc7
movss -0x34(%rbp), %xmm0
movss -0x34(%rbp), %xmm1
xorl %eax, %eax
movl $0x1, %ecx
ucomiss %xmm1, %xmm0
setp %sil
setne %dl
orb %sil, %dl
cmovnel %ecx, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x73(%rbp)
movb -0x73(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cltq
movq %rax, -0x60(%rbp)
jmp 0x9fea
movq $0x0, -0x68(%rbp)
leaq 0x24da(%rip), %rax # 0xc4c0
movq %rax, -0x30(%rbp)
movq -0x60(%rbp), %rax
cmpq -0x58(%rbp), %rax
je 0xa06d
movq -0x48(%rbp), %rdi
callq 0x9250
leaq 0x23df(%rip), %rdi # 0xc3e3
callq 0x8870
cmpq $0x0, -0x58(%rbp)
jne 0xa01c
leaq 0x24bd(%rip), %rdi # 0xc4d4
callq 0x8870
movq -0x68(%rbp), %rax
movq -0x30(%rbp,%rax,8), %rdi
callq 0x8870
leaq 0x23bd(%rip), %rdi # 0xc3ee
callq 0x8870
movss -0x34(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x8c90
movq -0x40(%rbp), %rdi
callq 0x9290
movq $0x1, 0x60f0(%rip) # 0x10148
leaq 0x60a9(%rip), %rdi # 0x10108
addq $0x50, %rdi
movl $0x1, %esi
callq 0x3140
movq %fs:0x28, %rax
movq -0x8(%rbp), %rcx
cmpq %rcx, %rax
jne 0xa088
addq $0x80, %rsp
popq %rbp
retq
callq 0x30b0
nopl (%rax)
|
/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 = crypto_sign_keypair(pk, sk);
VALGRIND_MAKE_MEM_DEFINED(&ret, sizeof(ret));
if (ret != 0) {
printf("Failed to generate key pair\n");
return -1;
}
VALGRIND_MAKE_MEM_UNDEFINED(sk, sizeof(sk));
VALGRIND_MAKE_MEM_UNDEFINED(message, sizeof(message));
unsigned long long smlen = sizeof(sm);
ret = crypto_sign(sm, &smlen, message, sizeof(message), sk);
if (ret != 0) {
printf("Failed to sign\n");
return -1;
}
VALGRIND_MAKE_MEM_DEFINED(sm, smlen);
VALGRIND_MAKE_MEM_DEFINED(sk, sizeof(sk));
VALGRIND_MAKE_MEM_DEFINED(message, sizeof(message));
unsigned long long mlen = sizeof(omessage);
ret = crypto_sign_open(omessage, &mlen, sm, smlen, pk);
if (ret != 0) {
printf("Failed to verify (ret = %d)\n", ret);
return -1;
}
if (mlen != sizeof(message)) {
printf("length of message after verify incorrect, got " LL_FMT ", expected " SIZET_FMT "\n",
mlen, sizeof(message));
return -1;
}
if (memcmp(message, omessage, sizeof(message)) != 0) {
printf("message mismatch after verification\n");
return -1;
}
// test special case where message and signature overlap
memcpy(sm, message, sizeof(message));
smlen = sizeof(sm);
ret = crypto_sign(sm, &smlen, sm, sizeof(message), sk);
if (ret != 0) {
printf("Failed to sign\n");
return -1;
}
mlen = smlen;
ret = crypto_sign_open(sm, &mlen, sm, smlen, pk);
if (ret != 0) {
printf("Failed to verify (ret = %d)\n", ret);
return -1;
}
if (mlen != sizeof(message)) {
printf("length of message after verify incorrect, got " LL_FMT ", expected " SIZET_FMT "\n",
mlen, sizeof(message));
return -1;
}
if (memcmp(message, sm, sizeof(message)) != 0) {
printf("message mismatch after verification\n");
return -1;
}
printf("Sign/Verify test passed\n");
return 0;
}
|
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, %esi
movl $0x32, %edx
callq 0x1060
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movl $0x1ed84, %edx # imm = 0x1ED84
callq 0x1060
leaq 0x1eea0(%rsp), %rdi
leaq 0x1ee30(%rsp), %rsi
callq 0x1520
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
je 0x12b1
leaq 0xd6a(%rip), %rdi # 0x2004
movb $0x0, %al
callq 0x1050
movl $0xffffffff, 0x1eee4(%rsp) # imm = 0xFFFFFFFF
jmp 0x150a
movq $0x1ed84, 0x10(%rsp) # imm = 0x1ED84
leaq 0x20(%rsp), %rdi
leaq 0x1edf0(%rsp), %rdx
leaq 0x1ee30(%rsp), %r8
leaq 0x10(%rsp), %rsi
movl $0x32, %ecx
callq 0x15f0
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
je 0x1307
leaq 0xd31(%rip), %rdi # 0x2021
movb $0x0, %al
callq 0x1050
movl $0xffffffff, 0x1eee4(%rsp) # imm = 0xFFFFFFFF
jmp 0x150a
movq $0x32, 0x8(%rsp)
leaq 0x1edb0(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movq 0x10(%rsp), %rcx
leaq 0x1eea0(%rsp), %r8
leaq 0x8(%rsp), %rsi
callq 0x1760
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
je 0x1361
movl 0x1c(%rsp), %esi
leaq 0xce7(%rip), %rdi # 0x2031
movb $0x0, %al
callq 0x1050
movl $0xffffffff, 0x1eee4(%rsp) # imm = 0xFFFFFFFF
jmp 0x150a
cmpq $0x32, 0x8(%rsp)
je 0x1391
movq 0x8(%rsp), %rsi
leaq 0xcd9(%rip), %rdi # 0x204e
movl $0x32, %edx
movb $0x0, %al
callq 0x1050
movl $0xffffffff, 0x1eee4(%rsp) # imm = 0xFFFFFFFF
jmp 0x150a
leaq 0x1edf0(%rsp), %rdi
leaq 0x1edb0(%rsp), %rsi
movl $0x32, %edx
callq 0x1090
cmpl $0x0, %eax
je 0x13ce
leaq 0xcd9(%rip), %rdi # 0x2090
movb $0x0, %al
callq 0x1050
movl $0xffffffff, 0x1eee4(%rsp) # imm = 0xFFFFFFFF
jmp 0x150a
leaq 0x20(%rsp), %rdi
leaq 0x1edf0(%rsp), %rsi
movl $0x32, %edx
callq 0x10c0
movq $0x1ed84, 0x10(%rsp) # imm = 0x1ED84
leaq 0x20(%rsp), %rdi
leaq 0x20(%rsp), %rdx
leaq 0x1ee30(%rsp), %r8
leaq 0x10(%rsp), %rsi
movl $0x32, %ecx
callq 0x15f0
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
je 0x1438
leaq 0xc00(%rip), %rdi # 0x2021
movb $0x0, %al
callq 0x1050
movl $0xffffffff, 0x1eee4(%rsp) # imm = 0xFFFFFFFF
jmp 0x150a
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movq 0x10(%rsp), %rcx
leaq 0x1eea0(%rsp), %r8
leaq 0x8(%rsp), %rsi
callq 0x1760
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
je 0x148d
movl 0x1c(%rsp), %esi
leaq 0xbb8(%rip), %rdi # 0x2031
movb $0x0, %al
callq 0x1050
movl $0xffffffff, 0x1eee4(%rsp) # imm = 0xFFFFFFFF
jmp 0x150a
cmpq $0x32, 0x8(%rsp)
je 0x14ba
movq 0x8(%rsp), %rsi
leaq 0xbad(%rip), %rdi # 0x204e
movl $0x32, %edx
movb $0x0, %al
callq 0x1050
movl $0xffffffff, 0x1eee4(%rsp) # imm = 0xFFFFFFFF
jmp 0x150a
leaq 0x1edf0(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movl $0x32, %edx
callq 0x1090
cmpl $0x0, %eax
je 0x14f1
leaq 0xbb3(%rip), %rdi # 0x2090
movb $0x0, %al
callq 0x1050
movl $0xffffffff, 0x1eee4(%rsp) # imm = 0xFFFFFFFF
jmp 0x150a
leaq 0xbbd(%rip), %rdi # 0x20b5
movb $0x0, %al
callq 0x1050
movl $0x0, 0x1eee4(%rsp)
movl 0x1eee4(%rsp), %eax
addq $0x1eee8, %rsp # imm = 0x1EEE8
retq
nopl (%rax)
|
/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 animated camera */
if (animated_camera)
camera = Camera(animated_camera->get(time),camera.handedness);
ISPCCamera ispccamera = camera.getISPCCamera(width,height);
if (print_camera)
std::cout << camera.str() << std::endl;
/* render image using ISPC */
initRayStats();
render(pixels,width,height,time,ispccamera);
double dt0 = getSeconds()-t0;
if (ispccamera.render_time != 0.0) dt0 = ispccamera.render_time;
avg_render_time.add(dt0);
double mrayps = double(getNumRays())/(1000000.0*dt0);
avg_mrayps.add(mrayps);
/* draw pixels to screen */
glRasterPos2i(-1,1);
glPixelZoom(1.0f,-1.0f);
glDrawPixels(width,height,GL_RGBA,GL_UNSIGNED_BYTE,pixels);
// Start the Dear ImGui frame
ImGui_ImplOpenGL2_NewFrame();
ImGui_ImplGlfw_NewFrame();
ImGui::NewFrame();
ImGuiWindowFlags window_flags = 0;
window_flags |= ImGuiWindowFlags_NoTitleBar;
//window_flags |= ImGuiWindowFlags_NoScrollbar;
//window_flags |= ImGuiWindowFlags_MenuBar;
//window_flags |= ImGuiWindowFlags_NoMove;
//window_flags |= ImGuiWindowFlags_NoResize;
//window_flags |= ImGuiWindowFlags_NoCollapse;
//window_flags |= ImGuiWindowFlags_NoNav;
//ImGui::GetStyle().WindowBorderSize = 0.0f;
//ImGui::SetNextWindowPos(ImVec2(width-200,0));
//ImGui::SetNextWindowSize(ImVec2(200,height));
ImGui::SetNextWindowBgAlpha(0.3f);
ImGui::Begin("Embree", nullptr, window_flags);
drawGUI();
double render_dt = avg_render_time.get();
double render_fps = render_dt != 0.0 ? 1.0f/render_dt : 0.0;
ImGui::Text("Render: %3.2f fps",render_fps);
double total_dt = avg_frame_time.get();
double total_fps = total_dt != 0.0 ? 1.0f/total_dt : 0.0;
ImGui::Text("Total: %3.2f fps",total_fps);
#if defined(RAY_STATS) && !defined(EMBREE_SYCL_TUTORIAL)
ImGui::Text("%3.2f Mray/s",avg_mrayps.get());
#endif
ImGui::End();
//ImGui::ShowDemoWindow();
ImGui::Render();
ImGui_ImplOpenGL2_RenderDrawData(ImGui::GetDrawData());
glfwSwapBuffers(window);
#ifdef __APPLE__
// work around glfw issue #1334
// https://github.com/glfw/glfw/issues/1334
static bool macMoved = false;
if (!macMoved) {
int x, y;
glfwGetWindowPos(window, &x, &y);
glfwSetWindowPos(window, ++x, y);
macMoved = true;
}
#endif
double dt1 = getSeconds()-t0;
avg_frame_time.add(dt1);
if (print_frame_rate)
{
std::ostringstream stream;
stream.setf(std::ios::fixed, std::ios::floatfield);
stream.precision(2);
stream << "render: ";
stream << 1.0f/dt0 << " fps, ";
stream << dt0*1000.0f << " ms, ";
#if defined(RAY_STATS) && !defined(EMBREE_SYCL_TUTORIAL)
stream << mrayps << " Mray/s, ";
#endif
stream << "total: ";
stream << 1.0f/dt1 << " fps, ";
stream << dt1*1000.0f << " ms, ";
stream << width << "x" << height << " pixels";
std::cout << stream.str() << std::endl;
}
}
|
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)
jne 0x28196
movsd 0x188(%rbx), %xmm2
movapd %xmm0, %xmm1
subsd %xmm2, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
andps 0x127f19(%rip), %xmm0 # 0x150090
callq 0x17930
cvtss2sd %xmm0, %xmm0
movsd 0x12b810(%rip), %xmm1 # 0x153998
mulsd %xmm1, %xmm0
addsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
jmp 0x2819e
movss 0x1c4(%rbx), %xmm0
movss %xmm0, (%rsp)
leaq 0xe0(%rbx), %r14
movss 0x1b0(%rbx), %xmm0
movss 0x1b4(%rbx), %xmm1
mulss %xmm0, %xmm1
movaps %xmm1, 0x50(%rsp)
movss 0x1b8(%rbx), %xmm1
mulss %xmm0, %xmm1
movaps %xmm1, 0x10(%rsp)
mulss 0x1bc(%rbx), %xmm0
movaps %xmm0, 0x40(%rsp)
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x3372a
movaps 0x50(%rsp), %xmm1
shufps $0x0, %xmm1, %xmm1 # xmm1 = xmm1[0,0,0,0]
movaps 0x40(%rsp), %xmm0
shufps $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
mulps 0x20(%r15), %xmm0
movaps %xmm0, %xmm2
movaps 0x10(%rsp), %xmm0
shufps $0x0, %xmm0, %xmm0 # xmm0 = xmm0[0,0,0,0]
mulps 0x10(%r15), %xmm0
addps %xmm2, %xmm0
mulps (%r15), %xmm1
addps %xmm0, %xmm1
movaps 0xe0(%rbx), %xmm0
addps %xmm1, %xmm0
movaps %xmm0, 0xe0(%rbx)
addps 0xf0(%rbx), %xmm1
movaps %xmm1, 0xf0(%rbx)
movq 0xd0(%rbx), %rsi
testq %rsi, %rsi
je 0x28291
movq (%rsi), %rax
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movss (%rsp), %xmm0
callq *0x80(%rax)
movaps (%r15), %xmm0
movaps 0x10(%r15), %xmm1
movaps 0x20(%r15), %xmm2
movl 0x30(%r15), %eax
movaps %xmm0, 0xe0(%rbx)
movaps %xmm1, 0xf0(%rbx)
movaps %xmm2, 0x100(%rbx)
movl %eax, 0x110(%rbx)
movl 0x120(%rbx), %edx
movl 0x124(%rbx), %ecx
leaq 0x1dc(%rsp), %rdi
movq %r14, %rsi
callq 0x318b0
cmpb $0x1, 0x2f0(%rbx)
jne 0x28316
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x32108
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq 0x1a8cec(%rip), %rdi # 0x1d0fc0
callq 0x17d70
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x17b40
movsbl %al, %esi
movq %r14, %rdi
callq 0x17050
movq %rax, %rdi
callq 0x17770
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x28316
callq 0x17b20
callq 0x26e48
movq 0x128(%rbx), %rsi
movl 0x120(%rbx), %edx
movl 0x124(%rbx), %ecx
movq (%rbx), %rax
leaq 0x1dc(%rsp), %r14
movq %rbx, %rdi
movss (%rsp), %xmm0
movq %r14, %r8
callq *0x58(%rax)
callq 0xdc332
movss 0x30(%r14), %xmm1
xorps %xmm2, %xmm2
ucomiss %xmm1, %xmm2
cvtss2sd %xmm1, %xmm1
movsd %xmm1, (%rsp)
jne 0x28370
jp 0x28370
subsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rsp)
leaq 0x1d0(%rbx), %r15
movq %r15, %rdi
movsd (%rsp), %xmm0
callq 0x328a6
callq 0x26eb0
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
movsd 0x127b0f(%rip), %xmm1 # 0x14fea8
mulsd (%rsp), %xmm1
divsd %xmm1, %xmm0
leaq 0x290(%rbx), %r14
movq %r14, %rdi
movsd %xmm0, 0x10(%rsp)
callq 0x328a6
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
movl $0x1, %esi
callq 0x17350
movss 0x127d32(%rip), %xmm0 # 0x150100
movss 0x127d66(%rip), %xmm1 # 0x15013c
callq 0x181e0
movl 0x120(%rbx), %edi
movl 0x124(%rbx), %esi
movq 0x128(%rbx), %r8
movl $0x1908, %edx # imm = 0x1908
movl $0x1401, %ecx # imm = 0x1401
callq 0x178a0
callq 0x13c76e
callq 0x13c056
callq 0xe80d3
movss 0x127d2c(%rip), %xmm0 # 0x150140
callq 0xf4e99
leaq 0x12d1fb(%rip), %rdi # 0x15561b
xorl %esi, %esi
movl $0x1, %edx
callq 0xec6a2
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x50(%rax)
movq %r15, %rdi
callq 0x32942
movsd 0x127a5b(%rip), %xmm1 # 0x14fea0
divsd %xmm0, %xmm1
xorps %xmm2, %xmm2
cmpneqsd %xmm2, %xmm0
andpd %xmm1, %xmm0
leaq 0x12d1c6(%rip), %rdi # 0x155622
movb $0x1, %al
callq 0x115b13
leaq 0x230(%rbx), %r15
movq %r15, %rdi
callq 0x32942
movsd 0x127a26(%rip), %xmm1 # 0x14fea0
divsd %xmm0, %xmm1
cmpneqsd 0x12b521(%rip), %xmm0 # 0x1539a8
andpd %xmm1, %xmm0
leaq 0x12d1a2(%rip), %rdi # 0x155634
movb $0x1, %al
callq 0x115b13
movq %r14, %rdi
callq 0x32942
leaq 0x12d19d(%rip), %rdi # 0x155645
movb $0x1, %al
callq 0x115b13
callq 0xf161f
callq 0xf1a00
callq 0xe7370
movq %rax, %rdi
callq 0x13c797
movq 0xa8(%rbx), %rdi
callq 0x13d730
callq 0xdc332
subsd 0x8(%rsp), %xmm0
movq %r15, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x328a6
cmpb $0x1, 0x1c9(%rbx)
jne 0x286f1
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0x18010
movq (%r14), %rax
movq -0x18(%rax), %rax
movl $0xfffffefb, %ecx # imm = 0xFFFFFEFB
andl 0x78(%rsp,%rax), %ecx
orl $0x4, %ecx
movl %ecx, 0x78(%rsp,%rax)
movq (%r14), %rax
movq -0x18(%rax), %rax
movq $0x2, 0x68(%rsp,%rax)
leaq 0x12d11f(%rip), %rsi # 0x155652
movl $0x8, %edx
movq %r14, %rdi
callq 0x17d70
movsd 0x127958(%rip), %xmm0 # 0x14fea0
divsd (%rsp), %xmm0
leaq 0x60(%rsp), %rdi
callq 0x18510
leaq 0x12d0fd(%rip), %rsi # 0x15565b
movl $0x6, %edx
movq %rax, %rdi
callq 0x17d70
movsd (%rsp), %xmm0
mulsd 0x12b428(%rip), %xmm0 # 0x1539a0
leaq 0x60(%rsp), %rdi
callq 0x18510
leaq 0x12d0d9(%rip), %rsi # 0x155662
movl $0x5, %edx
movq %rax, %rdi
callq 0x17d70
leaq 0x60(%rsp), %rdi
movsd 0x10(%rsp), %xmm0
callq 0x18510
leaq 0x12d0bb(%rip), %rsi # 0x155668
movl $0x9, %edx
movq %rax, %rdi
callq 0x17d70
leaq 0x12d0b1(%rip), %rsi # 0x155672
leaq 0x60(%rsp), %rdi
movl $0x7, %edx
callq 0x17d70
movsd 0x1278c8(%rip), %xmm0 # 0x14fea0
divsd 0x8(%rsp), %xmm0
leaq 0x60(%rsp), %rdi
callq 0x18510
leaq 0x12d06c(%rip), %rsi # 0x15565b
movl $0x6, %edx
movq %rax, %rdi
callq 0x17d70
movsd 0x8(%rsp), %xmm0
mulsd 0x12b396(%rip), %xmm0 # 0x1539a0
leaq 0x60(%rsp), %rdi
callq 0x18510
leaq 0x12d047(%rip), %rsi # 0x155662
movl $0x5, %edx
movq %rax, %rdi
callq 0x17d70
movl 0x120(%rbx), %esi
leaq 0x60(%rsp), %rdi
callq 0x17760
movq %rax, %r14
leaq 0x135ce5(%rip), %rsi # 0x15e327
movl $0x1, %edx
movq %rax, %rdi
callq 0x17d70
movl 0x124(%rbx), %esi
movq %r14, %rdi
callq 0x17760
leaq 0x132853(%rip), %rsi # 0x15aeb7
movl $0x7, %edx
movq %rax, %rdi
callq 0x17d70
leaq 0x68(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x184b0
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x1a892f(%rip), %rdi # 0x1d0fc0
callq 0x17d70
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x17b40
movsbl %al, %esi
movq %rbx, %rdi
callq 0x17050
movq %rax, %rdi
callq 0x17770
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x286d3
callq 0x17b20
movq 0x1a88ce(%rip), %rsi # 0x1d0fa8
leaq 0x60(%rsp), %rdi
callq 0x175c0
leaq 0xd0(%rsp), %rdi
callq 0x17340
addq $0x210, %rsp # imm = 0x210
popq %rbx
popq %r14
popq %r15
retq
jmp 0x28730
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x28733
callq 0x17b20
jmp 0x28733
movq %rax, %rbx
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x28751
callq 0x17b20
jmp 0x28751
movq %rax, %rbx
movq 0x1a886e(%rip), %rsi # 0x1d0fa8
leaq 0x60(%rsp), %rdi
callq 0x175c0
leaq 0xd0(%rsp), %rdi
callq 0x17340
movq %rbx, %rdi
callq 0x18710
nop
|
/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 %rbx
jmp 0x17770
|
/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 %rbx
popq %r14
retq
jmp 0x2a6d5
movq %rax, %r14
testq %rbx, %rbx
je 0x2a6cd
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq %r14, %rdi
callq 0x18710
movq %rax, %rdi
callq 0x1a679
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)::$_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), %rdi
movq %rbx, %rsi
callq 0x341b4
movq %rbx, %rdi
callq 0x1b056
movl %eax, %ebp
movq %rbx, %rdi
callq 0x1b056
movl %eax, %r15d
movss 0x24(%rsp), %xmm0
movaps %xmm0, 0x90(%rsp)
movsd 0x28(%rsp), %xmm0
movaps %xmm0, 0x50(%rsp)
movss 0x18(%rsp), %xmm0
movaps %xmm0, 0x60(%rsp)
movsd 0x1c(%rsp), %xmm0
movaps %xmm0, 0x80(%rsp)
movsd 0x8(%rsp), %xmm0
movaps %xmm0, 0x70(%rsp)
movss 0x10(%rsp), %xmm0
movss %xmm0, 0x4(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x40(%rsp)
movl $0x40, %edi
callq 0x17bb0
movslq %ebp, %rcx
movslq %r15d, %rdx
movq %r14, (%rax)
addq $0x398, %r14 # imm = 0x398
movaps 0x90(%rsp), %xmm0
movaps 0x50(%rsp), %xmm2
movlhps %xmm2, %xmm0 # xmm0 = xmm0[0],xmm2[0]
movaps 0x60(%rsp), %xmm1
shufps $0xd4, %xmm2, %xmm1 # xmm1 = xmm1[0,1],xmm2[1,3]
shufps $0x28, %xmm1, %xmm0 # xmm0 = xmm0[0,2],xmm1[2,0]
movups %xmm0, 0x8(%rax)
movaps 0x80(%rsp), %xmm0
unpcklpd 0x70(%rsp), %xmm0 # xmm0 = xmm0[0],mem[0]
movups %xmm0, 0x18(%rax)
movss 0x4(%rsp), %xmm0
movss %xmm0, 0x28(%rax)
movq %rcx, 0x30(%rax)
movq %rdx, 0x38(%rax)
leaq 0x30(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x8c(%rip), %rax # 0x2d9b2
movq %rax, 0x18(%rsi)
leaq 0x281(%rip), %rax # 0x2dbb2
movq %rax, 0x10(%rsi)
movq %r14, %rdi
callq 0x34282
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x2d956
leaq 0x30(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2d9aa
jmp 0x2d9aa
movq %rax, %r14
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x2d994
leaq 0x30(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x2d994
jmp 0x2d9aa
movq %rax, %r14
testq %rbx, %rbx
je 0x2d9a2
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq %r14, %rdi
callq 0x18710
movq %rax, %rdi
callq 0x1a679
|
/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
movl %eax, %ebp
movsd 0x10(%rsp), %xmm0
movaps %xmm0, 0x40(%rsp)
movss 0x18(%rsp), %xmm0
movss %xmm0, 0x8(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x30(%rsp)
movl $0x20, %edi
callq 0x17bb0
movslq %ebp, %rcx
movq %r14, (%rax)
addq $0x398, %r14 # imm = 0x398
movaps 0x40(%rsp), %xmm0
movlps %xmm0, 0x8(%rax)
movss 0x8(%rsp), %xmm0
movss %xmm0, 0x10(%rax)
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x14(%rax)
movq %rcx, 0x18(%rax)
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x88(%rip), %rax # 0x2f7ba
movq %rax, 0x18(%rsi)
leaq 0x249(%rip), %rax # 0x2f986
movq %rax, 0x10(%rsi)
movq %r14, %rdi
callq 0x34282
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x2f762
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x2f7b1
jmp 0x2f7b1
movq %rax, %r14
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x2f79b
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x2f79b
jmp 0x2f7b1
movq %rax, %r14
testq %rbx, %rbx
je 0x2f7a9
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq %r14, %rdi
callq 0x18710
movq %rax, %rdi
callq 0x1a679
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)::$_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
movss %xmm0, 0xc(%rsp)
movq %rbx, %rdi
callq 0x1b056
movl %eax, %ebp
movsd 0x20(%rsp), %xmm0
movaps %xmm0, 0x50(%rsp)
movss 0x28(%rsp), %xmm0
movss %xmm0, 0x4(%rsp)
movsd 0x10(%rsp), %xmm0
movaps %xmm0, 0x60(%rsp)
movss 0x18(%rsp), %xmm0
movss %xmm0, 0x8(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x40(%rsp)
movl $0x30, %edi
callq 0x17bb0
movslq %ebp, %rcx
movaps 0x50(%rsp), %xmm0
movlps %xmm0, (%rax)
movss 0x4(%rsp), %xmm0
movss %xmm0, 0x8(%rax)
movss 0xc(%rsp), %xmm0
movss %xmm0, 0xc(%rax)
movq %rcx, 0x10(%rax)
movaps 0x60(%rsp), %xmm0
movlps %xmm0, 0x18(%rax)
movss 0x8(%rsp), %xmm0
movss %xmm0, 0x20(%rax)
movq %r14, 0x28(%rax)
addq $0x398, %r14 # imm = 0x398
leaq 0x30(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x88(%rip), %rax # 0x2fbb2
movq %rax, 0x18(%rsi)
leaq 0x285(%rip), %rax # 0x2fdba
movq %rax, 0x10(%rsi)
movq %r14, %rdi
callq 0x34282
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x2fb5a
leaq 0x30(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x2fba9
jmp 0x2fba9
movq %rax, %r14
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x2fb93
leaq 0x30(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x2fb93
jmp 0x2fba9
movq %rax, %r14
testq %rbx, %rbx
je 0x2fba1
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq %r14, %rdi
callq 0x18710
movq %rax, %rdi
callq 0x1a679
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)::$_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
movq %r15, %rsi
callq 0x53283
movq 0x68(%rbx), %r13
movq (%r13,%r12,8), %rdi
testq %rdi, %rdi
je 0x32d8b
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x8(%rsp), %rax
movq %rax, (%r13,%r12,8)
movq $0x0, 0x8(%rsp)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x32dad
movq (%rdi), %rax
callq *0x18(%rax)
incq %r12
movq 0x68(%rbx), %rax
movq 0x70(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r12
jb 0x32d59
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x32e05
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x32dee
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x32dee
jmp 0x32e05
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x32dfd
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rdi
callq 0x18710
movq %rax, %rdi
callq 0x1a679
nop
|
/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 $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/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 (%r15), %rsi
movq (%rsi), %rax
movq %rsp, %r14
xorps %xmm0, %xmm0
movq %r14, %rdi
callq *0x90(%rax)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3a156
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x3a020
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x3a060
jmp 0x3a060
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x3a058
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x3a058
jmp 0x3a060
movq %rax, %rbx
testq %r14, %r14
je 0x3a058
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq %rbx, %rdi
callq 0x18710
movq %rax, %rdi
callq 0x1a679
|
/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*)*in->numTimeSteps());
for (size_t i=0; i<in->numTimeSteps(); i++)
positions[i] = copyArrayToUSM(in->positions[i]);
if (in->normals.size()) {
normals = (Vec3fa**) alignedUSMMalloc(sizeof(Vec3fa*)*in->numTimeSteps());
for (size_t i=0; i<in->numTimeSteps(); i++)
normals[i] = copyArrayToUSM(in->normals[i]);
}
texcoords = copyArrayToUSM(in->texcoords);
startTime = in->time_range.lower;
endTime = in->time_range.upper;
numTimeSteps = (unsigned) in->numTimeSteps();
numVertices = (unsigned) in->numVertices();
numTriangles = (unsigned) in->numPrimitives();
geom.materialID = scene_in->materialID(in->material);
triangles = (ISPCTriangle*) copyArrayToUSM(in->triangles);
}
|
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 0x18880
movq %rax, 0x8(%rbx)
movq (%r14), %rax
movq 0x78(%rax), %rdi
subq 0x70(%rax), %rdi
sarq $0x2, %rdi
movl $0x10, %esi
movl $0x1, %edx
callq 0xd8834
leaq 0x18(%rbx), %r12
movq %rax, (%r12)
movq (%r14), %rcx
movq 0x70(%rcx), %rdi
movq 0x78(%rcx), %rax
subq %rdi, %rax
je 0x3a796
xorl %r13d, %r13d
xorl %ebp, %ebp
addq %r13, %rdi
callq 0x3d821
movq (%r12), %rcx
movq %rax, (%rcx,%rbp,8)
incq %rbp
movq (%r14), %rcx
movq 0x70(%rcx), %rdi
movq 0x78(%rcx), %rax
subq %rdi, %rax
movq %rax, %rdx
sarq $0x5, %rdx
addq $0x20, %r13
cmpq %rdx, %rbp
jb 0x3a765
movq 0x90(%rcx), %rdx
cmpq 0x88(%rcx), %rdx
je 0x3a805
sarq $0x2, %rax
movl $0x10, %esi
movq %rax, %rdi
movl $0x1, %edx
callq 0xd8834
movq %rax, 0x20(%rbx)
movq (%r14), %rax
movq 0x78(%rax), %rcx
cmpq 0x70(%rax), %rcx
je 0x3a805
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x88(%rax), %rdi
addq %r12, %rdi
callq 0x3d821
movq 0x20(%rbx), %rcx
movq %rax, (%rcx,%r13,8)
movq (%r14), %rax
movq 0x78(%rax), %rcx
subq 0x70(%rax), %rcx
incq %r13
sarq $0x5, %rcx
addq $0x20, %r12
cmpq %rcx, %r13
jb 0x3a7d3
movl $0xa0, %edi
addq (%r14), %rdi
callq 0x3d851
movq %rax, 0x28(%rbx)
movq (%r14), %rax
movss 0x68(%rax), %xmm0
movss %xmm0, 0x38(%rbx)
movq (%r14), %rax
movss 0x6c(%rax), %xmm0
movss %xmm0, 0x3c(%rbx)
movq (%r14), %rax
movq 0x78(%rax), %rcx
subq 0x70(%rax), %rcx
shrq $0x5, %rcx
movl %ecx, 0x40(%rbx)
movq (%r14), %rax
movq 0x70(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, 0x44(%rbx)
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x70(%rax)
movl %eax, 0x48(%rbx)
movq (%r14), %rax
movq 0xd0(%rax), %rdi
movq %rdi, (%rsp)
testq %rdi, %rdi
je 0x3a874
movq (%rdi), %rax
callq *0x10(%rax)
movq %rsp, %rsi
movq %r15, %rdi
callq 0x380cc
movl %eax, 0x10(%rbx)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x3a891
movq (%rdi), %rax
callq *0x18(%rax)
movl $0xb8, %edi
addq (%r14), %rdi
callq 0x3d87e
movq %rax, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3a8c7
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x3a8d6
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x3a8d6
movq %rax, %rdi
callq 0x1a679
jmp 0x3a8d3
jmp 0x3a8d3
movq %rax, %r14
movq %rbx, %rdi
callq 0x3d808
movq %r14, %rdi
callq 0x18710
|
/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
movss %xmm0, 0xc(%rsp)
leaq 0x1177dc(%rip), %rsi # 0x1567bb
movq %r13, %rdi
callq 0x17110
movq %rax, %rbp
addq %r13, %rbp
movq %rbp, (%r14)
movq %rbp, %rdi
movq %r12, %rsi
callq 0x17490
leaq (%rax,%rbp), %r15
movq %r15, (%r14)
cmpb $0x0, (%rax,%rbp)
movss 0xc(%rsp), %xmm0
movaps %xmm0, %xmm1
movaps %xmm0, %xmm2
je 0x3f0a3
leaq 0x1175fd(%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
movss %xmm0, 0x14(%rsp)
leaq 0x11776f(%rip), %r15 # 0x1567bb
movq %r13, %rdi
movq %r15, %rsi
callq 0x17110
movq %rax, %rbp
addq %r13, %rbp
movq %rbp, (%r14)
movq %rbp, %rdi
movq %r12, %rsi
callq 0x17490
movq %rax, %r12
addq %rbp, %r12
movq %r12, (%r14)
movq %r12, %rdi
callq 0x17ef0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x10(%rsp)
movq %r12, %rdi
movq %r15, %rsi
callq 0x17110
movss 0x10(%rsp), %xmm2
movss 0x14(%rsp), %xmm1
addq %r12, %rax
movq %rax, (%r14)
movss 0xc(%rsp), %xmm0
movss %xmm0, (%rbx)
movss %xmm1, 0x4(%rbx)
movss %xmm2, 0x8(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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 next multiline */
std::string line; std::getline(cin,line);
while (!line.empty() && line[line.size()-1] == '\\') {
line[line.size()-1] = ' ';
std::string next_line; std::getline(cin,next_line);
if (next_line.empty()) break;
line += next_line;
}
const char* token = trimEnd(line.c_str() + strspn(line.c_str(), " \t"));
if (token[0] == 0 ) continue; // ignore empty lines
if (token[0] == '#') continue; // ignore comments
if (!strncmp(token, "newmtl", 6))
{
if (name != "") {
material[name] = cur.select();
material[name]->name = name;
}
parseSep(token+=6);
name = token;
cur = ExtObjMaterial();
continue;
}
if (name == "") THROW_RUNTIME_ERROR("invalid material file: newmtl expected first");
try
{
if (!strncmp(token, "illum", 5)) { parseSep(token += 5); continue; }
if (!strncmp(token, "d", 1)) { parseSep(token += 1); cur.d = getFloat(token); continue; }
if (!strncmp(token, "Ns", 2)) { parseSep(token += 2); cur.Ns = getFloat(token); continue; }
if (!strncmp(token, "Ni", 2)) { parseSep(token += 2); cur.Ni = getFloat(token); continue; }
if (!strncmp(token, "map_d", 5) || !strncmp(token, "d_map", 5)) {
parseSep(token += 5);
cur.map_d = loadTexture(FileName(token));
continue;
}
if (!strncmp(token, "map_Ka", 6) || !strncmp(token, "Ka_map", 6)) {
parseSep(token += 6);
cur.map_Ka = loadTexture(FileName(token));
continue;
}
if (!strncmp(token, "map_Kd", 6) || !strncmp(token, "Kd_map", 6)) {
parseSep(token += 6);
cur.map_Kd = loadTexture(FileName(token));
continue;
}
if (!strncmp(token, "map_Ks", 6) || !strncmp(token, "Ks_map", 6)) {
parseSep(token += 6);
cur.map_Ks = loadTexture(FileName(token));
continue;
}
if (!strncmp(token, "map_Kt", 6) || !strncmp(token, "Kt_map", 6)) {
parseSep(token += 6);
cur.map_Kt = loadTexture(FileName(token));
continue;
}
if (!strncmp(token, "map_Tf", 6) || !strncmp(token, "Tf_map", 6)) {
parseSep(token += 6);
cur.map_Kt = loadTexture(FileName(token));
continue;
}
if (!strncmp(token, "map_Ns", 6) || !strncmp(token, "Ns_map", 6)) {
parseSep(token += 6);
cur.map_Ns = loadTexture(FileName(token));
continue;
}
if (!strncmp(token, "map_Displ", 9) || !strncmp(token, "Displ_map", 9)) {
parseSep(token += 9);
cur.map_Displ = loadTexture(FileName(token));
continue;
}
if (!strncmp(token, "Ka", 2)) { parseSep(token += 2); cur.Ka = getVec3f(token); continue; }
if (!strncmp(token, "Kd", 2)) { parseSep(token += 2); cur.Kd = getVec3f(token); continue; }
if (!strncmp(token, "Ks", 2)) { parseSep(token += 2); cur.Ks = getVec3f(token); continue; }
if (!strncmp(token, "Kt", 2)) { parseSep(token += 2); cur.Kt = getVec3f(token); continue; }
if (!strncmp(token, "Tf", 2)) { parseSep(token += 2); cur.Kt = getVec3f(token); continue; }
/* extended OBJ */
if (!strncmp(token, "type", 4)) {
parseSep(token += 4); std::string type = token;
if (type == "matte") cur.type = ExtObjMaterial::MATTE;
else if (type == "glass") cur.type = ExtObjMaterial::GLASS;
else if (type == "metal") cur.type = ExtObjMaterial::METAL;
else if (type == "metallicPaint") cur.type = ExtObjMaterial::METALLIC_PAINT;
else if (type == "principled") cur.type = ExtObjMaterial::NONE;
else if (type == "luminous") cur.type = ExtObjMaterial::NONE;
continue;
}
/* OSPRay principled material extensions */
if (!strncmp(token, "baseColor", 9)) { parseSep(token += 9); cur.Kd = getVec3f(token); continue; }
if (!strncmp(token, "ior", 3)) { parseSep(token += 3); cur.Ni = getFloat(token); continue; }
if (!strncmp(token, "map_baseColor", 13)) { parseSep(token += 13); cur.map_Kd = loadTexture(FileName(token)); continue; }
if (!strncmp(token, "map_specular", 12)) { parseSep(token += 12); cur.map_Ks = loadTexture(FileName(token)); continue; }
if (!strncmp(token, "map_normal.scale", 16)) { parseSep(token += 16); continue; }
if (!strncmp(token, "map_normal", 10)) { parseSep(token += 10); cur.map_Displ = loadTexture(FileName(token)); continue; }
if (!strncmp(token, "transmissionColor",17)) { parseSep(token += 17); cur.Kt = getVec3f(token); continue; }
if (!strncmp(token, "transmission", 12)) { parseSep(token += 12); cur.Kt = Vec3f(getFloat(token)); continue; }
if (!strncmp(token, "roughnessMap", 12)) { parseSep(token += 12); cur.roughnessMap = loadTexture(FileName(token)); continue; }
if (!strncmp(token, "roughness", 9)) { parseSep(token += 9); cur.roughness = getFloat(token); cur.Ns = 1.0f/(cur.roughness+1E-6f); continue; }
if (!strncmp(token, "colorMap", 8)) { parseSep(token += 8); cur.map_Kd = loadTexture(FileName(token)); continue; }
if (!strncmp(token, "color", 5)) { parseSep(token += 5); cur.Kd = getVec3f(token); continue; }
if (!strncmp(token, "coat.color", 10)) { parseSep(token += 10); cur.Kd = getVec3f(token); continue; }
if (!strncmp(token, "coat.eta", 8)) { parseSep(token += 8); cur.coat_eta = getFloat(token); continue; }
if (!strncmp(token, "coat.roughnessMap",17)) { parseSep(token += 17); cur.coat_roughnessMap = loadTexture(FileName(token)); continue; }
if (!strncmp(token, "coat.roughness", 14)) { parseSep(token += 14); cur.coat_roughness = getFloat(token); continue; }
if (!strncmp(token, "bumpMap", 7)) { parseSep(token += 7); cur.map_Displ = loadTexture(FileName(token)); continue; }
if (!strncmp(token, "bump", 4)) { parseSep(token += 4); cur.bump = getFloat(token); continue; }
if (!strncmp(token, "eta", 3)) { parseSep(token += 3); cur.eta = getVec3f(token); continue; }
if (!strncmp(token, "k", 1)) { parseSep(token += 1); cur.k = getVec3f(token); continue; }
}
catch (const std::runtime_error& e) {
std::cerr << "Error: " << e.what() << std::endl;
}
}
if (name != "") {
material[name] = cur.select();
material[name]->name = name;
}
cin.close();
}
|
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
leaq 0x60(%rsp), %rax
movq %rax, -0x10(%rax)
xorl %r15d, %r15d
movq %r15, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x1e0(%rsp), %rbx
movq %r15, -0x40(%rbx)
movsd 0x110d53(%rip), %xmm0 # 0x1500c0
movsd %xmm0, -0x38(%rbx)
movl $0x3f800000, %ebp # imm = 0x3F800000
movl %ebp, -0x30(%rbx)
xorps %xmm1, %xmm1
movaps %xmm1, -0x20(%rbx)
movaps 0x110d48(%rip), %xmm0 # 0x1500d0
movaps %xmm0, -0x10(%rbx)
movups %xmm1, 0x98(%rbx)
movl $0x94, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x17600
movl %ebp, 0xa8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0xac(%rbx)
movq %r15, 0xbc(%rbx)
movaps 0x117210(%rip), %xmm0 # 0x1565d0
movups %xmm0, 0xc4(%rbx)
movsd 0x117211(%rip), %xmm0 # 0x1565e0
movsd %xmm0, 0xd4(%rbx)
leaq 0x38(%rsp), %r12
leaq 0x80(%rsp), %rbp
movq %r13, 0x20(%rsp)
leaq 0xf8(%r13), %rax
movq %rax, 0x198(%rsp)
movabsq $0x100002200, %r13 # imm = 0x100002200
movq %r14, %rdi
callq 0x17400
cmpl $-0x1, %eax
je 0x40a5e
movq %r12, 0x28(%rsp)
movq $0x0, 0x30(%rsp)
movb $0x0, 0x38(%rsp)
movq 0x2c0(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x17b40
movsbl %al, %edx
movq %r14, %rdi
leaq 0x28(%rsp), %rsi
callq 0x18810
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0x3f4e1
movq 0x28(%rsp), %rcx
cmpb $0x5c, -0x1(%rcx,%rax)
jne 0x3f4e1
movb $0x20, -0x1(%rcx,%rax)
movq %rbp, 0x70(%rsp)
movq $0x0, 0x78(%rsp)
movb $0x0, 0x80(%rsp)
movq 0x2c0(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x17b40
movsbl %al, %edx
movq %r14, %rdi
leaq 0x70(%rsp), %rsi
callq 0x18810
movq 0x78(%rsp), %r15
testq %r15, %r15
je 0x3f4c9
movq 0x70(%rsp), %rsi
leaq 0x28(%rsp), %rdi
movq %r15, %rdx
callq 0x17300
movq 0x70(%rsp), %rdi
cmpq %rbp, %rdi
je 0x3f4d8
callq 0x17b20
testq %r15, %r15
jne 0x3f44f
movq 0x28(%rsp), %r15
movq %r15, %rdi
leaq 0x11712c(%rip), %rsi # 0x15661c
callq 0x17490
leaq (%r15,%rax), %rdi
cmpb $0x0, (%r15,%rax)
je 0x3f52f
leaq (%r15,%rax), %rcx
decq %rcx
movq %rcx, %rax
incq %rcx
cmpb $0x0, 0x1(%rax)
jne 0x3f507
jmp 0x3f51b
movb $0x0, (%rax)
decq %rax
movzbl (%rax), %ecx
cmpq $0x20, %rcx
ja 0x3f52f
btq %rcx, %r13
jae 0x3f52f
cmpq %rdi, %rax
jae 0x3f515
movq %rdi, 0x8(%rsp)
movzbl (%rdi), %eax
testl %eax, %eax
je 0x3fe45
cmpl $0x23, %eax
je 0x3fe45
movl $0x6, %edx
leaq 0x1170e2(%rip), %rsi # 0x156636
callq 0x17500
movl %eax, %r15d
leaq 0x50(%rsp), %rdi
leaq 0x1170b6(%rip), %rsi # 0x15661e
callq 0x17290
testl %r15d, %r15d
je 0x3f62a
testl %eax, %eax
je 0x40b03
movq 0x8(%rsp), %r15
movl $0x5, %edx
movq %r15, %rdi
leaq 0x1170d8(%rip), %rsi # 0x15666a
callq 0x17500
testl %eax, %eax
je 0x3f7a0
movb (%r15), %r12b
cmpb $0x64, %r12b
jne 0x3f7ce
incq %r15
movq %r15, 0x8(%rsp)
movq %r15, %rdi
leaq 0x11705e(%rip), %r12 # 0x15661c
movq %r12, %rsi
callq 0x17490
testq %rax, %rax
je 0x40474
addq %rax, %r15
movq %r15, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x17490
movq %rax, %r12
addq %r15, %r12
movq %r12, 0x8(%rsp)
movq %r12, %rdi
callq 0x17ef0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4c(%rsp)
movq %r12, %rdi
leaq 0x1171b2(%rip), %rsi # 0x1567bb
callq 0x17110
addq %r12, %rax
movq %rax, 0x8(%rsp)
movss 0x4c(%rsp), %xmm0
movss %xmm0, 0x1a8(%rsp)
jmp 0x3fe40
testl %eax, %eax
je 0x3f68c
leaq 0x70(%rsp), %rdi
leaq 0x1a0(%rsp), %rsi
callq 0x422c0
movq 0x198(%rsp), %r12
movq %r12, %rdi
leaq 0x50(%rsp), %rsi
callq 0x42160
movq %rax, %r15
movq (%rax), %rdi
testq %rdi, %rdi
je 0x3f666
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x70(%rsp), %rax
movq %rax, (%r15)
movq %r12, %rdi
leaq 0x50(%rsp), %rsi
callq 0x42160
movq (%rax), %rdi
addq $0x30, %rdi
leaq 0x50(%rsp), %rsi
callq 0x175e0
movq 0x8(%rsp), %r15
addq $0x6, %r15
movq %r15, 0x8(%rsp)
movq %r15, %rdi
leaq 0x116f78(%rip), %rsi # 0x15661c
callq 0x17490
testq %rax, %rax
je 0x40b21
addq %rax, %r15
movq %r15, 0x8(%rsp)
movq 0x58(%rsp), %r12
movq %r15, %rdi
callq 0x174d0
leaq 0x50(%rsp), %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r15, %rcx
movq %rax, %r8
leaq 0x38(%rsp), %r12
callq 0x183d0
movl $0x120, %edx # imm = 0x120
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x17600
movsd 0x1109c3(%rip), %xmm0 # 0x1500c0
movsd %xmm0, 0x78(%rsp)
movl $0x3f800000, %r15d # imm = 0x3F800000
movl %r15d, 0x80(%rsp)
xorps %xmm1, %xmm1
movaps %xmm1, 0x90(%rsp)
movaps 0x1109ad(%rip), %xmm0 # 0x1500d0
movaps %xmm0, 0xa0(%rsp)
movups %xmm1, 0xc8(%rbp)
movl $0x94, %edx
leaq 0xb0(%rsp), %rdi
xorl %esi, %esi
callq 0x17600
movl %r15d, 0x158(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0xdc(%rbp)
movq $0x0, 0xec(%rbp)
movaps 0x116e66(%rip), %xmm0 # 0x1565d0
movups %xmm0, 0x174(%rsp)
movsd 0x116e66(%rip), %xmm0 # 0x1565e0
movsd %xmm0, 0x184(%rsp)
leaq 0x1a0(%rsp), %rdi
movq %rbx, %rsi
callq 0x42bb4
movq %rbx, %rdi
callq 0x42df4
jmp 0x3fe45
addq $0x5, %r15
movq %r15, 0x8(%rsp)
movq %r15, %rdi
leaq 0x116e69(%rip), %rsi # 0x15661c
callq 0x17490
testq %rax, %rax
je 0x40443
addq %rax, %r15
movq %r15, 0x8(%rsp)
jmp 0x3fe45
movl $0x2, %edx
movq %r15, %rdi
leaq 0x116ee6(%rip), %rsi # 0x1566c3
callq 0x17500
testl %eax, %eax
je 0x3fcd5
movl $0x2, %edx
movq %r15, %rdi
leaq 0x116e77(%rip), %rsi # 0x156670
callq 0x17500
testl %eax, %eax
je 0x3fdc6
movl $0x5, %edx
movq %r15, %rdi
leaq 0x116e5e(%rip), %rsi # 0x156673
callq 0x17500
testl %eax, %eax
je 0x3fd54
movl $0x5, %edx
movq %r15, %rdi
leaq 0x116e5e(%rip), %rsi # 0x15668f
callq 0x17500
testl %eax, %eax
je 0x3fd54
movl $0x6, %edx
movq %r15, %rdi
leaq 0x116e2c(%rip), %rsi # 0x156679
callq 0x17500
testl %eax, %eax
je 0x3fe5d
movl $0x6, %edx
movq %r15, %rdi
leaq 0x116e17(%rip), %rsi # 0x156680
callq 0x17500
testl %eax, %eax
je 0x3fe5d
movl $0x6, %edx
movq %r15, %rdi
leaq 0x116e02(%rip), %rsi # 0x156687
callq 0x17500
testl %eax, %eax
je 0x3fecf
movl $0x6, %edx
movq %r15, %rdi
leaq 0x116ded(%rip), %rsi # 0x15668e
callq 0x17500
testl %eax, %eax
je 0x3fecf
movl $0x6, %edx
movq %r15, %rdi
leaq 0x116dd8(%rip), %rsi # 0x156695
callq 0x17500
testl %eax, %eax
je 0x3ff41
movl $0x6, %edx
movq %r15, %rdi
leaq 0x116dc3(%rip), %rsi # 0x15669c
callq 0x17500
testl %eax, %eax
je 0x3ff41
movl $0x6, %edx
movq %r15, %rdi
leaq 0x116dae(%rip), %rsi # 0x1566a3
callq 0x17500
testl %eax, %eax
je 0x3ff9f
movl $0x6, %edx
movq %r15, %rdi
leaq 0x116d99(%rip), %rsi # 0x1566aa
callq 0x17500
testl %eax, %eax
je 0x3ff9f
movl $0x6, %edx
movq %r15, %rdi
leaq 0x116d84(%rip), %rsi # 0x1566b1
callq 0x17500
testl %eax, %eax
je 0x3ffdd
movl $0x6, %edx
movq %r15, %rdi
leaq 0x116d6f(%rip), %rsi # 0x1566b8
callq 0x17500
testl %eax, %eax
je 0x3ffdd
movl $0x6, %edx
movq %r15, %rdi
leaq 0x116d5a(%rip), %rsi # 0x1566bf
callq 0x17500
testl %eax, %eax
je 0x40067
movl $0x6, %edx
movq %r15, %rdi
leaq 0x116d45(%rip), %rsi # 0x1566c6
callq 0x17500
testl %eax, %eax
je 0x40067
movl $0x9, %edx
movq %r15, %rdi
leaq 0x116d30(%rip), %rsi # 0x1566cd
callq 0x17500
testl %eax, %eax
je 0x400c5
movl $0x9, %edx
movq %r15, %rdi
leaq 0x116d1e(%rip), %rsi # 0x1566d7
callq 0x17500
testl %eax, %eax
je 0x400c5
movl $0x2, %edx
movq %r15, %rdi
leaq 0x116ca8(%rip), %rsi # 0x15667d
callq 0x17500
testl %eax, %eax
je 0x40123
movl $0x2, %edx
movq %r15, %rdi
leaq 0x116c9a(%rip), %rsi # 0x15668b
callq 0x17500
testl %eax, %eax
je 0x4016b
movl $0x2, %edx
movq %r15, %rdi
leaq 0x116c8c(%rip), %rsi # 0x156699
callq 0x17500
testl %eax, %eax
je 0x401b3
movl $0x2, %edx
movq %r15, %rdi
leaq 0x116c7e(%rip), %rsi # 0x1566a7
callq 0x17500
testl %eax, %eax
je 0x401fb
movl $0x2, %edx
movq %r15, %rdi
leaq 0x116c70(%rip), %rsi # 0x1566b5
callq 0x17500
testl %eax, %eax
je 0x40215
movl $0x4, %edx
movq %r15, %rdi
leaq 0x11b5fa(%rip), %rsi # 0x15b05b
callq 0x17500
testl %eax, %eax
je 0x4025d
movl $0x9, %edx
movq %r15, %rdi
leaq 0x116ca0(%rip), %rsi # 0x15671d
callq 0x17500
testl %eax, %eax
je 0x40326
movl $0x3, %edx
movq %r15, %rdi
leaq 0x116c7c(%rip), %rsi # 0x156715
callq 0x17500
testl %eax, %eax
je 0x40343
movl $0xd, %edx
movq %r15, %rdi
leaq 0x116c64(%rip), %rsi # 0x156719
callq 0x17500
testl %eax, %eax
je 0x40383
movl $0xc, %edx
movq %r15, %rdi
leaq 0x116c56(%rip), %rsi # 0x156727
callq 0x17500
testl %eax, %eax
je 0x403eb
movl $0x10, %edx
movq %r15, %rdi
leaq 0x116c47(%rip), %rsi # 0x156734
callq 0x17500
testl %eax, %eax
je 0x40495
movl $0xa, %edx
movq %r15, %rdi
leaq 0x116c3c(%rip), %rsi # 0x156745
callq 0x17500
testl %eax, %eax
je 0x404bf
movl $0x11, %edx
movq %r15, %rdi
leaq 0x116c2b(%rip), %rsi # 0x156750
callq 0x17500
testl %eax, %eax
je 0x40564
movl $0xc, %edx
movq %r15, %rdi
leaq 0x116c21(%rip), %rsi # 0x156762
callq 0x17500
testl %eax, %eax
je 0x405c3
movl $0xc, %edx
movq %r15, %rdi
leaq 0x116c34(%rip), %rsi # 0x156791
callq 0x17500
testl %eax, %eax
je 0x405fd
movl $0x9, %edx
movq %r15, %rdi
leaq 0x116c2a(%rip), %rsi # 0x1567a3
callq 0x17500
testl %eax, %eax
je 0x40676
movl $0x8, %edx
movq %r15, %rdi
leaq 0x116bda(%rip), %rsi # 0x15676f
callq 0x17500
testl %eax, %eax
je 0x406c3
movl $0x5, %edx
movq %r15, %rdi
leaq 0x116bcc(%rip), %rsi # 0x15677d
callq 0x17500
testl %eax, %eax
je 0x40735
movl $0xa, %edx
movq %r15, %rdi
leaq 0x116bab(%rip), %rsi # 0x156778
callq 0x17500
testl %eax, %eax
je 0x40752
movl $0x8, %edx
movq %r15, %rdi
leaq 0x116b9a(%rip), %rsi # 0x156783
callq 0x17500
testl %eax, %eax
je 0x4076f
movl $0x11, %edx
movq %r15, %rdi
leaq 0x116b87(%rip), %rsi # 0x15678c
callq 0x17500
testl %eax, %eax
je 0x4079f
movl $0xe, %edx
movq %r15, %rdi
leaq 0x116b7d(%rip), %rsi # 0x15679e
callq 0x17500
testl %eax, %eax
je 0x407f7
movl $0x7, %edx
movq %r15, %rdi
leaq 0x116b70(%rip), %rsi # 0x1567ad
callq 0x17500
testl %eax, %eax
je 0x40827
movl $0x4, %edx
movq %r15, %rdi
leaq 0x116b5c(%rip), %rsi # 0x1567b5
callq 0x17500
testl %eax, %eax
je 0x40862
movl $0x3, %edx
movq %r15, %rdi
leaq 0x116b13(%rip), %rsi # 0x156788
callq 0x17500
testl %eax, %eax
je 0x40892
cmpb $0x6b, %r12b
leaq 0x38(%rsp), %r12
jne 0x3fe45
incq %r15
movq %r15, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x3f0c9
leaq 0x70(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3ef94
movsd 0x70(%rsp), %xmm0
movsd %xmm0, 0x2b0(%rsp)
movss 0x78(%rsp), %xmm0
movss %xmm0, 0x2b8(%rsp)
jmp 0x3fe45
addq $0x2, %r15
movq %r15, 0x8(%rsp)
movq %r15, %rdi
leaq 0x116934(%rip), %r12 # 0x15661c
movq %r12, %rsi
callq 0x17490
testq %rax, %rax
je 0x40543
addq %rax, %r15
movq %r15, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x17490
movq %rax, %r12
addq %r15, %r12
movq %r12, 0x8(%rsp)
movq %r12, %rdi
callq 0x17ef0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4c(%rsp)
movq %r12, %rdi
leaq 0x116a88(%rip), %rsi # 0x1567bb
callq 0x17110
addq %r12, %rax
movq %rax, 0x8(%rsp)
movss 0x4c(%rsp), %xmm0
movss %xmm0, 0x1ac(%rsp)
jmp 0x3fe40
addq $0x5, %r15
movq %r15, 0x8(%rsp)
movq %r15, %rdi
leaq 0x1168b5(%rip), %rsi # 0x15661c
callq 0x17490
testq %rax, %rax
je 0x40581
addq %rax, %r15
movq %r15, 0x8(%rsp)
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
leaq 0x38(%rsp), %r12
callq 0xdcb2c
leaq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %rbx, %rdx
callq 0x40c52
movaps 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, 0x10(%rsp)
movq 0x208(%rsp), %rdi
movaps %xmm0, 0x200(%rsp)
jmp 0x40036
addq $0x2, %r15
movq %r15, 0x8(%rsp)
movq %r15, %rdi
leaq 0x116843(%rip), %r12 # 0x15661c
movq %r12, %rsi
callq 0x17490
testq %rax, %rax
je 0x405a2
addq %rax, %r15
movq %r15, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x17490
movq %rax, %r12
addq %r15, %r12
movq %r12, 0x8(%rsp)
movq %r12, %rdi
callq 0x17ef0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4c(%rsp)
movq %r12, %rdi
leaq 0x116997(%rip), %rsi # 0x1567bb
callq 0x17110
addq %r12, %rax
movq %rax, 0x8(%rsp)
movss 0x4c(%rsp), %xmm0
movss %xmm0, 0x1b0(%rsp)
leaq 0x38(%rsp), %r12
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x3f402
callq 0x17b20
jmp 0x3f402
addq $0x6, %r15
movq %r15, 0x8(%rsp)
movq %r15, %rdi
leaq 0x1167ac(%rip), %rsi # 0x15661c
callq 0x17490
testq %rax, %rax
je 0x40655
addq %rax, %r15
movq %r15, 0x8(%rsp)
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
leaq 0x38(%rsp), %r12
callq 0xdcb2c
leaq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %rbx, %rdx
callq 0x40c52
movaps 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, 0x10(%rsp)
movq 0x218(%rsp), %rdi
movaps %xmm0, 0x210(%rsp)
jmp 0x40036
addq $0x6, %r15
movq %r15, 0x8(%rsp)
movq %r15, %rdi
leaq 0x11673a(%rip), %rsi # 0x15661c
callq 0x17490
testq %rax, %rax
je 0x406fe
addq %rax, %r15
movq %r15, 0x8(%rsp)
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
leaq 0x38(%rsp), %r12
callq 0xdcb2c
leaq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %rbx, %rdx
callq 0x40c52
movaps 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, 0x10(%rsp)
movq 0x228(%rsp), %rdi
movaps %xmm0, 0x220(%rsp)
jmp 0x40036
addq $0x6, %r15
movq %r15, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %r12
callq 0x3f0c9
movq 0x8(%rsp), %rsi
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
callq 0xdcb2c
leaq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %rbx, %rdx
callq 0x40c52
movaps 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, 0x10(%rsp)
movq 0x238(%rsp), %rdi
movaps %xmm0, 0x230(%rsp)
jmp 0x40036
addq $0x6, %r15
movq %r15, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %r12
callq 0x3f0c9
movq 0x8(%rsp), %rsi
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
callq 0xdcb2c
leaq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %rbx, %rdx
callq 0x40c52
jmp 0x40019
addq $0x6, %r15
movq %r15, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %r12
callq 0x3f0c9
movq 0x8(%rsp), %rsi
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
callq 0xdcb2c
leaq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %rbx, %rdx
callq 0x40c52
movaps 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, 0x10(%rsp)
movq 0x248(%rsp), %rdi
movaps %xmm0, 0x240(%rsp)
testq %rdi, %rdi
je 0x40040
callq 0x1b2ee
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x4004f
callq 0x1b2ee
movq 0x70(%rsp), %rdi
cmpq %rbp, %rdi
je 0x3fe45
callq 0x17b20
jmp 0x3fe45
addq $0x6, %r15
movq %r15, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %r12
callq 0x3f0c9
movq 0x8(%rsp), %rsi
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
callq 0xdcb2c
leaq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %rbx, %rdx
callq 0x40c52
movaps 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, 0x10(%rsp)
movq 0x258(%rsp), %rdi
movaps %xmm0, 0x250(%rsp)
jmp 0x40036
addq $0x9, %r15
movq %r15, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %r12
callq 0x3f0c9
movq 0x8(%rsp), %rsi
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
callq 0xdcb2c
leaq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %rbx, %rdx
callq 0x40c52
movaps 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, 0x10(%rsp)
movq 0x268(%rsp), %rdi
movaps %xmm0, 0x260(%rsp)
jmp 0x40036
addq $0x2, %r15
movq %r15, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %r12
callq 0x3f0c9
leaq 0x70(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3ef94
movsd 0x74(%rsp), %xmm0
movss 0x70(%rsp), %xmm1
shufps $0x4c, %xmm0, %xmm1 # xmm1 = xmm1[0,3],xmm0[0,1]
shufps $0x78, %xmm1, %xmm1 # xmm1 = xmm1[0,2,3,1]
movaps %xmm1, 0x1c0(%rsp)
jmp 0x3fe45
addq $0x2, %r15
movq %r15, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %r12
callq 0x3f0c9
leaq 0x70(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3ef94
movsd 0x74(%rsp), %xmm0
movss 0x70(%rsp), %xmm1
shufps $0x4c, %xmm0, %xmm1 # xmm1 = xmm1[0,3],xmm0[0,1]
shufps $0x78, %xmm1, %xmm1 # xmm1 = xmm1[0,2,3,1]
movaps %xmm1, 0x1d0(%rsp)
jmp 0x3fe45
addq $0x2, %r15
movq %r15, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %r12
callq 0x3f0c9
leaq 0x70(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3ef94
movsd 0x74(%rsp), %xmm0
movss 0x70(%rsp), %xmm1
shufps $0x4c, %xmm0, %xmm1 # xmm1 = xmm1[0,3],xmm0[0,1]
shufps $0x78, %xmm1, %xmm1 # xmm1 = xmm1[0,2,3,1]
movaps %xmm1, 0x1e0(%rsp)
jmp 0x3fe45
addq $0x2, %r15
movq %r15, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %r12
callq 0x3f0c9
jmp 0x4022d
addq $0x2, %r15
movq %r15, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %r12
callq 0x3f0c9
leaq 0x70(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3ef94
movsd 0x74(%rsp), %xmm0
movss 0x70(%rsp), %xmm1
shufps $0x4c, %xmm0, %xmm1 # xmm1 = xmm1[0,3],xmm0[0,1]
shufps $0x78, %xmm1, %xmm1 # xmm1 = xmm1[0,2,3,1]
movaps %xmm1, 0x1f0(%rsp)
jmp 0x3fe45
addq $0x4, %r15
movq %r15, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x3f0c9
movq 0x8(%rsp), %rsi
leaq 0x70(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x17450
leaq 0x70(%rsp), %rdi
leaq 0x116451(%rip), %rsi # 0x1566e1
callq 0x17290
testl %eax, %eax
je 0x40373
leaq 0x70(%rsp), %rdi
leaq 0x11643e(%rip), %rsi # 0x1566e7
callq 0x17290
testl %eax, %eax
je 0x403db
leaq 0x70(%rsp), %rdi
leaq 0x11642b(%rip), %rsi # 0x1566ed
callq 0x17290
testl %eax, %eax
je 0x40464
leaq 0x70(%rsp), %rdi
leaq 0x116418(%rip), %rsi # 0x1566f3
callq 0x17290
testl %eax, %eax
je 0x404b2
leaq 0x70(%rsp), %rdi
leaq 0x11640d(%rip), %rsi # 0x156701
callq 0x17290
testl %eax, %eax
je 0x40316
leaq 0x70(%rsp), %rdi
leaq 0x116403(%rip), %rsi # 0x15670c
callq 0x17290
testl %eax, %eax
jne 0x4052b
movl $0x0, 0x1a0(%rsp)
jmp 0x4052b
addq $0x9, %r15
movq %r15, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %r12
callq 0x3f0c9
jmp 0x40183
addq $0x3, %r15
movq %r15, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %r12
callq 0x3f0c9
leaq 0x8(%rsp), %rdi
callq 0x3f278
movss %xmm0, 0x1b0(%rsp)
jmp 0x3fe45
movl $0x1, 0x1a0(%rsp)
jmp 0x4052b
addq $0xd, %r15
movq %r15, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x3f0c9
movq 0x8(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0xdcb2c
leaq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0x40c52
movaps 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, 0x10(%rsp)
movq 0x228(%rsp), %rdi
movaps %xmm0, 0x220(%rsp)
jmp 0x40512
movl $0x2, 0x1a0(%rsp)
jmp 0x4052b
addq $0xc, %r15
movq %r15, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x3f0c9
movq 0x8(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0xdcb2c
leaq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0x40c52
movaps 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, 0x10(%rsp)
movq 0x238(%rsp), %rdi
movaps %xmm0, 0x230(%rsp)
jmp 0x40512
movl $0x10, %edi
callq 0x17530
movq %rax, %r12
movq %rax, %rdi
leaq 0x116381(%rip), %rsi # 0x1567db
callq 0x17430
jmp 0x4071a
movl $0x3, 0x1a0(%rsp)
jmp 0x4052b
movl $0x10, %edi
callq 0x17530
movq %rax, %r12
movq %rax, %rdi
leaq 0x116350(%rip), %rsi # 0x1567db
callq 0x17430
jmp 0x4071a
addq $0x10, %r15
movq %r15, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %r12
callq 0x3f0c9
jmp 0x3fe45
movl $0x4, 0x1a0(%rsp)
jmp 0x4052b
addq $0xa, %r15
movq %r15, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x3f0c9
movq 0x8(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0xdcb2c
leaq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0x40c52
movaps 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, 0x10(%rsp)
movq 0x268(%rsp), %rdi
movaps %xmm0, 0x260(%rsp)
testq %rdi, %rdi
je 0x4051c
callq 0x1b2ee
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x4052b
callq 0x1b2ee
movq 0x70(%rsp), %rdi
cmpq %rbp, %rdi
je 0x3fe40
callq 0x17b20
jmp 0x3fe40
movl $0x10, %edi
callq 0x17530
movq %rax, %r12
movq %rax, %rdi
leaq 0x116281(%rip), %rsi # 0x1567db
callq 0x17430
jmp 0x4071a
addq $0x11, %r15
movq %r15, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %r12
callq 0x3f0c9
jmp 0x4022d
movl $0x10, %edi
callq 0x17530
movq %rax, %r12
movq %rax, %rdi
leaq 0x116243(%rip), %rsi # 0x1567db
callq 0x17430
jmp 0x4071a
movl $0x10, %edi
callq 0x17530
movq %rax, %r12
movq %rax, %rdi
leaq 0x116222(%rip), %rsi # 0x1567db
callq 0x17430
jmp 0x4071a
addq $0xc, %r15
movq %r15, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %r12
callq 0x3f0c9
leaq 0x8(%rsp), %rdi
callq 0x3f278
xorps %xmm1, %xmm1
movss %xmm0, %xmm1 # xmm1 = xmm0[0],xmm1[1,2,3]
shufps $0x40, %xmm1, %xmm0 # xmm0 = xmm0[0,0],xmm1[0,1]
movaps %xmm0, 0x1f0(%rsp)
jmp 0x3fe45
addq $0xc, %r15
movq %r15, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x3f0c9
movq 0x8(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0xdcb2c
leaq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0x40c52
movaps 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, 0x10(%rsp)
movq 0x280(%rsp), %rdi
movups %xmm0, 0x278(%rsp)
jmp 0x40512
movl $0x10, %edi
callq 0x17530
movq %rax, %r12
movq %rax, %rdi
leaq 0x11616f(%rip), %rsi # 0x1567db
callq 0x17430
jmp 0x4071a
addq $0x9, %r15
movq %r15, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %r12
callq 0x3f0c9
leaq 0x8(%rsp), %rdi
callq 0x3f278
movss %xmm0, 0x270(%rsp)
addss 0x115f57(%rip), %xmm0 # 0x156600
movss 0x10fa4f(%rip), %xmm1 # 0x150100
divss %xmm0, %xmm1
movss %xmm1, 0x1ac(%rsp)
jmp 0x3fe45
addq $0x8, %r15
movq %r15, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x3f0c9
movq 0x8(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0xdcb2c
leaq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0x40c52
jmp 0x403b9
movl $0x10, %edi
callq 0x17530
movq %rax, %r12
movq %rax, %rdi
leaq 0x1160c6(%rip), %rsi # 0x1567db
callq 0x17430
movq %r12, %rdi
movq 0x1908cc(%rip), %rsi # 0x1d0ff0
movq 0x190875(%rip), %rdx # 0x1d0fa0
callq 0x18680
jmp 0x40b53
addq $0x5, %r15
movq %r15, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %r12
callq 0x3f0c9
jmp 0x40183
addq $0xa, %r15
movq %r15, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %r12
callq 0x3f0c9
jmp 0x40183
addq $0x8, %r15
movq %r15, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %r12
callq 0x3f0c9
leaq 0x8(%rsp), %rdi
callq 0x3f278
movss %xmm0, 0x288(%rsp)
jmp 0x3fe45
addq $0x11, %r15
movq %r15, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x3f0c9
movq 0x8(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0xdcb2c
leaq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0x40c52
movaps 0x10(%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, 0x10(%rsp)
movq 0x298(%rsp), %rdi
movaps %xmm0, 0x290(%rsp)
jmp 0x40512
addq $0xe, %r15
movq %r15, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %r12
callq 0x3f0c9
leaq 0x8(%rsp), %rdi
callq 0x3f278
movss %xmm0, 0x28c(%rsp)
jmp 0x3fe45
addq $0x7, %r15
movq %r15, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x3f0c9
movq 0x8(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0xdcb2c
leaq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0x40c52
jmp 0x404f5
addq $0x4, %r15
movq %r15, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %r12
callq 0x3f0c9
leaq 0x8(%rsp), %rdi
callq 0x3f278
movss %xmm0, 0x2a0(%rsp)
jmp 0x3fe45
addq $0x3, %r15
movq %r15, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %r12
callq 0x3f0c9
leaq 0x70(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3ef94
movsd 0x70(%rsp), %xmm0
movsd %xmm0, 0x2a4(%rsp)
movss 0x78(%rsp), %xmm0
movss %xmm0, 0x2ac(%rsp)
jmp 0x3fe45
jmp 0x40920
jmp 0x4094b
jmp 0x40920
jmp 0x4094b
jmp 0x40920
jmp 0x4094b
jmp 0x40920
jmp 0x4094b
jmp 0x40920
jmp 0x4094b
jmp 0x40920
jmp 0x4094b
jmp 0x40920
jmp 0x4094b
jmp 0x4094b
jmp 0x40920
jmp 0x4094b
jmp 0x40920
jmp 0x4094b
jmp 0x40920
jmp 0x4094b
jmp 0x40920
jmp 0x4094b
jmp 0x40920
jmp 0x4094b
jmp 0x4093b
jmp 0x40920
jmp 0x4094b
jmp 0x4093b
jmp 0x40920
jmp 0x4094b
jmp 0x4093b
jmp 0x4093b
jmp 0x4093b
movq %rdx, %rbx
movq %rax, %r15
movq 0x70(%rsp), %rdi
cmpq %rbp, %rdi
je 0x40951
callq 0x17b20
jmp 0x40951
jmp 0x4094b
jmp 0x4093b
movq %rdx, %rbx
movq %rax, %r15
movq %r12, %rdi
callq 0x177b0
jmp 0x40951
movq %rdx, %rbx
movq %rax, %r15
cmpl $0x1, %ebx
jne 0x40bea
movq %r15, %rdi
callq 0x17470
movq %rax, %r15
movl $0x7, %edx
movq 0x190677(%rip), %rdi # 0x1d0fe8
leaq 0x114c5a(%rip), %rsi # 0x1555d2
callq 0x17d70
movq (%r15), %rax
movq %r15, %rdi
callq *0x10(%rax)
movq 0x19065b(%rip), %rdi # 0x1d0fe8
movq %rax, %rsi
callq 0x17b70
movq %rax, %rdi
callq 0x17520
leaq 0x38(%rsp), %r12
callq 0x18590
jmp 0x3fe45
movq 0x190635(%rip), %rdi # 0x1d0fe8
leaq 0x114e88(%rip), %rsi # 0x155842
movl $0xc, %edx
callq 0x17d70
leaq 0x1b0(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x1a0(%rsp), %rdi
callq 0x1ac76
movq 0x1a0(%rsp), %rsi
movq 0x1a8(%rsp), %rdx
movq 0x1905ea(%rip), %rdi # 0x1d0fe8
callq 0x17d70
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x17b40
movsbl %al, %esi
movq %rbx, %rdi
callq 0x17050
movq %rax, %rdi
callq 0x17770
movq 0x1a0(%rsp), %rdi
cmpq %r14, %rdi
je 0x40a3f
callq 0x17b20
leaq 0x2c0(%rsp), %rdi
callq 0x17230
addq $0x4c8, %rsp # imm = 0x4C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x115bb9(%rip), %rsi # 0x15661e
leaq 0x50(%rsp), %rdi
callq 0x17290
testl %eax, %eax
je 0x40ad1
leaq 0x70(%rsp), %rdi
leaq 0x1a0(%rsp), %rsi
callq 0x422c0
leaq 0x50(%rsp), %rsi
movq 0x198(%rsp), %r14
movq %r14, %rdi
callq 0x42160
movq %rax, %rbx
movq (%rax), %rdi
testq %rdi, %rdi
je 0x40aab
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x70(%rsp), %rax
movq %rax, (%rbx)
leaq 0x50(%rsp), %rsi
movq %r14, %rdi
callq 0x42160
movq (%rax), %rdi
addq $0x30, %rdi
leaq 0x50(%rsp), %rsi
callq 0x175e0
leaq 0x2c0(%rsp), %rdi
callq 0x171d0
leaq 0x1a0(%rsp), %rdi
callq 0x42df4
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rax
cmpq %rax, %rdi
jne 0x40a3a
jmp 0x40a3f
movl $0x10, %edi
callq 0x17530
movq %rax, %rbx
leaq 0x115b26(%rip), %rsi # 0x15663d
movq %rax, %rdi
callq 0x17430
jmp 0x40b3d
movl $0x10, %edi
callq 0x17530
movq %rax, %rbx
leaq 0x115ca6(%rip), %rsi # 0x1567db
movq %rax, %rdi
callq 0x17430
movq 0x1904ac(%rip), %rsi # 0x1d0ff0
movq 0x190455(%rip), %rdx # 0x1d0fa0
movq %rbx, %rdi
callq 0x18680
jmp 0x40be7
movq %rax, %r15
callq 0x18590
jmp 0x40bea
jmp 0x40bcb
jmp 0x40bf1
jmp 0x40b92
movq %rax, %r15
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x40c1c
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x40c1c
jmp 0x40bcb
jmp 0x40b9a
jmp 0x40bf1
jmp 0x40be7
movq %rax, %r15
jmp 0x40c3d
movq %rax, %r15
movq %rbx, %rdi
callq 0x177b0
jmp 0x40bea
movq %rax, %r15
leaq 0x70(%rsp), %rdi
callq 0x42df4
jmp 0x40bea
movq %rax, %r15
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x40bea
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x40bea
movq %rax, %rdi
callq 0x1a679
movq %rax, %r15
movq 0x1a0(%rsp), %rdi
cmpq %r14, %rdi
jne 0x40c38
jmp 0x40c3d
jmp 0x40be7
movq %rax, %r15
leaq 0x38(%rsp), %r12
jmp 0x40c0d
movq %rax, %r15
jmp 0x40c1c
movq %rax, %r15
jmp 0x40c0d
movq %rax, %r15
movq 0x70(%rsp), %rdi
cmpq %rbp, %rdi
je 0x40c0d
callq 0x17b20
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x40c1c
callq 0x17b20
leaq 0x1a0(%rsp), %rdi
callq 0x42df4
movq 0x50(%rsp), %rdi
leaq 0x60(%rsp), %rax
cmpq %rax, %rdi
je 0x40c3d
callq 0x17b20
leaq 0x2c0(%rsp), %rdi
callq 0x17230
movq %r15, %rdi
callq 0x18710
|
/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 %rax, 0x50(%rdi)
movw $0x1, 0x58(%rdi)
movl $0xffffffff, 0x5c(%rdi) # imm = 0xFFFFFFFF
movq %rax, 0x60(%rdi)
leaq 0x18b627(%rip), %rax # 0x1ce808
addq $0x10, %rax
movq %rax, (%rdi)
movlps %xmm0, 0x68(%rdi)
leaq 0x70(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rdi)
movups %xmm0, 0x80(%rdi)
movups %xmm0, 0x90(%rdi)
movups %xmm0, 0xa0(%rdi)
movups %xmm0, 0xb0(%rdi)
movups %xmm0, 0xc0(%rdi)
movq (%rsi), %rdi
movq %rdi, 0xd0(%rbx)
testq %rdi, %rdi
je 0x4322f
movq (%rdi), %rax
callq *0x10(%rax)
testq %r15, %r15
je 0x43276
leaq 0x8(%rsp), %r13
xorps %xmm0, %xmm0
movq %rsp, %r12
movups %xmm0, (%r13)
movq $0x0, 0x10(%r13)
movq %r14, %rdi
movq %r12, %rsi
callq 0x43f22
movq 0x18(%rsp), %rdi
callq 0xdc3f5
xorps %xmm0, %xmm0
movups %xmm0, (%r13)
movq $0x0, 0x10(%r13)
decq %r15
jne 0x4323f
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r15
jmp 0x432b8
movq %rax, %r15
movq 0x18(%rsp), %rdi
callq 0xdc3f5
xorps %xmm0, %xmm0
movups %xmm0, (%r13)
movq $0x0, 0x10(%r13)
movq 0xd0(%rbx), %rdi
testq %rdi, %rdi
je 0x432b8
movq (%rdi), %rax
callq *0x18(%rax)
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0x432c9
callq 0x17b20
movq 0xa0(%rbx), %rdi
testq %rdi, %rdi
je 0x432da
callq 0x17b20
leaq 0x88(%rbx), %rdi
callq 0x43efa
movq %r14, %rdi
callq 0x43efa
movq %rbx, %rdi
callq 0x34eac
movq %r15, %rdi
callq 0x18710
jmp 0x43302
jmp 0x43302
movq %rax, %rdi
callq 0x1a679
|
/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 %r13, %rsi
callq 0x35014
leaq 0x18ab3a(%rip), %rax # 0x1ce760
addq $0x10, %rax
movq %rax, (%r14)
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x43c3c
callq 0x17b20
leaq 0x18a4dd(%rip), %rax # 0x1ce120
movq %rax, (%r14)
movl $0x8, 0x70(%r14)
movaps (%r12), %xmm0
movaps %xmm0, 0x80(%r14)
movaps (%r15), %xmm0
movaps %xmm0, 0x90(%r14)
movaps (%rbx), %xmm0
movaps %xmm0, 0xa0(%r14)
movl $0x0, 0xb0(%r14)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x43c9e
callq 0x17b20
movq %rbx, %rdi
callq 0x18710
|
/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(%r14), %rdx
subq %rcx, %rdx
sarq $0x5, %rdx
imulq 0x8(%rcx), %rdx
addq %rax, %rdx
shlq $0x4, %rdx
addq %rdx, 0x28(%rbx)
movq 0xd0(%r14), %rdi
movq (%rdi), %rax
movq 0x48(%rax), %rax
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
|
/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 0x8(%rax), %rcx
shlq $0x4, %rcx
addq %rcx, 0x58(%rbx)
movq 0xa8(%r14), %rdi
movq (%rdi), %rax
movq 0x48(%rax), %rax
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
nop
|
/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
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
cmpq $0x2, (%rax,%r14)
jb 0x48f65
movq 0x80(%rbx), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
incq %r15
movq 0x68(%rbx), %rax
movq 0x70(%rbx), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
imulq %r12, %rcx
addq $0x30, %r14
cmpq %rcx, %r15
jb 0x48f51
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/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 (const auto& child : groupNode->children)
optimize_animation(child);
}
else if (Ref<SceneGraph::TriangleMeshNode> mesh = node.dynamicCast<SceneGraph::TriangleMeshNode>())
{
bool equal = true;
for (size_t i=1; i<mesh->numTimeSteps(); i++)
equal &= mesh->positions[0] == mesh->positions[i];
if (equal)
mesh->positions.resize(1);
}
else if (Ref<SceneGraph::QuadMeshNode> mesh = node.dynamicCast<SceneGraph::QuadMeshNode>())
{
bool equal = true;
for (size_t i=1; i<mesh->numTimeSteps(); i++)
equal &= mesh->positions[0] == mesh->positions[i];
if (equal)
mesh->positions.resize(1);
}
else if (Ref<SceneGraph::HairSetNode> mesh = node.dynamicCast<SceneGraph::HairSetNode>())
{
bool equal = true;
for (size_t i=1; i<mesh->numTimeSteps(); i++)
equal &= mesh->positions[0] == mesh->positions[i];
if (equal)
mesh->positions.resize(1);
}
else if (Ref<SceneGraph::PointSetNode> mesh = node.dynamicCast<SceneGraph::PointSetNode>())
{
bool equal = true;
for (size_t i=1; i<mesh->numTimeSteps(); i++)
equal &= mesh->positions[0] == mesh->positions[i];
if (equal)
mesh->positions.resize(1);
}
else if (Ref<SceneGraph::SubdivMeshNode> mesh = node.dynamicCast<SceneGraph::SubdivMeshNode>())
{
bool equal = true;
for (size_t i=1; i<mesh->numTimeSteps(); i++)
equal &= mesh->positions[0] == mesh->positions[i];
if (equal)
mesh->positions.resize(1);
}
}
|
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 0x4bf25
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
testq %rbx, %rbx
je 0x4bf65
movq 0x98(%rbx), %r14
movq %r14, 0x30(%rsp)
testq %r14, %r14
je 0x4bf44
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
leaq 0x30(%rsp), %rdi
callq 0x4bee2
testq %r14, %r14
je 0x4c3d5
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
jmp 0x4c3d5
movq (%rbp), %rdi
testq %rdi, %rdi
je 0x4bf88
leaq 0x1823c3(%rip), %rsi # 0x1ce338
leaq 0x18270c(%rip), %rdx # 0x1ce688
xorl %ecx, %ecx
callq 0x17d50
movq %rax, %r14
jmp 0x4bf8b
xorl %r14d, %r14d
testq %r14, %r14
je 0x4bf99
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
testq %r14, %r14
je 0x4bff1
movq 0x68(%r14), %r13
movq 0x70(%r14), %rbp
cmpq %rbp, %r13
je 0x4c3c7
leaq 0x28(%rsp), %r15
movq (%r13), %r12
movq %r12, 0x28(%rsp)
testq %r12, %r12
je 0x4bfcc
movq (%r12), %rax
movq %r12, %rdi
callq *0x10(%rax)
movq %r15, %rdi
callq 0x4bee2
testq %r12, %r12
je 0x4bfe3
movq (%r12), %rax
movq %r12, %rdi
callq *0x18(%rax)
addq $0x8, %r13
cmpq %rbp, %r13
jne 0x4bfb4
jmp 0x4c3c7
movq (%rbp), %rdi
testq %rdi, %rdi
je 0x4c014
leaq 0x182337(%rip), %rsi # 0x1ce338
leaq 0x182888(%rip), %rdx # 0x1ce890
xorl %ecx, %ecx
callq 0x17d50
movq %rax, %r15
jmp 0x4c017
xorl %r15d, %r15d
testq %r15, %r15
je 0x4c025
movq (%r15), %rax
movq %r15, %rdi
callq *0x10(%rax)
testq %r15, %r15
je 0x4c08d
movq 0x70(%r15), %rdi
movq 0x78(%r15), %rax
subq %rdi, %rax
cmpq $0x21, %rax
jb 0x4c07a
movb $0x1, %bpl
movl $0x1, %r12d
movl $0x20, %r13d
leaq (%rdi,%r13), %rsi
callq 0x551cf
andb %al, %bpl
incq %r12
movq 0x70(%r15), %rdi
movq 0x78(%r15), %rax
subq %rdi, %rax
sarq $0x5, %rax
addq $0x20, %r13
cmpq %rax, %r12
jb 0x4c04a
testb %bpl, %bpl
je 0x4c3b9
leaq 0x70(%r15), %rdi
movl $0x1, %esi
callq 0x43134
jmp 0x4c3b9
movq (%rbp), %rdi
testq %rdi, %rdi
je 0x4c0b0
leaq 0x18229b(%rip), %rsi # 0x1ce338
leaq 0x18288c(%rip), %rdx # 0x1ce930
xorl %ecx, %ecx
callq 0x17d50
movq %rax, %r12
jmp 0x4c0b3
xorl %r12d, %r12d
testq %r12, %r12
je 0x4c0c2
movq (%r12), %rax
movq %r12, %rdi
callq *0x10(%rax)
testq %r12, %r12
je 0x4c13c
movq 0x70(%r12), %rdi
movq 0x78(%r12), %rax
subq %rdi, %rax
cmpq $0x21, %rax
jb 0x4c128
movq %r12, 0x8(%rsp)
movb $0x1, %bpl
movl $0x1, %r13d
movl $0x20, %r12d
leaq (%rdi,%r12), %rsi
callq 0x551cf
andb %al, %bpl
incq %r13
movq 0x8(%rsp), %rax
movq 0x70(%rax), %rdi
movq 0x78(%rax), %rax
subq %rdi, %rax
sarq $0x5, %rax
addq $0x20, %r12
cmpq %rax, %r13
jb 0x4c0ee
testb %bpl, %bpl
movq 0x8(%rsp), %r12
je 0x4c3aa
leaq 0x70(%r12), %rdi
movl $0x1, %esi
callq 0x43134
jmp 0x4c3aa
movq (%rbp), %rdi
testq %rdi, %rdi
je 0x4c15f
leaq 0x1821ec(%rip), %rsi # 0x1ce338
leaq 0x18291d(%rip), %rdx # 0x1cea70
xorl %ecx, %ecx
callq 0x17d50
movq %rax, %r13
jmp 0x4c162
xorl %r13d, %r13d
testq %r13, %r13
je 0x4c171
movq (%r13), %rax
movq %r13, %rdi
callq *0x10(%rax)
testq %r13, %r13
je 0x4c1fc
movq 0x78(%r13), %rdi
movq 0x80(%r13), %rax
subq %rdi, %rax
cmpq $0x21, %rax
jb 0x4c1e9
movq %r13, 0x10(%rsp)
movq %r12, 0x8(%rsp)
movb $0x1, %bpl
movl $0x1, %r13d
movl $0x20, %r12d
leaq (%rdi,%r12), %rsi
callq 0x55232
andb %al, %bpl
incq %r13
movq 0x10(%rsp), %rax
movq 0x78(%rax), %rdi
movq 0x80(%rax), %rax
subq %rdi, %rax
sarq $0x5, %rax
addq $0x20, %r12
cmpq %rax, %r13
jb 0x4c1a7
testb %bpl, %bpl
movq 0x8(%rsp), %r12
movq 0x10(%rsp), %r13
je 0x4c39b
leaq 0x78(%r13), %rdi
movl $0x1, %esi
callq 0x54ebc
jmp 0x4c39b
movq (%rbp), %rdi
testq %rdi, %rdi
je 0x4c21c
leaq 0x18212c(%rip), %rsi # 0x1ce338
leaq 0x1828fd(%rip), %rdx # 0x1ceb10
xorl %ecx, %ecx
callq 0x17d50
jmp 0x4c21e
xorl %eax, %eax
testq %rax, %rax
movq %rax, 0x18(%rsp)
je 0x4c236
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x4c2c6
movq 0x78(%rax), %rdi
movq 0x80(%rax), %rax
subq %rdi, %rax
cmpq $0x21, %rax
jb 0x4c2ae
movq %r13, 0x10(%rsp)
movq %r12, 0x8(%rsp)
movb $0x1, %bpl
movl $0x1, %r13d
movl $0x20, %r12d
leaq (%rdi,%r12), %rsi
callq 0x55232
andb %al, %bpl
incq %r13
movq 0x18(%rsp), %rax
movq 0x78(%rax), %rdi
movq 0x80(%rax), %rax
subq %rdi, %rax
sarq $0x5, %rax
addq $0x20, %r12
cmpq %rax, %r13
jb 0x4c26c
testb %bpl, %bpl
movq 0x8(%rsp), %r12
movq 0x10(%rsp), %r13
je 0x4c38b
movq 0x18(%rsp), %rax
leaq 0x78(%rax), %rdi
movl $0x1, %esi
callq 0x54ebc
jmp 0x4c38b
movq (%rbp), %rdi
testq %rdi, %rdi
je 0x4c2e9
leaq 0x182062(%rip), %rsi # 0x1ce338
leaq 0x1826f3(%rip), %rdx # 0x1ce9d0
xorl %ecx, %ecx
callq 0x17d50
movq %rax, %rbp
jmp 0x4c2eb
xorl %ebp, %ebp
testq %rbp, %rbp
je 0x4c2fa
movq (%rbp), %rax
movq %rbp, %rdi
callq *0x10(%rax)
testq %rbp, %rbp
je 0x4c37c
movq 0x70(%rbp), %rdi
movq 0x78(%rbp), %rax
subq %rdi, %rax
cmpq $0x21, %rax
jb 0x4c36e
movq %rbp, 0x20(%rsp)
movq %r13, 0x10(%rsp)
movq %r12, 0x8(%rsp)
movb $0x1, %bpl
movl $0x1, %r13d
movl $0x20, %r12d
leaq (%rdi,%r12), %rsi
callq 0x551cf
andb %al, %bpl
incq %r13
movq 0x20(%rsp), %rax
movq 0x70(%rax), %rdi
movq 0x78(%rax), %rax
subq %rdi, %rax
sarq $0x5, %rax
addq $0x20, %r12
cmpq %rax, %r13
jb 0x4c32e
testb %bpl, %bpl
movq 0x8(%rsp), %r12
movq 0x10(%rsp), %r13
movq 0x20(%rsp), %rbp
je 0x4c37c
leaq 0x70(%rbp), %rdi
movl $0x1, %esi
callq 0x43134
testq %rbp, %rbp
je 0x4c38b
movq (%rbp), %rax
movq %rbp, %rdi
callq *0x18(%rax)
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x4c39b
movq (%rdi), %rax
callq *0x18(%rax)
testq %r13, %r13
je 0x4c3aa
movq (%r13), %rax
movq %r13, %rdi
callq *0x18(%rax)
testq %r12, %r12
je 0x4c3b9
movq (%r12), %rax
movq %r12, %rdi
callq *0x18(%rax)
testq %r15, %r15
je 0x4c3c7
movq (%r15), %rax
movq %r15, %rdi
callq *0x18(%rax)
testq %r14, %r14
je 0x4c3d5
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
testq %rbx, %rbx
je 0x4c3e3
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbp, 0x20(%rsp)
movq %r13, 0x10(%rsp)
movq %r12, 0x8(%rsp)
jmp 0x4c437
jmp 0x4c534
jmp 0x4c40a
movq %r13, 0x10(%rsp)
movq %r12, 0x8(%rsp)
jmp 0x4c45b
jmp 0x4c534
jmp 0x4c41d
movq %r13, 0x10(%rsp)
movq %r12, 0x8(%rsp)
jmp 0x4c47f
jmp 0x4c534
jmp 0x4c430
movq %r12, 0x8(%rsp)
jmp 0x4c4ad
movq %rax, %r13
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x4c45e
jmp 0x4c534
jmp 0x4c534
jmp 0x4c4de
jmp 0x4c4de
movq %rax, %r13
cmpq $0x0, 0x18(%rsp)
je 0x4c482
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x4c482
jmp 0x4c534
jmp 0x4c534
jmp 0x4c4f5
movq %rax, %r13
cmpq $0x0, 0x10(%rsp)
je 0x4c4b0
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x4c4b0
jmp 0x4c534
jmp 0x4c534
jmp 0x4c4a8
jmp 0x4c534
movq %rax, %r13
jmp 0x4c51a
movq %rax, %r13
cmpq $0x0, 0x8(%rsp)
je 0x4c4e1
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x4c4e1
jmp 0x4c534
jmp 0x4c534
movq %rax, %r13
testq %r14, %r14
je 0x4c51a
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
jmp 0x4c51a
jmp 0x4c534
movq %rax, %r13
testq %r15, %r15
je 0x4c50c
movq (%r15), %rax
movq %r15, %rdi
callq *0x18(%rax)
jmp 0x4c50c
jmp 0x4c534
jmp 0x4c534
movq %rax, %r13
jmp 0x4c50c
movq %rax, %r13
testq %r12, %r12
je 0x4c50c
movq (%r12), %rax
movq %r12, %rdi
callq *0x18(%rax)
testq %r14, %r14
je 0x4c51a
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
testq %rbx, %rbx
je 0x4c528
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq %r13, %rdi
callq 0x18710
jmp 0x4c534
jmp 0x4c534
movq %rax, %rdi
callq 0x1a679
|
/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::MultiTransformNode> xfmNode = node.dynamicCast<SceneGraph::MultiTransformNode>()) {
xfmNode->child = convert_triangles_to_quads(xfmNode->child,prop);
}
else if (Ref<SceneGraph::GroupNode> groupNode = node.dynamicCast<SceneGraph::GroupNode>())
{
for (size_t i=0; i<groupNode->children.size(); i++)
groupNode->children[i] = convert_triangles_to_quads(groupNode->children[i],prop);
}
else if (Ref<SceneGraph::TriangleMeshNode> tmesh = node.dynamicCast<SceneGraph::TriangleMeshNode>()) {
if (random<float>() <= prop) return convert_triangles_to_quads(tmesh);
else return node;
}
return node;
}
|
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 0x4f221
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x4f22f
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
testq %rbx, %rbx
je 0x4f29b
movq 0x98(%rbx), %rdi
movq %rdi, 0x38(%rsp)
testq %rdi, %rdi
je 0x4f24b
movq (%rdi), %rax
callq *0x10(%rax)
movq %rsp, %rdi
leaq 0x38(%rsp), %rsi
movss 0xc(%rsp), %xmm0
callq 0x4f1e3
movq 0x98(%rbx), %rdi
testq %rdi, %rdi
je 0x4f270
movq (%rdi), %rax
callq *0x18(%rax)
movq (%rsp), %rax
movq %rax, 0x98(%rbx)
movq $0x0, (%rsp)
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x4f293
movq (%rdi), %rax
callq *0x18(%rax)
movb $0x1, %bpl
jmp 0x4f4c7
movq (%r12), %rdi
testq %rdi, %rdi
je 0x4f2be
leaq 0x17f08d(%rip), %rsi # 0x1ce338
leaq 0x17f336(%rip), %rdx # 0x1ce5e8
xorl %ecx, %ecx
callq 0x17d50
movq %rax, %r14
jmp 0x4f2c1
xorl %r14d, %r14d
testq %r14, %r14
je 0x4f2cf
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
testq %r14, %r14
movq %r15, 0x20(%rsp)
movq %r12, 0x18(%rsp)
je 0x4f346
movq 0x80(%r14), %rdi
movq %rdi, 0x30(%rsp)
testq %rdi, %rdi
je 0x4f2f5
movq (%rdi), %rax
callq *0x10(%rax)
movq %rsp, %rdi
leaq 0x30(%rsp), %rsi
movss 0xc(%rsp), %xmm0
callq 0x4f1e3
movq 0x80(%r14), %rdi
testq %rdi, %rdi
je 0x4f31a
movq (%rdi), %rax
callq *0x18(%rax)
movq (%rsp), %rax
movq %rax, 0x80(%r14)
movq $0x0, (%rsp)
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x4f4a0
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x4f4a0
movq (%r12), %rdi
testq %rdi, %rdi
je 0x4f369
leaq 0x17efe2(%rip), %rsi # 0x1ce338
leaq 0x17f32b(%rip), %rdx # 0x1ce688
xorl %ecx, %ecx
callq 0x17d50
movq %rax, %r13
jmp 0x4f36c
xorl %r13d, %r13d
movq %r14, 0x10(%rsp)
testq %r13, %r13
je 0x4f380
movq (%r13), %rax
movq %r13, %rdi
callq *0x10(%rax)
testq %r13, %r13
je 0x4f413
movq 0x68(%r13), %rax
cmpq %rax, 0x70(%r13)
je 0x4f48c
xorl %r14d, %r14d
movq %rsp, %rbp
leaq 0x28(%rsp), %r15
movq (%rax,%r14,8), %rdi
movq %rdi, 0x28(%rsp)
testq %rdi, %rdi
je 0x4f3b6
movq (%rdi), %rax
callq *0x10(%rax)
movq %rbp, %rdi
movq %r15, %rsi
movss 0xc(%rsp), %xmm0
callq 0x4f1e3
movq 0x68(%r13), %r12
movq (%r12,%r14,8), %rdi
testq %rdi, %rdi
je 0x4f3da
movq (%rdi), %rax
callq *0x18(%rax)
movq (%rsp), %rax
movq %rax, (%r12,%r14,8)
movq $0x0, (%rsp)
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x4f3fa
movq (%rdi), %rax
callq *0x18(%rax)
incq %r14
movq 0x68(%r13), %rax
movq 0x70(%r13), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r14
jb 0x4f3a2
jmp 0x4f48c
movq 0x18(%rsp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x4f43a
leaq 0x17ef11(%rip), %rsi # 0x1ce338
leaq 0x17f462(%rip), %rdx # 0x1ce890
xorl %ecx, %ecx
callq 0x17d50
movq %rax, %rbp
jmp 0x4f43c
xorl %ebp, %ebp
testq %rbp, %rbp
je 0x4f48c
movq (%rbp), %rax
movq %rbp, %rdi
callq *0x10(%rax)
callq 0x17270
cvtsi2ss %eax, %xmm0
mulss 0x1074d0(%rip), %xmm0 # 0x15692c
movss 0xc(%rsp), %xmm1
ucomiss %xmm0, %xmm1
movq 0x20(%rsp), %r15
jae 0x4f4fb
movq 0x18(%rsp), %rcx
movq (%rcx), %rax
movq %rax, (%r15)
movq $0x0, (%rcx)
movq 0x10(%rsp), %r14
jmp 0x4f526
testq %r13, %r13
movq 0x10(%rsp), %r14
je 0x4f4a0
movq (%r13), %rax
movq %r13, %rdi
callq *0x18(%rax)
movb $0x1, %bpl
testq %r14, %r14
je 0x4f4bd
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq 0x20(%rsp), %r15
movq 0x18(%rsp), %r12
jmp 0x4f4c7
movq 0x20(%rsp), %r15
movq 0x18(%rsp), %r12
testq %rbx, %rbx
je 0x4f4d5
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
testb %bpl, %bpl
je 0x4f4e9
movq (%r12), %rax
movq %rax, (%r15)
movq $0x0, (%r12)
movq %r15, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbp, 0x40(%rsp)
movq (%rbp), %rax
movq %rbp, %rdi
callq *0x10(%rax)
leaq 0x40(%rsp), %rsi
movq %r15, %rdi
movq 0x10(%rsp), %r14
callq 0x4edd4
movq (%rbp), %rax
movq %rbp, %rdi
callq *0x18(%rax)
movq (%rbp), %rax
movq %rbp, %rdi
callq *0x18(%rax)
testq %r13, %r13
je 0x4f53f
movq (%r13), %rax
movq %r13, %rdi
callq *0x18(%rax)
testq %r14, %r14
je 0x4f559
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq 0x18(%rsp), %r12
xorl %ebp, %ebp
jmp 0x4f4c7
xorl %ebp, %ebp
jmp 0x4f4c2
jmp 0x4f6b5
movq %rax, %r15
movq (%rbp), %rax
movq %rbp, %rdi
callq *0x18(%rax)
jmp 0x4f57c
jmp 0x4f6b5
movq %rax, %r15
movq (%rbp), %rax
movq %rbp, %rdi
callq *0x18(%rax)
jmp 0x4f677
jmp 0x4f6b5
jmp 0x4f6b5
jmp 0x4f6b5
jmp 0x4f6b5
jmp 0x4f65f
jmp 0x4f6b5
jmp 0x4f5d3
jmp 0x4f6b5
movq %r14, 0x10(%rsp)
movq %rax, %r15
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4f5e8
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x4f5e8
jmp 0x4f6b5
movq %r14, 0x10(%rsp)
movq %rax, %r15
jmp 0x4f686
jmp 0x4f6b5
movq %r14, 0x10(%rsp)
movq %rax, %r15
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x4f686
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x4f686
jmp 0x4f6b5
jmp 0x4f626
jmp 0x4f6b5
movq %rax, %r15
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4f633
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x4f633
jmp 0x4f6b5
movq %rax, %r15
jmp 0x4f699
jmp 0x4f6b5
movq %rax, %r15
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x4f699
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x4f699
jmp 0x4f6b5
jmp 0x4f6b5
movq %rax, %r15
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4f667
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x4f667
jmp 0x4f6b5
movq %rax, %r15
jmp 0x4f677
movq %rax, %r15
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x4f677
movq (%rdi), %rax
callq *0x18(%rax)
testq %r13, %r13
je 0x4f686
movq (%r13), %rax
movq %r13, %rdi
callq *0x18(%rax)
cmpq $0x0, 0x10(%rsp)
je 0x4f699
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
testq %rbx, %rbx
je 0x4f6a7
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq %r15, %rdi
callq 0x18710
jmp 0x4f6b5
jmp 0x4f6b5
jmp 0x4f6b5
movq %rax, %rdi
callq 0x1a679
|
/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);
}
else if (Ref<SceneGraph::MultiTransformNode> xfmNode = node.dynamicCast<SceneGraph::MultiTransformNode>()) {
xfmNode->child = convert_quads_to_grids(xfmNode->child, resX, resY);
}
else if (Ref<SceneGraph::GroupNode> groupNode = node.dynamicCast<SceneGraph::GroupNode>())
{
for (size_t i=0; i<groupNode->children.size(); i++)
groupNode->children[i] = convert_quads_to_grids(groupNode->children[i], resX, resY);
}
else if (Ref<SceneGraph::QuadMeshNode> qmesh = node.dynamicCast<SceneGraph::QuadMeshNode>()) {
return convert_quads_to_grids(qmesh, resX, resY);
}
return node;
}
|
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
jmp 0x4fbc7
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x4fbd5
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
testq %rbx, %rbx
je 0x4fc44
movq 0x98(%rbx), %rdi
movq %rdi, 0x38(%rsp)
testq %rdi, %rdi
je 0x4fbf1
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rsi
movl %r13d, %edx
movl %ebp, %ecx
callq 0x4fb8a
movq 0x98(%rbx), %rdi
testq %rdi, %rdi
je 0x4fc17
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x98(%rbx)
movq $0x0, 0x8(%rsp)
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x4fc3c
movq (%rdi), %rax
callq *0x18(%rax)
movb $0x1, %bpl
jmp 0x4fe93
movq %r14, 0x18(%rsp)
movq (%r14), %rdi
testq %rdi, %rdi
je 0x4fc6b
leaq 0x17e6e0(%rip), %rsi # 0x1ce338
leaq 0x17e989(%rip), %rdx # 0x1ce5e8
xorl %ecx, %ecx
callq 0x17d50
movq %rax, %r14
jmp 0x4fc6e
xorl %r14d, %r14d
testq %r14, %r14
je 0x4fc7c
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
testq %r14, %r14
movq %r15, 0x20(%rsp)
je 0x4fcf1
movq 0x80(%r14), %rdi
movq %rdi, 0x30(%rsp)
testq %rdi, %rdi
je 0x4fc9d
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movl %r13d, %edx
movl %ebp, %ecx
callq 0x4fb8a
movq 0x80(%r14), %rdi
testq %rdi, %rdi
je 0x4fcc3
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x80(%r14)
movq $0x0, 0x8(%rsp)
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x4fe6a
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x4fe6a
movq 0x18(%rsp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x4fd18
leaq 0x17e633(%rip), %rsi # 0x1ce338
leaq 0x17e97c(%rip), %rdx # 0x1ce688
xorl %ecx, %ecx
callq 0x17d50
movq %rax, %r15
jmp 0x4fd1b
xorl %r15d, %r15d
movq %r14, 0x10(%rsp)
testq %r15, %r15
je 0x4fd2e
movq (%r15), %rax
movq %r15, %rdi
callq *0x10(%rax)
testq %r15, %r15
je 0x4fdc1
movq 0x68(%r15), %rax
cmpq %rax, 0x70(%r15)
je 0x4fe57
xorl %r14d, %r14d
movq (%rax,%r14,8), %rdi
movq %rdi, 0x28(%rsp)
testq %rdi, %rdi
je 0x4fd5c
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movl %r13d, %edx
movl %ebp, %ecx
callq 0x4fb8a
movq 0x68(%r15), %r12
movq (%r12,%r14,8), %rdi
testq %rdi, %rdi
je 0x4fd83
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x8(%rsp), %rax
movq %rax, (%r12,%r14,8)
movq $0x0, 0x8(%rsp)
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x4fda5
movq (%rdi), %rax
callq *0x18(%rax)
incq %r14
movq 0x68(%r15), %rax
movq 0x70(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r14
jb 0x4fd48
jmp 0x4fe57
movq 0x18(%rsp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x4fde8
leaq 0x17e563(%rip), %rsi # 0x1ce338
leaq 0x17eb54(%rip), %rdx # 0x1ce930
xorl %ecx, %ecx
callq 0x17d50
movq %rax, %r14
jmp 0x4fdeb
xorl %r14d, %r14d
testq %r14, %r14
je 0x4fe57
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %r14, 0x40(%rsp)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
leaq 0x40(%rsp), %rsi
movq 0x20(%rsp), %rdi
movl %r13d, %edx
movl %ebp, %ecx
callq 0x4f6bd
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq %r14, %rdi
movq 0x10(%rsp), %r14
movq (%rdi), %rax
callq *0x18(%rax)
testq %r15, %r15
je 0x4fe40
movq (%r15), %rax
movq %r15, %rdi
callq *0x18(%rax)
testq %r14, %r14
je 0x4fe87
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq 0x20(%rsp), %r15
xorl %ebp, %ebp
jmp 0x4fe8e
testq %r15, %r15
movq 0x10(%rsp), %r14
je 0x4fe6a
movq (%r15), %rax
movq %r15, %rdi
callq *0x18(%rax)
movb $0x1, %bpl
testq %r14, %r14
je 0x4fe89
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq 0x20(%rsp), %r15
movq 0x18(%rsp), %r14
jmp 0x4fe93
xorl %ebp, %ebp
movq 0x20(%rsp), %r15
movq 0x18(%rsp), %r14
testq %rbx, %rbx
je 0x4fea1
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
testb %bpl, %bpl
je 0x4feb3
movq (%r14), %rax
movq %rax, (%r15)
movq $0x0, (%r14)
movq %r15, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x50021
jmp 0x50021
jmp 0x50021
jmp 0x50021
movq %rax, %r12
movq (%r14), %rax
movq %r14, %r13
movq %r14, %rdi
callq *0x18(%rax)
jmp 0x4fef5
jmp 0x50021
movq %r14, %r13
movq %rax, %r12
movq %r13, %rdi
movq (%r13), %rax
callq *0x18(%rax)
jmp 0x4ffe4
jmp 0x50021
jmp 0x4ffcc
jmp 0x50021
jmp 0x4ff3e
jmp 0x50021
movq %r14, 0x10(%rsp)
movq %rax, %r12
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4ff53
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x4ff53
jmp 0x50021
movq %r14, 0x10(%rsp)
movq %rax, %r12
jmp 0x4fff2
jmp 0x50021
movq %r14, 0x10(%rsp)
movq %rax, %r12
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x4fff2
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x4fff2
jmp 0x50021
jmp 0x4ff92
jmp 0x50021
movq %rax, %r12
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4ff9f
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x4ff9f
jmp 0x50021
movq %rax, %r12
jmp 0x50005
jmp 0x50021
movq %rax, %r12
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x50005
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x50005
jmp 0x50021
jmp 0x50021
movq %rax, %r12
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x4ffd4
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x4ffd4
jmp 0x50021
movq %rax, %r12
jmp 0x4ffe4
movq %rax, %r12
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x4ffe4
movq (%rdi), %rax
callq *0x18(%rax)
testq %r15, %r15
je 0x4fff2
movq (%r15), %rax
movq %r15, %rdi
callq *0x18(%rax)
cmpq $0x0, 0x10(%rsp)
je 0x50005
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
testq %rbx, %rbx
je 0x50013
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq %r12, %rdi
callq 0x18710
jmp 0x50021
jmp 0x50021
jmp 0x50021
movq %rax, %rdi
callq 0x1a679
|
/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.dynamicCast<SceneGraph::MultiTransformNode>()) {
xfmNode->child = convert_grids_to_quads(xfmNode->child);
}
else if (Ref<SceneGraph::GroupNode> groupNode = node.dynamicCast<SceneGraph::GroupNode>())
{
for (size_t i=0; i<groupNode->children.size(); i++)
groupNode->children[i] = convert_grids_to_quads(groupNode->children[i]);
}
else if (Ref<SceneGraph::GridMeshNode> gmesh = node.dynamicCast<SceneGraph::GridMeshNode>()) {
return convert_grids_to_quads(gmesh);
}
return 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 %rbx, %rbx
je 0x50287
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
testq %rbx, %rbx
je 0x502f1
movq 0x98(%rbx), %rdi
movq %rdi, 0x38(%rsp)
testq %rdi, %rdi
je 0x502a3
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x50241
movq 0x98(%rbx), %rdi
testq %rdi, %rdi
je 0x502c4
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x98(%rbx)
movq $0x0, 0x8(%rsp)
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x502e9
movq (%rdi), %rax
callq *0x18(%rax)
movb $0x1, %bpl
jmp 0x5053f
movq (%r12), %rdi
testq %rdi, %rdi
je 0x50314
leaq 0x17e037(%rip), %rsi # 0x1ce338
leaq 0x17e2e0(%rip), %rdx # 0x1ce5e8
xorl %ecx, %ecx
callq 0x17d50
movq %rax, %r14
jmp 0x50317
xorl %r14d, %r14d
testq %r14, %r14
je 0x50325
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
testq %r14, %r14
movq %r15, 0x20(%rsp)
movq %r12, 0x18(%rsp)
je 0x5039a
movq 0x80(%r14), %rdi
movq %rdi, 0x30(%rsp)
testq %rdi, %rdi
je 0x5034b
movq (%rdi), %rax
callq *0x10(%rax)
leaq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x50241
movq 0x80(%r14), %rdi
testq %rdi, %rdi
je 0x5036c
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x80(%r14)
movq $0x0, 0x8(%rsp)
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x50518
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x50518
movq (%r12), %rdi
testq %rdi, %rdi
je 0x503bd
leaq 0x17df8e(%rip), %rsi # 0x1ce338
leaq 0x17e2d7(%rip), %rdx # 0x1ce688
xorl %ecx, %ecx
callq 0x17d50
movq %rax, %r13
jmp 0x503c0
xorl %r13d, %r13d
movq %r14, 0x10(%rsp)
testq %r13, %r13
je 0x503d4
movq (%r13), %rax
movq %r13, %rdi
callq *0x10(%rax)
testq %r13, %r13
je 0x50468
movq 0x68(%r13), %rax
cmpq %rax, 0x70(%r13)
je 0x50504
xorl %r14d, %r14d
leaq 0x8(%rsp), %rbp
leaq 0x28(%rsp), %r15
movq (%rax,%r14,8), %rdi
movq %rdi, 0x28(%rsp)
testq %rdi, %rdi
je 0x5040c
movq (%rdi), %rax
callq *0x10(%rax)
movq %rbp, %rdi
movq %r15, %rsi
callq 0x50241
movq 0x68(%r13), %r12
movq (%r12,%r14,8), %rdi
testq %rdi, %rdi
je 0x5042a
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x8(%rsp), %rax
movq %rax, (%r12,%r14,8)
movq $0x0, 0x8(%rsp)
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x5044c
movq (%rdi), %rax
callq *0x18(%rax)
incq %r14
movq 0x68(%r13), %rax
movq 0x70(%r13), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r14
jb 0x503f8
jmp 0x50504
movq 0x18(%rsp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x5048f
leaq 0x17debc(%rip), %rsi # 0x1ce338
leaq 0x17e72d(%rip), %rdx # 0x1cebb0
xorl %ecx, %ecx
callq 0x17d50
movq %rax, %rbp
jmp 0x50491
xorl %ebp, %ebp
testq %rbp, %rbp
je 0x50504
movq (%rbp), %rax
movq %rbp, %rdi
callq *0x10(%rax)
movq %rbp, 0x40(%rsp)
movq (%rbp), %rax
movq %rbp, %rdi
callq *0x10(%rax)
movq 0x20(%rsp), %r15
leaq 0x40(%rsp), %rsi
movq %r15, %rdi
callq 0x50029
movq (%rbp), %rax
movq %rbp, %rdi
callq *0x18(%rax)
movq 0x10(%rsp), %r14
movq (%rbp), %rax
movq %rbp, %rdi
callq *0x18(%rax)
testq %r13, %r13
je 0x504e9
movq (%r13), %rax
movq %r13, %rdi
callq *0x18(%rax)
testq %r14, %r14
je 0x50573
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq 0x18(%rsp), %r12
xorl %ebp, %ebp
jmp 0x5053f
testq %r13, %r13
movq 0x10(%rsp), %r14
je 0x50518
movq (%r13), %rax
movq %r13, %rdi
callq *0x18(%rax)
movb $0x1, %bpl
testq %r14, %r14
je 0x50535
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq 0x20(%rsp), %r15
movq 0x18(%rsp), %r12
jmp 0x5053f
movq 0x20(%rsp), %r15
movq 0x18(%rsp), %r12
testq %rbx, %rbx
je 0x5054d
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
testb %bpl, %bpl
je 0x50561
movq (%r12), %rax
movq %rax, (%r15)
movq $0x0, (%r12)
movq %r15, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %ebp, %ebp
jmp 0x5053a
jmp 0x506cf
jmp 0x506cf
jmp 0x506cf
jmp 0x506cf
movq %rax, %r15
movq (%rbp), %rax
movq %rbp, %rdi
callq *0x18(%rax)
jmp 0x505a2
jmp 0x506cf
movq %rax, %r15
movq (%rbp), %rax
movq %rbp, %rdi
callq *0x18(%rax)
jmp 0x50691
jmp 0x506cf
jmp 0x50679
jmp 0x506cf
jmp 0x505eb
jmp 0x506cf
movq %r14, 0x10(%rsp)
movq %rax, %r15
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x50600
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x50600
jmp 0x506cf
movq %r14, 0x10(%rsp)
movq %rax, %r15
jmp 0x506a0
jmp 0x506cf
movq %r14, 0x10(%rsp)
movq %rax, %r15
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x506a0
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x506a0
jmp 0x506cf
jmp 0x5063f
jmp 0x506cf
movq %rax, %r15
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x5064c
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x5064c
jmp 0x506cf
movq %rax, %r15
jmp 0x506b3
jmp 0x506cf
movq %rax, %r15
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x506b3
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x506b3
jmp 0x506cf
jmp 0x506cf
movq %rax, %r15
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x50681
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x50681
jmp 0x506cf
movq %rax, %r15
jmp 0x50691
movq %rax, %r15
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x50691
movq (%rdi), %rax
callq *0x18(%rax)
testq %r13, %r13
je 0x506a0
movq (%r13), %rax
movq %r13, %rdi
callq *0x18(%rax)
cmpq $0x0, 0x10(%rsp)
je 0x506b3
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
testq %rbx, %rbx
je 0x506c1
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq %r15, %rdi
callq 0x18710
jmp 0x506cf
jmp 0x506cf
jmp 0x506cf
movq %rax, %rdi
callq 0x1a679
|
/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, %r15
je 0x54e44
leaq 0x179507(%rip), %rsi # 0x1ce338
leaq 0x179850(%rip), %rdx # 0x1ce688
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x17d50
jmp 0x54e46
xorl %eax, %eax
movq %rax, (%r14)
testq %rax, %rax
je 0x54e57
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
testq %r15, %r15
je 0x54e65
movq (%r15), %rax
movq %r15, %rdi
callq *0x18(%rax)
testq %rbx, %rbx
je 0x54e73
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x54eb3
jmp 0x54eb3
movq %rax, %r14
testq %r15, %r15
je 0x54e9d
movq (%r15), %rax
movq %r15, %rdi
callq *0x18(%rax)
jmp 0x54e9d
jmp 0x54eb3
movq %rax, %r14
testq %rbx, %rbx
je 0x54eab
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq %r14, %rdi
callq 0x18710
movq %rax, %rdi
callq 0x1a679
nop
|
/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 %rax, 0x50(%rdi)
movw $0x1, 0x58(%rdi)
movl $0xffffffff, 0x5c(%rdi) # imm = 0xFFFFFFFF
movq %rax, 0x60(%rdi)
leaq 0x179573(%rip), %rax # 0x1ce8b8
movq %rax, (%rdi)
movlps %xmm0, 0x68(%rdi)
leaq 0x70(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rdi)
movups %xmm0, 0x80(%rdi)
movups %xmm0, 0x90(%rdi)
movups %xmm0, 0xa0(%rdi)
movups %xmm0, 0xb0(%rdi)
movups %xmm0, 0xc0(%rdi)
movq (%rsi), %rdi
movq %rdi, 0xd0(%rbx)
testq %rdi, %rdi
je 0x5538f
movq (%rdi), %rax
callq *0x10(%rax)
testq %r15, %r15
je 0x553d6
leaq 0x8(%rsp), %r13
xorps %xmm0, %xmm0
movq %rsp, %r12
movups %xmm0, (%r13)
movq $0x0, 0x10(%r13)
movq %r14, %rdi
movq %r12, %rsi
callq 0x43f22
movq 0x18(%rsp), %rdi
callq 0xdc3f5
xorps %xmm0, %xmm0
movups %xmm0, (%r13)
movq $0x0, 0x10(%r13)
decq %r15
jne 0x5539f
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r15
jmp 0x55418
movq %rax, %r15
movq 0x18(%rsp), %rdi
callq 0xdc3f5
xorps %xmm0, %xmm0
movups %xmm0, (%r13)
movq $0x0, 0x10(%r13)
movq 0xd0(%rbx), %rdi
testq %rdi, %rdi
je 0x55418
movq (%rdi), %rax
callq *0x18(%rax)
movq 0xb8(%rbx), %rdi
testq %rdi, %rdi
je 0x55429
callq 0x17b20
movq 0xa0(%rbx), %rdi
testq %rdi, %rdi
je 0x5543a
callq 0x17b20
leaq 0x88(%rbx), %rdi
callq 0x43efa
movq %r14, %rdi
callq 0x43efa
movq %rbx, %rdi
callq 0x34eac
movq %r15, %rdi
callq 0x18710
jmp 0x55462
jmp 0x55462
movq %rax, %rdi
callq 0x1a679
|
/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 lerp(cameras[itime+0]->get(time), cameras[itime+1]->get(time), ftime);
}
|
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
subq %r15, %r12
sarq $0x3, %r12
movq %r12, %rax
decq %rax
js 0x5604e
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
jmp 0x56066
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
addss %xmm0, %xmm0
mulss %xmm0, %xmm1
movss %xmm1, 0xc(%rsp)
movaps %xmm1, %xmm0
callq 0x17420
cvttss2si %xmm0, %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovgl %eax, %ecx
addl $-0x2, %r12d
cmpl %r12d, %ecx
cmovll %ecx, %r12d
xorps %xmm1, %xmm1
cvtsi2ss %r12d, %xmm1
movss 0xc(%rsp), %xmm0
movaps %xmm0, %xmm2
subss %xmm1, %xmm2
movaps %xmm2, 0x10(%rsp)
movslq %r12d, %r12
movq (%r15,%r12,8), %rsi
movq (%rsi), %rax
leaq 0x60(%rsp), %r15
movq %r15, %rdi
callq *0x80(%rax)
movq 0xb8(%r14), %rax
movq 0x8(%rax,%r12,8), %rsi
movq (%rsi), %rax
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movss 0xc(%rsp), %xmm0
callq *0x80(%rax)
movss 0xfa015(%rip), %xmm0 # 0x150100
movaps 0x10(%rsp), %xmm2
subss %xmm2, %xmm0
movaps %xmm2, %xmm1
movaps %xmm2, %xmm6
shufps $0x0, %xmm2, %xmm1 # xmm1 = xmm1[0,0],xmm2[0,0]
movaps (%r14), %xmm2
mulps %xmm1, %xmm2
movaps %xmm0, %xmm3
shufps $0x0, %xmm0, %xmm3 # xmm3 = xmm3[0,0],xmm0[0,0]
movaps (%r15), %xmm4
mulps %xmm3, %xmm4
addps %xmm2, %xmm4
movaps 0x10(%r14), %xmm2
mulps %xmm1, %xmm2
movaps 0x10(%r15), %xmm5
mulps %xmm3, %xmm5
mulps 0x20(%r14), %xmm1
mulps 0x20(%r15), %xmm3
addps %xmm2, %xmm5
addps %xmm1, %xmm3
mulss 0x30(%r14), %xmm6
mulss 0x30(%r15), %xmm0
addss %xmm6, %xmm0
movaps %xmm4, (%rbx)
movaps %xmm5, 0x10(%rbx)
movaps %xmm3, 0x20(%rbx)
movss %xmm0, 0x30(%rbx)
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/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.