name string | code string | asm string | file string |
|---|---|---|---|
fiber_destroy | void
fiber_destroy(Fiber *fbr)
{
assert(!fiber_is_executing(fbr));
assert(!fiber_is_toplevel(fbr));
if (!fbr->alloc_stack)
return;
if (fbr->state &
(FIBER_FS_HAS_HI_GUARD_PAGE | FIBER_FS_HAS_LO_GUARD_PAGE)) {
size_t pgsz = get_page_size();
size_t npages = (fbr->stack_si... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movzwl 0x58(%rdi), %ebp
testb $0x1, %bpl
jne 0x1b24
testb $0x2, %bpl
jne 0x1b43
movq %rdi, %rbx
movq 0x48(%rdi), %r14
testq %r14, %r14
je 0x1b15
movzwl %bp, %r13d
testb $0x18, %r13b
je 0x1afd
callq 0x1da3
movq %rax, %r15
movq 0x50(%rbx), %rax
... | /simonfxr[P]fiber/src/fiber.c |
fiber_switch | void
fiber_switch(Fiber *from, Fiber *to)
{
NULL_CHECK(from, "Fiber cannot be NULL");
NULL_CHECK(to, "Fiber cannot be NULL");
if (from == to)
return;
assert(fiber_is_executing(from));
assert(!fiber_is_executing(to));
assert(fiber_is_alive(to));
from->state &= ~FIBER_FS_EXECUTING;
... | pushq %rax
cmpq %rsi, %rdi
je 0x1b91
movzwl 0x58(%rdi), %eax
testb $0x1, %al
je 0x1b93
movzwl 0x58(%rsi), %ecx
testb $0x1, %cl
jne 0x1bb2
testb $0x4, %cl
je 0x1bd1
andl $0xfffe, %eax # imm = 0xFFFE
movw %ax, 0x58(%rdi)
orb $0x1, 0x58(%rsi)
popq %rax
jmp 0x1dc8
popq %rax
retq
leaq 0x730(%rip), %rdi # 0x2... | /simonfxr[P]fiber/src/fiber.c |
probe_stack | HU_NOINLINE
static void
probe_stack(volatile char *sp0, size_t sz, size_t pgsz)
{
volatile char *sp = sp0;
#if HU_COMP_GNUC_P
__asm__ __volatile__("" : : "r"(sp) : "memory");
#endif
size_t i = 0;
while (i < sz) {
*(volatile uintptr_t *) sp |= (uintptr_t) 0;
i += pgsz;
sp -= pgsz;... | movq %rdx, %rax
negq %rax
xorl %ecx, %ecx
movq %rdi, %r8
cmpq %rsi, %rcx
jae 0x1bf0
movq (%r8), %r9
movq %r9, (%r8)
addq %rdx, %rcx
addq %rax, %r8
jmp 0x1c97
| /simonfxr[P]fiber/src/fiber.c |
fiber_exec_on | void
fiber_exec_on(Fiber *active, Fiber *temp, FiberFunc f, void *args)
{
NULL_CHECK(active, "Fiber cannot be NULL");
NULL_CHECK(temp, "Fiber cannot be NULL");
assert(fiber_is_executing(active));
if (active == temp) {
f(args);
} else {
assert(!fiber_is_executing(temp));
temp... | pushq %r14
pushq %rbx
pushq %rax
testb $0x1, 0x58(%rdi)
je 0x1d05
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rsi, %rdi
je 0x1cf9
movzwl 0x58(%rbx), %eax
testb $0x1, %al
jne 0x1d24
orl $0x1, %eax
movw %ax, 0x58(%rbx)
andb $-0x2, 0x58(%r14)
movq (%rbx), %rax
movq %rcx, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x1e28
orb $0x... | /simonfxr[P]fiber/src/fiber.c |
get_page_size | HU_CONST_FN
static size_t
get_page_size()
{
static size_t PAGE_SIZE = 0;
size_t pgsz = PAGE_SIZE;
if (hu_likely(pgsz != 0))
return pgsz;
#if HU_OS_POSIX_P
pgsz = (size_t) sysconf(_SC_PAGESIZE);
#elif HU_OS_WINDOWS_P
SYSTEM_INFO sysnfo;
GetSystemInfo(&sysnfo);
pgsz = (size_t) sysnfo.... | movq 0x22f6(%rip), %rax # 0x40a0
testq %rax, %rax
je 0x1db0
retq
pushq %rax
pushq $0x1e
popq %rdi
callq 0x10d0
movq %rax, 0x22e0(%rip) # 0x40a0
addq $0x8, %rsp
retq
nopl (%rax)
| /simonfxr[P]fiber/src/fiber.c |
thread(void*) | void* thread(void *thread_data) {
stringstream ss;
thr_data *data = (thr_data*) thread_data;
ss << "..\\Files\\" << data->numberFile << ".txt";
ifstream in(ss.str());
ss.str(string());
if (in.is_open()) {
while (!in.eof()) {
int num;
in >> num;
data->... | pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp # imm = 0x420
movq %rdi, -0x8(%rbp)
leaq -0x190(%rbp), %rdi
callq 0x20f0
movq -0x8(%rbp), %rax
movq %rax, -0x198(%rbp)
leaq -0x180(%rbp), %rdi
leaq 0x17cb(%rip), %rsi # 0x413f
callq 0x2150
movq %rax, -0x400(%rbp)
jmp 0x2982
movq -0x400(%rbp), %rdi
movq -0x198... | /Dudoserovich[P]pthread_sum/src/pthreads_summator_lib.cpp |
highwayhash::SetThreadAffinity(highwayhash::ThreadAffinity*) | void SetThreadAffinity(ThreadAffinity* affinity) {
// Ensure original is initialized before changing.
const ThreadAffinity* const original = OriginalThreadAffinity();
CHECK(original != nullptr);
#if OS_WIN
const HANDLE hThread = GetCurrentThread();
const DWORD_PTR prev = SetThreadAffinityMask(hThread, affini... | pushq %rbx
movq %rdi, %rbx
callq 0xa95f
testq %rax, %rax
je 0xa939
movl $0x80, %esi
xorl %edi, %edi
movq %rbx, %rdx
callq 0x21c0
testl %eax, %eax
jne 0xa947
popq %rbx
retq
leaq 0x2dc0(%rip), %rdi # 0xd700
movl $0xa1, %esi
jmp 0xa953
leaq 0x2db2(%rip), %rdi # 0xd700
movl $0xaa, %esi
xorl %eax, %eax
callq 0x205... | /google[P]highwayhash/highwayhash/os_specific.cc |
highwayhash::Cpuid(unsigned int, unsigned int, unsigned int*) | void Cpuid(const uint32_t level, const uint32_t count,
uint32_t* HH_RESTRICT abcd) {
#if HH_MSC_VERSION
int regs[4];
__cpuidex(regs, level, count);
for (int i = 0; i < 4; ++i) {
abcd[i] = regs[i];
}
#else
uint32_t a, b, c, d;
__cpuid_count(level, count, a, b, c, d);
abcd[0] = a;
abcd[1] =... | movq %rdx, %r8
movl %esi, %ecx
movl %edi, %eax
xchgq %rbx, %rsi
cpuid
xchgq %rbx, %rsi
movl %eax, (%r8)
movl %esi, 0x4(%r8)
movl %ecx, 0x8(%r8)
movl %edx, 0xc(%r8)
retq
| /google[P]highwayhash/highwayhash/arch_specific.cc |
highwayhash::NominalClockRate() | double NominalClockRate() {
// Thread-safe caching - this is called several times.
static const double cycles_per_second = DetectNominalClockRate();
return cycles_per_second;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movb 0x8f12(%rip), %al # 0x14228
testb %al, %al
je 0xb331
movsd 0x8efe(%rip), %xmm0 # 0x14220
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8ef0(%rip), %rdi # 0x14228
callq 0x2370... | /google[P]highwayhash/highwayhash/arch_specific.cc |
testing::internal::SingleFailureChecker::~SingleFailureChecker() | SingleFailureChecker::~SingleFailureChecker() {
EXPECT_PRED_FORMAT3(HasOneFailure, *results_, type_, substr_);
} | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %r8
movl 0x8(%rdi), %r9d
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
leaq -0x28(%rbp), %rdi
callq 0x200d1
cmpb $0x0, -0x28(%rbp)
jne 0x20553
leaq -0x10(%rbp), %rdi
callq 0x20d8a
movq -0x20(%rbp), %rax
testq %rax, %rax
je 0x20505
movq (%rax)... | /trinerdi[P]icpc-notebook/lib/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::UnshuffleTests() | void UnitTestImpl::UnshuffleTests() {
for (size_t i = 0; i < test_cases_.size(); i++) {
// Unshuffles the tests in each test case.
test_cases_[i]->UnshuffleTests();
// Resets the index of each test case.
test_case_indices_[i] = static_cast<int>(i);
}
} | movq 0xb8(%rdi), %rax
movq 0xc0(%rdi), %rcx
subq %rax, %rcx
je 0x2c4d0
pushq %rbp
movq %rsp, %rbp
sarq $0x3, %rcx
movq 0xd0(%rdi), %rdx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %esi, %esi
movq (%rax,%rsi,8), %r8
movq 0x48(%r8), %rdi
movq 0x50(%r8), %r8
subq %rdi, %r8
je 0x2c4c4
sarq $0x2, %r8
cmpq $0x1, %r8
adcq $0x0, %r8
... | /trinerdi[P]icpc-notebook/lib/googletest/src/gtest.cc |
testing::internal::ParseFlagValue(char const*, char const*, bool) | const char* ParseFlagValue(const char* str,
const char* flag,
bool def_optional) {
// str and flag must not be NULL.
if (str == NULL || flag == NULL) return NULL;
// The flag must start with "--" followed by GTEST_FLAG_PREFIX_.
const std::string flag_str = ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
je 0x2c8a0
xorl %ebx, %ebx
jmp 0x2c9db
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x13916(%rip), %r... | /trinerdi[P]icpc-notebook/lib/googletest/src/gtest.cc |
testing::internal::DeathTestAbort(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void DeathTestAbort(const std::string& message) {
// On a POSIX system, this function may be called from a threadsafe-style
// death test child process, which operates on a very small stack. Use
// the heap for any additional non-minuscule memory requirements.
const InternalRunDeathTestFlag* const flag =
... | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x1ece4
movq 0x22735(%rip), %rax # 0x4f700
movq 0x1d0(%rax), %rax
testq %rax, %rax
jne 0x2cff6
movq 0x21fea(%rip), %r14 # 0x4efc8
movq (%r14), %rsi
movq (%rbx), %rdi
callq 0x1b550
movq (%r14), %rdi
callq 0x1b5c0
callq 0x1b2a0
movl 0x28(%rax)... | /trinerdi[P]icpc-notebook/lib/googletest/src/gtest-death-test.cc |
testing::internal::DeathTest::DeathTest() | DeathTest::DeathTest() {
TestInfo* const info = GetUnitTestImpl()->current_test_info();
if (info == NULL) {
DeathTestAbort("Cannot run a death test outside of a TEST or "
"TEST_F construct");
}
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
leaq 0x21a58(%rip), %rax # 0x4ead8
movq %rax, (%rdi)
callq 0x1ece4
movq 0x22671(%rip), %rax # 0x4f700
cmpq $0x0, 0x110(%rax)
je 0x2d0a2
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x1312b... | /trinerdi[P]icpc-notebook/lib/googletest/src/gtest-death-test.cc |
testing::internal::DeathTestImpl::ReadAndInterpretStatusByte() | void DeathTestImpl::ReadAndInterpretStatusByte() {
char flag;
int bytes_read;
// The read() here blocks until data is available (signifying the
// failure of the death test) or until the pipe is closed (signifying
// its success), so it's okay to call this in the parent before
// the child process has exit... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movq %rdi, %rbx
leaq -0x29(%rbp), %r14
movl 0x24(%rbx), %edi
movl $0x1, %edx
movq %r14, %rsi
callq 0x1b780
movq %rax, %r15
cmpl $-0x1, %r15d
jne 0x2d1ad
callq 0x1b070
cmpl $0x4, (%rax)
je 0x2d179... | /trinerdi[P]icpc-notebook/lib/googletest/src/gtest-death-test.cc |
testing::internal::DeathTestImpl::Abort(testing::internal::DeathTest::AbortReason) | void DeathTestImpl::Abort(AbortReason reason) {
// The parent process considers the death test to be a failure if
// it finds any data in our pipe. So, here we write a single flag byte
// to the pipe, then exit.
const char status_ch =
reason == TEST_DID_NOT_DIE ? kDeathTestLived :
reason == TEST_TH... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rdi, %rbx
cmpl $0x1, %esi
sete %al
addb %al, %al
addb $0x52, %al
cmpl $0x2, %esi
movzbl %al, %eax
movl $0x4c, %ecx
cmovnel %eax, %ecx
leaq -0x29(%rbp), %r14
movb %cl, (%r14)
movl 0x28(%rbx)... | /trinerdi[P]icpc-notebook/lib/googletest/src/gtest-death-test.cc |
testing::internal::DeathTestImpl::Passed(bool) | bool DeathTestImpl::Passed(bool status_ok) {
if (!spawned())
return false;
const std::string error_message = GetCapturedStderr();
bool success = false;
Message buffer;
buffer << "Death test: " << statement() << "\n";
switch (outcome()) {
case LIVED:
buffer << " Result: failed to die.\n"
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
cmpb $0x1, 0x18(%rdi)
jne 0x2dd65
movl %esi, %r14d
movq %rdi, %r15
leaq 0x21a62(%rip), %rsi # 0x4f780
leaq -0x88(%rbp), %rdi
callq 0x33a45
leaq -0x48(%rbp), %rdi
callq 0x20d8a
movq -0x48(%rbp), %rbx
addq $0x10, %rbx
leaq 0x12613... | /trinerdi[P]icpc-notebook/lib/googletest/src/gtest-death-test.cc |
testing::internal::FormatDeathTestOutput(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static ::std::string FormatDeathTestOutput(const ::std::string& output) {
::std::string ret;
for (size_t at = 0; ; ) {
const size_t line_end = output.find('\n', at);
ret += "[ DEATH ] ";
if (line_end == ::std::string::npos) {
ret += output.substr(at);
break;
}
ret += output.substr... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x50(%rbp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorl %r12d, %r12d
movq %r14, %rdi
movl $0xa, %esi
movq %r12, %rdx
callq 0x1b6e0
mov... | /trinerdi[P]icpc-notebook/lib/googletest/src/gtest-death-test.cc |
testing::internal::ForkingDeathTest::Wait() | int ForkingDeathTest::Wait() {
if (!spawned())
return 0;
ReadAndInterpretStatusByte();
int status_value;
GTEST_DEATH_TEST_CHECK_SYSCALL_(waitpid(child_pid_, &status_value, 0));
set_status(status_value);
return status_value;
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
xorl %eax, %eax
cmpb $0x1, 0x18(%rdi)
jne 0x2e4ec
movq %rdi, %rbx
callq 0x2d15e
leaq -0x2c(%rbp), %r14
movl 0x2c(%rbx), %edi
movq %r14, %rsi
xorl %edx, %edx
callq 0x1b3b0
cmpl $-0x1, %eax
jne 0x2... | /trinerdi[P]icpc-notebook/lib/googletest/src/gtest-death-test.cc |
testing::Message::Message(testing::Message const&) | Message(const Message& msg) : ss_(new ::std::stringstream) { // NOLINT
*ss_ << msg.GetString();
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x188, %edi # imm = 0x188
callq 0x1b480
movq %rax, %r15
movq %rax, %rdi
callq 0x1b340
movq %r15, (%rbx)
movq (%r14), %rsi
leaq -0x38(%rbp), %rdi
callq 0x20fe5
addq $0x10, %r15
movq -0x38(%rbp), ... | /trinerdi[P]icpc-notebook/lib/googletest/include/gtest/gtest-message.h |
testing::internal::StreamingListener::OnTestPartResult(testing::TestPartResult const&) | void OnTestPartResult(const TestPartResult& test_part_result) {
const char* file_name = test_part_result.file_name();
if (file_name == NULL)
file_name = "";
SendLn("event=TestPartResult&file=" + UrlEncode(file_name) +
"&line=" + StreamableToString(test_part_result.line_number()) +
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x39e45
movq 0x8(%r14), %rax
testq %rax, %rax
leaq 0x5e33(%rip), %rsi # 0x3fc82
cmovneq %rax, %rsi
leaq -0x130(%rbp)... | /trinerdi[P]icpc-notebook/lib/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::OnTestEnd(testing::TestInfo const&) | void OnTestEnd(const TestInfo& test_info) {
SendLn("event=TestEnd&passed=" +
FormatBool((test_info.result())->Passed()) +
"&elapsed_time=" +
StreamableToString((test_info.result())->elapsed_time()) + "ms");
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x90(%rsi), %rdi
callq 0x24a2c
leaq 0x6cd7(%rip), %rcx # 0x40f8a
leaq 0x3d5f(%rip), %rsi # 0x3e019
testb %al, %al
cmovneq %rcx, %rsi
leaq -0xe0(%rbp), %r12
movq %r12, -0x10(%... | /trinerdi[P]icpc-notebook/lib/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::OnTestCaseEnd(testing::TestCase const&) | void OnTestCaseEnd(const TestCase& test_case) {
SendLn("event=TestCaseEnd&passed=" + FormatBool(test_case.Passed())
+ "&elapsed_time=" + StreamableToString(test_case.elapsed_time())
+ "ms");
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2087c
testl %eax, %eax
leaq 0x3a1e(%rip), %rax # 0x3e019
leaq 0x6988(%rip), %rsi # 0x40f8a
cmovleq %rax, %rsi
leaq -0xe0(%rbp), %r12
movq %r12, -0x10(%r12)... | /trinerdi[P]icpc-notebook/lib/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::OnTestIterationEnd(testing::UnitTest const&, int) | void OnTestIterationEnd(const UnitTest& unit_test, int /* iteration */) {
SendLn("event=TestIterationEnd&passed=" +
FormatBool(unit_test.Passed()) + "&elapsed_time=" +
StreamableToString(unit_test.elapsed_time()) + "ms");
} | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x40(%rsi), %rdi
callq 0x373a2
leaq 0x36dd(%rip), %rcx # 0x3e019
leaq 0x6647(%rip), %rsi # 0x40f8a
testb %al, %al
cmovneq %rcx, %rsi
leaq -0xe0(%rbp), %r12
movq %r12, -0x10(%... | /trinerdi[P]icpc-notebook/lib/googletest/src/gtest-internal-inl.h |
ImGuiSelectionBasicStorage::ImGuiSelectionBasicStorage() | inline ~ImVector() { if (Data) IM_FREE(Data); } | xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movl $0x0, (%rdi)
movb $0x0, 0x4(%rdi)
movq $0x0, 0x8(%rdi)
leaq 0x5c5c(%rip), %rax # 0xd123e
movq %rax, 0x10(%rdi)
movl $0x1, 0x18(%rdi)
retq
| /OpenBoardView[P]OpenBoardView/src/imgui/imgui.h |
embree::CommandLineParser::CommandLineOptionClosure<embree::VerifyApplication::VerifyApplication()::$_2>::parse(embree::Ref<embree::ParseStream>, embree::FileName const&) | virtual void parse(Ref<ParseStream> cin, const FileName& path) {
f(cin,path);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %r14
movq (%rsi), %rbx
testq %rbx, %rbx
je 0x32549
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq 0x30(%r14), %r15
cmpb $0x0, 0x1a0(%r15)
jne 0x3258e
movq 0xe8(%r15), %r14
movq %r14, 0x10(%rsp)
testq %r14, %r14
je 0x32571
movq (%r14), %ra... | /embree[P]embree/tutorials/verify/../common/tutorial/application.h |
embree::CommandLineParser::CommandLineOptionClosure<embree::VerifyApplication::VerifyApplication()::$_3>::~CommandLineOptionClosure() | CommandLineOptionClosure (std::string description, const F& f)
: CommandLineOption(description), f(f) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x136bc5(%rip), %rax # 0x1692d0
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x32720
callq 0x14760
movq %rbx, %rdi
popq %rbx
jmp 0x14760
nop
| /embree[P]embree/tutorials/verify/../common/tutorial/application.h |
embree::Geometry::getFirstHalfEdge(unsigned int) | virtual unsigned int getFirstHalfEdge(unsigned int faceID) {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"operation not supported for this geometry");
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl $0x30, %edi
callq 0x143c0
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa58a1(%rip), %rsi # 0x11e959
leaq 0xa58c3(%rip), %rdx # 0x11e982
movq %rsp, %rdi
callq 0x62274
leaq 0xef62a(%rip), %rax # 0x1686f8
movq %rax, (%rbx)
movl $0x3,... | /embree[P]embree/kernels/common/geometry.h |
embree::Geometry::getNextHalfEdge(unsigned int) | virtual unsigned int getNextHalfEdge(unsigned int edgeID) {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"operation not supported for this geometry");
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl $0x30, %edi
callq 0x143c0
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa5725(%rip), %rsi # 0x11e959
leaq 0xa5747(%rip), %rdx # 0x11e982
movq %rsp, %rdi
callq 0x62274
leaq 0xef4ae(%rip), %rax # 0x1686f8
movq %rax, (%rbx)
movl $0x3,... | /embree[P]embree/kernels/common/geometry.h |
embree::Geometry::getOppositeHalfEdge(unsigned int, unsigned int) | virtual unsigned int getOppositeHalfEdge(unsigned int topologyID, unsigned int edgeID) {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"operation not supported for this geometry");
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl $0x30, %edi
callq 0x143c0
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa55a9(%rip), %rsi # 0x11e959
leaq 0xa55cb(%rip), %rdx # 0x11e982
movq %rsp, %rdi
callq 0x62274
leaq 0xef332(%rip), %rax # 0x1686f8
movq %rax, (%rbx)
movl $0x3,... | /embree[P]embree/kernels/common/geometry.h |
embree::Geometry::getBufferData(RTCBufferType, unsigned int, embree::BufferDataPointerType) | virtual void* getBufferData(RTCBufferType type, unsigned int slot, BufferDataPointerType pointerType) {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"operation not supported for this geometry");
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl $0x30, %edi
callq 0x143c0
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa536b(%rip), %rsi # 0x11e959
leaq 0xa538d(%rip), %rdx # 0x11e982
movq %rsp, %rdi
callq 0x62274
leaq 0xef0f4(%rip), %rax # 0x1686f8
movq %rax, (%rbx)
movl $0x3,... | /embree[P]embree/kernels/common/geometry.h |
embree::Geometry::setTransform(embree::AffineSpaceT<embree::LinearSpace3<embree::Vec3fa>> const&, unsigned int) | virtual void setTransform(const AffineSpace3fa& transform, unsigned int timeStep) {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"operation not supported for this geometry");
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl $0x30, %edi
callq 0x143c0
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa511f(%rip), %rsi # 0x11e959
leaq 0xa5141(%rip), %rdx # 0x11e982
movq %rsp, %rdi
callq 0x62274
leaq 0xeeea8(%rip), %rax # 0x1686f8
movq %rax, (%rbx)
movl $0x3,... | /embree[P]embree/kernels/common/geometry.h |
embree::Geometry::getTransform(unsigned long, float) | virtual AffineSpace3fa getTransform(size_t instance, float time) {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"operation not supported for this geometry");
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl $0x30, %edi
callq 0x143c0
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa4ee5(%rip), %rsi # 0x11e959
leaq 0xa4f07(%rip), %rdx # 0x11e982
movq %rsp, %rdi
callq 0x62274
leaq 0xeec6e(%rip), %rax # 0x1686f8
movq %rax, (%rbx)
movl $0x3,... | /embree[P]embree/kernels/common/geometry.h |
embree::Geometry::computeAlignedSpaceMB(unsigned long, embree::BBox<float>) const | virtual LinearSpace3fa computeAlignedSpaceMB(const size_t primID, const BBox1f time_range) const {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"computeAlignedSpace not implemented for this geometry");
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl $0x30, %edi
callq 0x143c0
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa4777(%rip), %rsi # 0x11ea6f
leaq 0xa47a5(%rip), %rdx # 0x11eaa4
movq %rsp, %rdi
callq 0x62274
leaq 0xee3ea(%rip), %rax # 0x1686f8
movq %rax, (%rbx)
movl $0x3,... | /embree[P]embree/kernels/common/geometry.h |
embree::Geometry::computeDirection(unsigned int) const | virtual Vec3fa computeDirection(unsigned int primID) const {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"computeDirection not implemented for this geometry");
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl $0x30, %edi
callq 0x143c0
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa46ef(%rip), %rsi # 0x11eaa5
leaq 0xa471a(%rip), %rdx # 0x11ead7
movq %rsp, %rdi
callq 0x62274
leaq 0xee32c(%rip), %rax # 0x1686f8
movq %rax, (%rbx)
movl $0x3,... | /embree[P]embree/kernels/common/geometry.h |
embree::Geometry::computeDirection(unsigned int, unsigned long) const | virtual Vec3fa computeDirection(unsigned int primID, size_t time) const {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"computeDirection not implemented for this geometry");
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl $0x30, %edi
callq 0x143c0
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa4631(%rip), %rsi # 0x11eaa5
leaq 0xa465c(%rip), %rdx # 0x11ead7
movq %rsp, %rdi
callq 0x62274
leaq 0xee26e(%rip), %rax # 0x1686f8
movq %rax, (%rbx)
movl $0x3,... | /embree[P]embree/kernels/common/geometry.h |
embree::Geometry::vbounds(embree::LinearSpace3<embree::Vec3fa> const&, unsigned long) const | virtual BBox3fa vbounds(const LinearSpace3fa& space, size_t primID) const {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"vbounds not implemented for this geometry");
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl $0x30, %edi
callq 0x143c0
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa44e8(%rip), %rsi # 0x11ead8
leaq 0xa450a(%rip), %rdx # 0x11eb01
movq %rsp, %rdi
callq 0x62274
leaq 0xee0f2(%rip), %rax # 0x1686f8
movq %rax, (%rbx)
movl $0x3,... | /embree[P]embree/kernels/common/geometry.h |
embree::Geometry::vlinearBounds(embree::LinearSpace3<embree::Vec3fa> const&, unsigned long, embree::BBox<float> const&) const | virtual LBBox3fa vlinearBounds(const LinearSpace3fa& space, size_t primID, const BBox1f& time_range) const {
throw_RTCError(RTC_ERROR_INVALID_OPERATION,"vlinearBounds not implemented for this geometry");
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl $0x30, %edi
callq 0x143c0
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa42c6(%rip), %rsi # 0x11eb02
leaq 0xa42ee(%rip), %rdx # 0x11eb31
movq %rsp, %rdi
callq 0x62274
leaq 0xedea6(%rip), %rax # 0x1686f8
movq %rax, (%rbx)
movl $0x3,... | /embree[P]embree/kernels/common/geometry.h |
embree::Scene::checkIfModifiedAndSet() | void Scene::checkIfModifiedAndSet ()
{
if (isModified ()) return;
auto geometryIsModified = [this](size_t geomID)->bool {
return isGeometryModified(geomID);
};
if (parallel_any_of (size_t(0), geometries.size (), geometryIsModified)) {
setModified ();
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x130, %rsp # imm = 0x130
cmpb $0x0, 0x250(%rdi)
jne 0x7ab06
movq %rdi, %rbx
movq 0x1d8(%rdi), %r12
xorl %eax, %eax
xchgb %al, 0x7(%rsp)
movw $0x401, %bp # imm = 0x401
leaq 0xb0(%rsp), %r14
movw %bp, 0xc(%r14)
xorps %xmm0, %xmm0
movups ... | /embree[P]embree/kernels/common/scene_verify.cpp |
embree::getCompilerName[abi:cxx11]() | std::string getCompilerName()
{
#if defined(__INTEL_COMPILER)
int icc_mayor = __INTEL_COMPILER / 100 % 100;
int icc_minor = __INTEL_COMPILER % 100;
std::string version = "Intel Compiler ";
version += toString(icc_mayor);
version += "." + toString(icc_minor);
#if defined(__INTEL_COMPILER_UPDATE)
... | pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
leaq 0xa3cd1(%rip), %rsi # 0x11ed2e
leaq 0xa3d2f(%rip), %rdx # 0x11ed93
callq 0x62274
movq %rbx, %rax
popq %rbx
retq
| /embree[P]embree/common/sys/sysinfo.cpp |
embree::getCPUModel() | CPU getCPUModel()
{
#if defined(__X86_ASM__)
if (getCPUVendor() != "GenuineIntel")
return CPU::UNKNOWN;
int out[4];
__cpuid(out, 0);
if (out[0] < 1) return CPU::UNKNOWN;
__cpuid(out, 1);
/* please see CPUID documentation for these formulas */
uint32_t family_ID = (out... | pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x7b06e
leaq 0xa3cba(%rip), %rsi # 0x11ed94
movq %r14, %rdi
callq 0x14240
movl %eax, %ebx
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x7b0f6
callq 0x14760
movl $0x15, %esi
testl %ebx, %ebx
je 0x7b109
movl %esi, %eax
ad... | /embree[P]embree/common/sys/sysinfo.cpp |
embree::stringOfCPUFeatures[abi:cxx11](int) | std::string stringOfCPUFeatures(int features)
{
std::string str;
if (features & CPU_FEATURE_XMM_ENABLED) str += "XMM ";
if (features & CPU_FEATURE_YMM_ENABLED) str += "YMM ";
if (features & CPU_FEATURE_ZMM_ENABLED) str += "ZMM ";
if (features & CPU_FEATURE_SSE ) str += "SSE ";
if (features &... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
btl $0x19, %esi
jae 0x7b73c
leaq 0xa37b0(%rip), %rsi # 0x11eee4
movq %rbx, %rdi
callq 0x15190
btl $0x1a, %ebp
jae 0x7b751
leaq 0xa37a0(%rip), %rsi... | /embree[P]embree/common/sys/sysinfo.cpp |
embree::stringOfISA[abi:cxx11](int) | std::string stringOfISA (int isa)
{
if (isa == SSE) return "SSE";
if (isa == SSE2) return "SSE2";
if (isa == SSE3) return "SSE3";
if (isa == SSSE3) return "SSSE3";
if (isa == SSE41) return "SSE4.1";
if (isa == SSE42) return "SSE4.2";
if (isa == AVX) return "AVX";
if (isa == AVX2) retur... | pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
cmpl $0x200007e, %esi # imm = 0x200007E
jle 0x7b9ff
cmpl $0xe737dfe, %esi # imm = 0xE737DFE
jg 0x7ba3e
cmpl $0x200007f, %esi # imm = 0x200007F
je 0x7bae5
cmpl $0x60000ff, %esi # imm = 0x60000FF
je 0x7bab5
cmpl $0x6007dff, %es... | /embree[P]embree/common/sys/sysinfo.cpp |
embree::supportedTargetList[abi:cxx11](int) | std::string supportedTargetList (int features)
{
std::string v;
if (hasISA(features,SSE)) v += "SSE ";
if (hasISA(features,SSE2)) v += "SSE2 ";
if (hasISA(features,SSE3)) v += "SSE3 ";
if (hasISA(features,SSSE3)) v += "SSSE3 ";
if (hasISA(features,SSE41)) v += "SSE4.1 ";
if (hasISA(feature... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
notl %ebp
testl $0x2000001, %ebp # imm = 0x2000001
jne 0x7bb60
leaq 0xa339b(%rip), %rsi # 0x11eef3
movq %rbx, %rdi
callq 0x15190
testl $0x2... | /embree[P]embree/common/sys/sysinfo.cpp |
embree::getExecutableFileName[abi:cxx11]() | std::string getExecutableFileName()
{
std::string pid = "/proc/" + toString(getpid()) + "/exe";
char buf[4096];
memset(buf,0,sizeof(buf));
if (readlink(pid.c_str(), buf, sizeof(buf)-1) == -1)
return std::string();
return std::string(buf);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1048, %rsp # imm = 0x1048
movq %rdi, %rbx
callq 0x14cb0
movslq %eax, %r15
movq %r15, %r14
negq %r14
cmovsq %r15, %r14
movl $0x1, %r12d
cmpq $0xa, %r14
jb 0x7bd09
movl $0x4, %r12d
movabsq $0x346dc5d63886594b, %rsi # imm = 0x346DC5D638865... | /embree[P]embree/common/sys/sysinfo.cpp |
embree::getNumberOfLogicalThreads() | unsigned int getNumberOfLogicalThreads()
{
static int nThreads = -1;
if (nThreads != -1) return nThreads;
#if defined(__MACOSX__) || defined(__ANDROID__)
nThreads = sysconf(_SC_NPROCESSORS_ONLN); // does not work in Linux LXC container
assert(nThreads);
#elif defined(__EMSCRIPTEN__)
// WebAssemb... | movl 0xf07e1(%rip), %eax # 0x16c7d0
cmpl $-0x1, %eax
je 0x7bff5
retq
subq $0x88, %rsp
callq 0x14700
leaq 0x8(%rsp), %rdx
movl $0x80, %esi
movq %rax, %rdi
callq 0x15000
testl %eax, %eax
je 0x7c01f
movl 0xf07b3(%rip), %eax # 0x16c7d0
jmp 0x7c034
leaq 0x8(%rsp), %rsi
movl $0x80, %edi
callq 0x14120
movl %eax, 0xf07... | /embree[P]embree/common/sys/sysinfo.cpp |
embree::os_init(bool, bool) | bool os_init(bool hugepages, bool verbose)
{
Lock<MutexSys> lock(os_init_mutex);
if (!hugepages) {
huge_pages_enabled = false;
return true;
}
#if defined(__LINUX__)
int hugepagesize = 0;
std::ifstream file;
file.open("/proc/meminfo",std::ios::in);
if (!file.is_open()) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x438, %rsp # imm = 0x438
movl %esi, %ebp
movl %edi, %ebx
leaq 0xf07dd(%rip), %rdi # 0x16c930
movq %rdi, 0x98(%rsp)
movb $0x1, 0xa0(%rsp)
callq 0x7dc5a
testl %ebx, %ebx
je 0x7c4b5
leaq 0x230(%rsp), %rdi
callq 0x148f0
leaq 0xa2e78(%ri... | /embree[P]embree/common/sys/alloc.cpp |
embree::os_malloc(unsigned long, bool&) | void* os_malloc(size_t bytes, bool& hugepages)
{
if (bytes == 0) {
hugepages = false;
return nullptr;
}
/* try direct huge page allocation first */
if (isHugePageCandidate(bytes))
{
#if defined(__MACOSX__)
void* ptr = mmap(0, bytes, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_AN... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
testq %rdi, %rdi
je 0x7c6ee
movq %rdi, %r14
cmpb $0x1, 0xf02d9(%rip) # 0x16c938
jne 0x7c6b3
leaq 0x1fffff(%r14), %rax
movabsq $0x7fffffffffe00000, %rcx # imm = 0x7FFFFFFFFFE00000
andq %rax, %rcx
subq %r14, %rcx
movq %rcx, %rax
shlq $0x6, %rax
leaq (%rax,%rcx,2), %rax... | /embree[P]embree/common/sys/alloc.cpp |
embree::os_free(void*, unsigned long, bool) | void os_free(void* ptr, size_t bytes, bool hugepages)
{
if (bytes == 0)
return;
/* for hugepages we need to also align the size */
const size_t pageSize = hugepages ? PAGE_SIZE_2M : PAGE_SIZE_4K;
bytes = (bytes+pageSize-1) & ~(pageSize-1);
if (munmap(ptr,bytes) == -1)
throw std::bad_... | pushq %rax
testq %rsi, %rsi
je 0x7c7ed
leaq 0x1000(%rsi), %rax
addq $0x200000, %rsi # imm = 0x200000
testb %dl, %dl
movq $-0x200000, %rcx # imm = 0xFFE00000
movq $-0x1000, %rdx # imm = 0xF000
cmovneq %rcx, %rdx
cmoveq %rax, %rsi
decq %rsi
andq %rdx, %rsi
callq 0x14490
cmpl $-0x1, %eax
je 0x7c7ef... | /embree[P]embree/common/sys/alloc.cpp |
embree::FileName::FileName(char const*) | FileName::FileName (const char* in) {
filename = in;
for (size_t i=0; i<filename.size(); i++)
if (filename[i] == '\\' || filename[i] == '/')
filename[i] = path_sep;
while (!filename.empty() && filename[filename.size()-1] == path_sep)
filename.resize(filename.size()-1);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x14390
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %rcx
movq %rax, %r8
callq 0x14d90
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x7c8ba
... | /embree[P]embree/common/sys/filename.cpp |
embree::FileName::FileName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | FileName::FileName (const std::string& in) {
filename = in;
for (size_t i=0; i<filename.size(); i++)
if (filename[i] == '\\' || filename[i] == '/')
filename[i] = path_sep;
while (!filename.empty() && filename[filename.size()-1] == path_sep)
filename.resize(filename.size()-1);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
callq 0x14450
movq 0x8(%rbx), %rsi
testq %rsi, %rsi
je 0x7c948
xorl %eax, %eax
movq (%rbx), %rcx
movzbl (%rcx,%rax), %edx
cmpl $0x5c, %edx
je 0x7c916
cmpl $0x2f, %edx
jne 0x7c91e
movb $0x2... | /embree[P]embree/common/sys/filename.cpp |
embree::FileName::executableFolder() | FileName FileName::executableFolder() {
return FileName(getExecutableFileName()).path();
} | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x7bc83
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x7c8da
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x7ca00
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7c9ac
callq 0x14760
leaq 0x38(%rsp), %rax
mov... | /embree[P]embree/common/sys/filename.cpp |
embree::FileName::path() const | FileName FileName::path() const {
size_t pos = filename.find_last_of(path_sep);
if (pos == std::string::npos) return FileName();
return filename.substr(0,pos);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x2f, %esi
movq $-0x1, %rdx
callq 0x151d0
cmpq $-0x1, %rax
je 0x7ca5c
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x14830
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7c8da
leaq 0... | /embree[P]embree/common/sys/filename.cpp |
embree::FileName::base[abi:cxx11]() const | std::string FileName::base() const {
size_t pos = filename.find_last_of(path_sep);
if (pos == std::string::npos) return filename;
return filename.substr(pos+1);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x2f, %esi
movq $-0x1, %rdx
callq 0x151d0
cmpq $-0x1, %rax
je 0x7cad8
incq %rax
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
movq $-0x1, %rcx
callq 0x14830
jmp 0x7caf1
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq... | /embree[P]embree/common/sys/filename.cpp |
embree::FileName::ext[abi:cxx11]() const | std::string FileName::ext() const {
size_t pos = filename.find_last_of('.');
if (pos == std::string::npos) return "";
return filename.substr(pos+1);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movl $0x2e, %esi
movq $-0x1, %rdx
callq 0x151d0
cmpq $-0x1, %rax
je 0x7cb3a
incq %rax
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
movq $-0x1, %rcx
callq 0x14830
jmp 0x7cb53
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xa4443(%rip), %r... | /embree[P]embree/common/sys/filename.cpp |
embree::FileName::addExt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | FileName FileName::addExt(const std::string& ext) const {
return FileName(filename+ext);
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x39e1b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7c8da
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7cde3
callq 0x14760
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x1... | /embree[P]embree/common/sys/filename.cpp |
embree::FileName::operator+(embree::FileName const&) const | FileName FileName::operator +( const FileName& other ) const {
if (filename == "") return FileName(other);
else return FileName(filename + path_sep + other.filename);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0xa4164(%rip), %rsi # 0x120f8b
movq %r15, %rdi
callq 0x14240
testl %eax, %eax
je 0x7cea5
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp... | /embree[P]embree/common/sys/filename.cpp |
embree::FileName::operator+(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | FileName FileName::operator +( const std::string& other ) const {
return operator+(FileName(other));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
movq %rdx, %rsi
callq 0x7c8da
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x7ce0c
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7cf86
callq 0x14760
movq %rbx, %rax
addq $0x20, ... | /embree[P]embree/common/sys/filename.cpp |
embree::FileName::operator-(embree::FileName const&) const | FileName FileName::operator -( const FileName& base ) const {
size_t pos = filename.find_first_of(base);
if (pos == std::string::npos) return *this;
return FileName(filename.substr(pos+1));
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
movq %rsp, %r12
movq %r12, %rdi
callq 0x621de
movq (%r12), %rsi
movq 0x8(%r12), %rcx
movq %r14, %rdi
xorl %edx, %edx... | /embree[P]embree/common/sys/filename.cpp |
embree::mapThreadID(unsigned long) | size_t mapThreadID(size_t threadID)
{
Lock<MutexSys> lock(mutex);
if (threadIDs.size() == 0)
{
/* parse thread/CPU topology */
for (size_t cpuID=0;;cpuID++)
{
std::fstream fs;
std::string cpu = std::string("/sys/devices/system/cpu/cpu") + std::to_string((long long)cp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2d8, %rsp # imm = 0x2D8
movq %rdi, %r14
leaq 0xef841(%rip), %rdi # 0x16c948
movq %rdi, 0xb0(%rsp)
movb $0x1, 0xb8(%rsp)
callq 0x7dc5a
movq 0xef835(%rip), %rcx # 0x16c958
movq 0xef826(%rip), %rax # 0x16c950
cmpq %rax, %rcx
j... | /embree[P]embree/common/sys/thread.cpp |
embree::setAffinity(long) | void setAffinity(ssize_t affinity)
{
cpu_set_t cset;
CPU_ZERO(&cset);
//size_t threadID = mapThreadID(affinity); // this is not working properly in LXC containers when some processors are disabled
size_t threadID = affinity;
CPU_SET(threadID, &cset);
pthread_setaffinity_np(pthread_self(), siz... | subq $0x88, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%rsp)
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
cmpq $0x3ff, %rdi # imm = 0x3FF
ja 0x7d784
movl $0x1, %eax
movl %edi, %ecx
sh... | /embree[P]embree/common/sys/thread.cpp |
embree::createThread(void (*)(void*), void*, unsigned long, long) | thread_t createThread(thread_func f, void* arg, size_t stack_size, ssize_t threadID)
{
/* set stack size */
pthread_attr_t attr;
pthread_attr_init(&attr);
if (stack_size > 0) pthread_attr_setstacksize (&attr, stack_size);
/* create thread */
pthread_t* tid = new pthread_t;
if (pthread_cre... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
leaq 0x88(%rsp), %rdi
callq 0x14a20
testq %rbx, %rbx
je 0x7d7de
leaq 0x88(%rsp), %rdi
movq %rbx, %rsi
callq 0x14b90
movl $0x8, %edi
callq 0x147e0
movq %rax, %rbx
movl $0x18, %edi
callq... | /embree[P]embree/common/sys/thread.cpp |
embree::threadStartup(embree::ThreadStartupData*) | static void* threadStartup(ThreadStartupData* parg)
{
_mm_setcsr(_mm_getcsr() | /*FTZ:*/ (1<<15) | /*DAZ:*/ (1<<6));
/*! Mac OS X does not support setting affinity at thread creation time */
#if defined(__MACOSX__)
if (parg->affinity >= 0)
setAffinity(parg->affinity);
#endif
parg->f(parg->arg);... | pushq %rbx
subq $0x10, %rsp
stmxcsr 0xc(%rsp)
movl $0x8040, %eax # imm = 0x8040
orl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
ldmxcsr 0x8(%rsp)
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq *(%rbx)
movq %rbx, %rdi
callq 0x14760
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
| /embree[P]embree/common/sys/thread.cpp |
embree::destroyThread(embree::opaque_thread_t*) | void destroyThread(thread_t tid) {
#if defined(__ANDROID__)
FATAL("Can't destroy threads on Android."); // pthread_cancel not implemented.
#else
pthread_cancel(*(pthread_t*)tid);
delete (pthread_t*)tid;
#endif
} | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x14bc0
movq %rbx, %rdi
popq %rbx
jmp 0x14760
| /embree[P]embree/common/sys/thread.cpp |
embree::createTls() | tls_t createTls()
{
pthread_key_t* key = new pthread_key_t;
if (pthread_key_create(key,nullptr) != 0) {
delete key;
FATAL("pthread_key_create failed");
}
return tls_t(key);
} | pushq %r14
pushq %rbx
pushq %rax
movl $0x4, %edi
callq 0x147e0
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
callq 0x14e10
testl %eax, %eax
jne 0x7d9d1
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
callq 0x14760
movl $0x10, %edi
callq 0x143c0
movq %rax, %rbx
leaq 0xa1733(%rip), %rsi # 0... | /embree[P]embree/common/sys/thread.cpp |
embree::BarrierSys::BarrierSys(unsigned long) | BarrierSys::BarrierSys (size_t N) {
opaque = new BarrierSysImplementation(N);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movl $0x20, %edi
callq 0x147e0
movq %rax, %rbx
movq %rax, %rdi
callq 0x7dbcc
movq %rbx, %rdi
addq $0x8, %rdi
callq 0x7e4ec
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movq %rax, 0x10(%rbx)
movq %r15, 0x18(%rbx)
movq %rbx, (%r14)
popq %rbx
... | /embree[P]embree/common/sys/barrier.cpp |
embree::barrier_sys_regression_test::barrier_sys_regression_test() | barrier_sys_regression_test()
: RegressionTest("barrier_sys_regression_test"), threadID(0), numFailed(0)
{
registerRegressionTest(this);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xa12bd(%rip), %rsi # 0x11f1bf
leaq 0xa12d1(%rip), %rdx # 0x11f1da
movq %rsp, %r14
movq %r14, %rdi
callq 0x62274
leaq 0xebb55(%rip), %r12 # 0x169a70
movq %r12, (%rbx)
lea... | /embree[P]embree/common/sys/barrier.cpp |
embree::barrier_sys_regression_test::run() | bool run ()
{
threadID.store(0);
numFailed.store(0);
size_t numThreads = getNumberOfLogicalThreads();
threadResults.resize(numThreads);
barrier.init(numThreads+1);
/* create threads */
std::vector<thread_t> threads;
for (size_t i=0; i<numThreads; i++)
thread... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorl %r12d, %r12d
xorl %eax, %eax
xchgq %rax, 0x30(%rdi)
xorl %eax, %eax
xchgq %rax, 0x38(%rdi)
callq 0x7bfe9
movl %eax, %ebp
movl %eax, %r14d
leaq 0x40(%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x7e18a
leaq 0x1(%... | /embree[P]embree/common/sys/barrier.cpp |
embree::barrier_sys_regression_test::thread_alloc(embree::barrier_sys_regression_test*) | static void thread_alloc(barrier_sys_regression_test* This)
{
size_t tid = This->threadID++;
for (size_t j=0; j<1000; j++)
{
This->barrier.wait();
This->threadResults[tid] = tid;
This->barrier.wait();
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %r15d
lock
xaddq %r15, 0x30(%rdi)
leaq 0x28(%rdi), %r14
movl $0x3e8, %r12d # imm = 0x3E8
movq %r14, %rdi
callq 0x7ddc4
movq 0x40(%rbx), %rax
movq %r15, (%rax,%r15,8)
movq %r14, %rdi
callq 0x7ddc4
decq %r12
jne 0x7e1dd
addq $0x8,... | /embree[P]embree/common/sys/barrier.cpp |
embree::SceneGraph::PerspectiveCameraNode::print(std::ostream&, int) | void SceneGraph::PerspectiveCameraNode::print(std::ostream& cout, int depth) {
cout << "PerspectiveCameraNode @ " << this << " { " << std::endl;
if (name != "") {
tab(cout, depth+1); cout << "name = " << name << std::endl;
}
tab(cout, depth+1); cout << "from = " << data.from << std::endl;
tab(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
leaq 0xa0888(%rip), %rsi # 0x11f575
movl $0x18, %edx
movq %rbx, %rdi
callq 0x14900
movq %rbx, %rdi
movq %r15, %rsi
callq 0x14650
movq %rax, %r12
leaq 0xa0832(%rip), %rsi # 0x11f541
movl ... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.cpp |
embree::SceneGraph::TransformNode::print(std::ostream&, int) | void SceneGraph::TransformNode::print(std::ostream& cout, int depth)
{
cout << "TransformNode @ " << this << " { " << std::endl;
tab(cout, depth+1); cout << "closed = " << closed << std::endl;
tab(cout, depth+1); cout << "numTimeSteps = " << spaces.size() << std::endl;
tab(cout, depth+1); cout << "chi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
leaq 0xa023b(%rip), %rsi # 0x11f5ac
movl $0x10, %edx
movq %rbx, %rdi
callq 0x14900
movq %rbx, %rdi
movq %r15, %rsi
callq 0x14650
movq %rax, %r12
leaq 0xa01ae(%rip), %rsi # 0x11f541
movl ... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.cpp |
embree::SceneGraph::MultiTransformNode::print(std::ostream&, int) | void SceneGraph::MultiTransformNode::print(std::ostream& cout, int depth)
{
cout << "MultiTransformNode @ " << this << " { " << std::endl;
tab(cout, depth+1); cout << "closed = " << closed << std::endl;
tab(cout, depth+1); cout << "numInstances = " << spaces.size() << std::endl;
if (spaces.size() > 0)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
leaq 0xa002e(%rip), %rsi # 0x11f5a7
movl $0x15, %edx
movq %rbx, %rdi
callq 0x14900
movq %rbx, %rdi
movq %r15, %rsi
callq 0x14650
movq %rax, %r12
leaq 0x9ffa6(%rip), %rsi # 0x11f541
movl ... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.cpp |
embree::SceneGraph::GroupNode::print(std::ostream&, int) | void SceneGraph::GroupNode::print(std::ostream& cout, int depth)
{
cout << "GroupNode @ " << this << " { " << std::endl;
tab(cout, depth+1); cout << "closed = " << closed << std::endl;
for (size_t i=0; i<children.size(); i++) {
tab(cout, depth+1); cout << "child" << i << " = "; children[i]->print(co... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x9fdba(%rip), %rsi # 0x11f5cd
movl $0xc, %edx
movq %rbx, %rdi
callq 0x14900
movq %rbx, %rdi
movq %r15, %rsi
callq 0x14650
movq %rax, %r12
leaq 0x9fd0c(%rip), %rsi # 0x11f541
movl $... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.cpp |
embree::SceneGraph::MaterialNode::print(std::ostream&, int) | void SceneGraph::MaterialNode::print(std::ostream& cout, int depth) {
cout << "MaterialNode @ " << this << " { closed = " << closed << " }" << std::endl;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x9fbed(%rip), %rsi # 0x11f5e0
movl $0xf, %edx
movq %rbx, %rdi
callq 0x14900
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14650
movq %rax, %rbx
leaq 0x9fbdb(%rip), %rsi # 0x11f5f0
movl $0xc, %edx
movq %rax, %rdi
callq 0x14900
movzbl 0x58(%r14), %e... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.cpp |
embree::SceneGraph::LightNode::print(std::ostream&, int) | void SceneGraph::LightNode::print(std::ostream& cout, int depth) {
cout << "LightNode @ " << this << " { closed = " << closed << " }" << std::endl;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x9fb7b(%rip), %rsi # 0x11f600
movl $0xc, %edx
movq %rbx, %rdi
callq 0x14900
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14650
movq %rax, %rbx
leaq 0x9fb49(%rip), %rsi # 0x11f5f0
movl $0xc, %edx
movq %rax, %rdi
callq 0x14900
movzbl 0x58(%r14), %e... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.cpp |
embree::SceneGraph::TriangleMeshNode::print(std::ostream&, int) | void SceneGraph::TriangleMeshNode::print(std::ostream& cout, int depth) {
cout << "TriangleMeshNode @ " << this << " { closed = " << closed << " }" << std::endl;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x9faf6(%rip), %rsi # 0x11f60d
movl $0x13, %edx
movq %rbx, %rdi
callq 0x14900
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14650
movq %rax, %rbx
leaq 0x9fab7(%rip), %rsi # 0x11f5f0
movl $0xc, %edx
movq %rax, %rdi
callq 0x14900
movzbl 0x58(%r14), %... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.cpp |
embree::SceneGraph::QuadMeshNode::print(std::ostream&, int) | void SceneGraph::QuadMeshNode::print(std::ostream& cout, int depth) {
cout << "QuadMeshNode @ " << this << " { closed = " << closed << " }" << std::endl;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x9fa78(%rip), %rsi # 0x11f621
movl $0xf, %edx
movq %rbx, %rdi
callq 0x14900
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14650
movq %rax, %rbx
leaq 0x9fa25(%rip), %rsi # 0x11f5f0
movl $0xc, %edx
movq %rax, %rdi
callq 0x14900
movzbl 0x58(%r14), %e... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.cpp |
embree::SceneGraph::SubdivMeshNode::print(std::ostream&, int) | void SceneGraph::SubdivMeshNode::print(std::ostream& cout, int depth) {
cout << "SubdivMeshNode @ " << this << " { closed = " << closed << " }" << std::endl;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x9f9f6(%rip), %rsi # 0x11f631
movl $0x11, %edx
movq %rbx, %rdi
callq 0x14900
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14650
movq %rax, %rbx
leaq 0x9f993(%rip), %rsi # 0x11f5f0
movl $0xc, %edx
movq %rax, %rdi
callq 0x14900
movzbl 0x58(%r14), %... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.cpp |
embree::SceneGraph::HairSetNode::print(std::ostream&, int) | void SceneGraph::HairSetNode::print(std::ostream& cout, int depth) {
cout << "HairSetNode @ " << this << " { closed = " << closed << " }" << std::endl;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x9f976(%rip), %rsi # 0x11f643
movl $0xe, %edx
movq %rbx, %rdi
callq 0x14900
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14650
movq %rax, %rbx
leaq 0x9f901(%rip), %rsi # 0x11f5f0
movl $0xc, %edx
movq %rax, %rdi
callq 0x14900
movzbl 0x58(%r14), %e... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.cpp |
embree::SceneGraph::GridMeshNode::print(std::ostream&, int) | void SceneGraph::GridMeshNode::print(std::ostream& cout, int depth) {
cout << "GridMeshNode @ " << this << " { closed = " << closed << " }" << std::endl;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x9f871(%rip), %rsi # 0x11f662
movl $0xf, %edx
movq %rbx, %rdi
callq 0x14900
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14650
movq %rax, %rbx
leaq 0x9f7dd(%rip), %rsi # 0x11f5f0
movl $0xc, %edx
movq %rax, %rdi
callq 0x14900
movzbl 0x58(%r14), %e... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.cpp |
embree::SceneGraph::TriangleMeshNode::calculateStatistics(embree::SceneGraph::Statistics&) | void SceneGraph::TriangleMeshNode::calculateStatistics(Statistics& stat)
{
indegree++;
if (indegree == 1) {
stat.numTriangleMeshes++;
stat.numTriangles += numPrimitives();
stat.numTriangleBytes += numBytes();
material->calculateStatistics(stat);
}
} | movq 0x50(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x50(%rdi)
testq %rax, %rax
je 0x7fef2
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
incq (%rsi)
movq (%rdi), %rax
callq *0x70(%rax)
addq %rax, 0x8(%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x70(%rax)
leaq (%rax,%rax,2), %rax
shlq $0x2, ... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.cpp |
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 0x7ff6a
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
incq 0x18(%rsi)
movq (%rdi), %rax
callq *0x70(%rax)
addq %rax, 0x20(%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x70(%rax)
movq 0x70(%r14), %rcx
movq 0x78... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.cpp |
embree::SceneGraph::SubdivMeshNode::calculateStatistics(embree::SceneGraph::Statistics&) | void SceneGraph::SubdivMeshNode::calculateStatistics(Statistics& stat)
{
indegree++;
if (indegree == 1) {
stat.numSubdivMeshes++;
stat.numPatches += numPrimitives();
stat.numSubdivBytes += numBytes();
material->calculateStatistics(stat);
}
} | movq 0x50(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x50(%rdi)
testq %rax, %rax
je 0x7ffd6
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
incq 0x30(%rsi)
movq (%rdi), %rax
callq *0x70(%rax)
addq %rax, 0x38(%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x70(%rax)
shlq $0x2, %rax
addq 0xc0(%r14)... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.cpp |
embree::SceneGraph::HairSetNode::calculateStatistics(embree::SceneGraph::Statistics&) | void SceneGraph::HairSetNode::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 0x8005c
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 (%r14), %rax
movq %r14, %rdi
callq *0x70(%rax)
shlq $0x3, %rax
movq 0x78(%r14)... | /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 0x800d4
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
incq 0x48(%rsi)
movq (%rdi), %rax
callq *0x70(%rax)
addq %rax, 0x50(%rbx)
movq 0x78(%r14), %rax
movq 0x80(%r14), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
imulq 0... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.cpp |
embree::SceneGraph::TransformNode::calculateStatistics(embree::SceneGraph::Statistics&) | void SceneGraph::TransformNode::calculateStatistics(Statistics& stat)
{
indegree++;
if (indegree == 1)
{
child->calculateStatistics(stat);
stat.numTransformNodes++;
if (child->indegree == 1)
stat.numTransformedObjects++;
if (spaces.size() > 1) child->calculate... | pushq %r14
pushq %rbx
pushq %rax
movq 0x50(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x50(%rdi)
testq %rax, %rax
jne 0x80203
movq %rsi, %rbx
movq %rdi, %r14
movq 0x98(%rdi), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
incq 0x90(%rbx)
movq 0x98(%r14), %rax
cmpq $0x1, 0x50(%rax)
jne 0x801e2
incq 0x98(%rbx)
cmpq $0x2, 0x78... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.cpp |
embree::SceneGraph::Statistics::print() | void SceneGraph::Statistics::print()
{
std::cout << " # transform nodes : " << numTransformNodes << std::endl;
std::cout << " # objects : " << numTransformedObjects << std::endl;
std::cout << " # triangle meshes : " << numTriangleMeshes << " ( " << 1E-6*numTriangleBytes << " MB )" << std::endl;... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0xebc55(%rip), %r14 # 0x16bf98
leaq 0x9f328(%rip), %rsi # 0x11f672
movl $0x16, %edx
movq %r14, %rdi
callq 0x14900
movq 0x90(%rbx), %rsi
movq %r14, %rdi
callq 0x14590
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %r... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.cpp |
embree::SceneGraph::TransformNode::calculateInDegree() | void SceneGraph::TransformNode::calculateInDegree()
{
indegree++;
if (indegree == 1) {
child->calculateInDegree();
if (spaces.size() > 1) child->calculateInDegree(); // break instance up when motion blur is used
}
} | pushq %rbx
movq 0x50(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x50(%rdi)
testq %rax, %rax
jne 0x80b4d
movq %rdi, %rbx
movq 0x98(%rdi), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
cmpq $0x2, 0x78(%rbx)
jb 0x80b4d
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
popq %rbx
jmpq *0x30(%rax)
popq %rbx
retq
nop
| /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 0x80b62
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
movq 0x70(%rbx), %rcx
cmpq %rax, %rcx
je 0x80bd0
movl $0x10, %r14d
xorl... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.cpp |
embree::SceneGraph::GroupNode::calculateInDegree() | void SceneGraph::GroupNode::calculateInDegree()
{
indegree++;
if (indegree == 1) {
for (auto& c : children)
c->calculateInDegree();
}
} | movq 0x50(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x50(%rdi)
testq %rax, %rax
je 0x80bee
retq
pushq %r14
pushq %rbx
pushq %rax
movq 0x68(%rdi), %rbx
movq 0x70(%rdi), %r14
cmpq %r14, %rbx
je 0x80c0e
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
addq $0x8, %rbx
jmp 0x80bfa
addq $0x8, %rsp
popq %rbx
popq %r14
... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.cpp |
embree::SceneGraph::TransformNode::calculateClosed(bool) | bool SceneGraph::TransformNode::calculateClosed(bool group_instancing)
{
assert(indegree);
if (!closed) {
closed = group_instancing;
closed &= child->calculateClosed(group_instancing);
hasLightOrCamera = child->hasLightOrCamera;
}
return closed && (indegree == 1);
} | pushq %rbx
movq %rdi, %rbx
movb $0x1, %al
cmpb $0x0, 0x58(%rdi)
jne 0x80c8a
movb %sil, 0x58(%rbx)
movq 0x98(%rbx), %rdi
movq (%rdi), %rax
movzbl %sil, %esi
callq *0x38(%rax)
andb 0x58(%rbx), %al
movb %al, 0x58(%rbx)
movq 0x98(%rbx), %rcx
movb 0x59(%rcx), %cl
movb %cl, 0x59(%rbx)
cmpq $0x1, 0x50(%rbx)
sete %cl
andb %al,... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.cpp |
embree::SceneGraph::MultiTransformNode::calculateClosed(bool) | bool SceneGraph::MultiTransformNode::calculateClosed(bool group_instancing)
{
assert(indegree);
if (!closed) {
closed = group_instancing;
closed &= child->calculateClosed(group_instancing);
hasLightOrCamera = child->hasLightOrCamera;
}
return closed && (indegree == 1);
} | pushq %rbx
movq %rdi, %rbx
movb $0x1, %al
cmpb $0x0, 0x58(%rdi)
jne 0x80ccc
movb %sil, 0x58(%rbx)
movq 0x80(%rbx), %rdi
movq (%rdi), %rax
movzbl %sil, %esi
callq *0x38(%rax)
andb 0x58(%rbx), %al
movb %al, 0x58(%rbx)
movq 0x80(%rbx), %rcx
movb 0x59(%rcx), %cl
movb %cl, 0x59(%rbx)
cmpq $0x1, 0x50(%rbx)
sete %cl
andb %al,... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.cpp |
embree::SceneGraph::GroupNode::calculateClosed(bool) | bool SceneGraph::GroupNode::calculateClosed(bool group_instancing)
{
assert(indegree);
if (!closed) {
closed = group_instancing;
hasLightOrCamera = false;
for (auto& c : children) {
closed &= c->calculateClosed(group_instancing);
hasLightOrCamera |= c->hasLightOrCamera;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb 0x58(%rdi), %al
testb %al, %al
jne 0x80d2b
movb %sil, 0x58(%rbx)
movb $0x0, 0x59(%rbx)
movq 0x68(%rbx), %r14
movq 0x70(%rbx), %r15
cmpq %r15, %r14
je 0x80d29
movzbl %sil, %ebp
movq (%r14), %rdi
movq (%rdi), %rax
movl %ebp, %esi
callq *0x38(%rax... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.cpp |
embree::bezier_to_bspline_helper(std::vector<embree::SceneGraph::HairSetNode::Hair, std::allocator<embree::SceneGraph::HairSetNode::Hair>> const&, embree::vector_t<embree::Vec3fx, embree::aligned_allocator<embree::Vec3fx, 16ul>> const&) | avector<Vec3ff> bezier_to_bspline_helper(const std::vector<SceneGraph::HairSetNode::Hair>& indices, const avector<Vec3ff>& positions)
{
avector<Vec3ff> positions_o;
positions_o.resize(4*indices.size());
for (size_t i=0; i<indices.size(); i++)
{
const size_t idx = indices[i].vertex;
vfloat... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rdi), %rdx
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq $0x0, 0x18(%rdi)
movq (%rsi), %rcx
movq 0x8(%rsi), %rax
movq %rax, %rbp
subq %rcx, %rbp
sarq %rbp
movq %rax, %rdi
subq %rcx, %... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.cpp |
embree::bezier_to_hermite_helper(std::vector<embree::SceneGraph::HairSetNode::Hair, std::allocator<embree::SceneGraph::HairSetNode::Hair>> const&, embree::vector_t<embree::Vec3fx, embree::aligned_allocator<embree::Vec3fx, 16ul>> const&) | std::pair<avector<Vec3ff>,avector<Vec3ff>> bezier_to_hermite_helper(const std::vector<SceneGraph::HairSetNode::Hair>& indices, const avector<Vec3ff>& positions)
{
avector<Vec3ff> positions_o; positions_o.resize(2*indices.size());
avector<Vec3ff> tangents_o; tangents_o.resize(2*indices.size());
for (... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rsp)
movq $0x0, 0x40(%rsp)
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
movq %rcx, %rbp
subq %rax, %rbp
sarq $0x2, %rbp
movq %rcx, %rdi
subq %rax, %rdi
je 0... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.cpp |
embree::SceneGraph::HairSetNode::compact_vertices() | void SceneGraph::HairSetNode::compact_vertices()
{
std::vector<avector<Vec3ff>> positions_o(positions.size());
for (size_t i=0; i<positions.size(); i++)
positions_o.reserve(positions[i].size());
for (size_t i=0; i<hairs.size(); i++)
{
unsigned idx = hairs[i].vertex;
if (test_lo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %r13
movq 0x80(%rdi), %rsi
subq 0x78(%rdi), %rsi
sarq $0x5, %rsi
leaq 0x30(%rsp), %rdi
leaq 0xa0(%rsp), %rdx
callq 0x8b3a8
movq 0x78(%r13), %rax
movq 0x80(%r13), %rcx
cmpq %rax, %rcx
je 0x82555
movl $0x8, %ebx
xorl %r15d, %r15... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.cpp |
embree::SceneGraph::extend_animation(embree::Ref<embree::SceneGraph::Node>, embree::Ref<embree::SceneGraph::Node>) | void SceneGraph::GridMeshNode::print(std::ostream& cout, int depth) {
cout << "GridMeshNode @ " << this << " { closed = " << closed << " }" << std::endl;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %r15
cmpq (%rsi), %r15
sete %al
testq %r15, %r15
sete %cl
orb %al, %cl
jne 0x834e9
movq %rsi, %rbx
leaq 0xe6bcf(%rip), %rsi # 0x169b00
leaq 0xe6dd0(%rip), %rdx # 0x169d08
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x148e0... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.cpp |
embree::SceneGraph::optimize_animation(embree::Ref<embree::SceneGraph::Node>) | void SceneGraph::HairSetNode::print(std::ostream& cout, int depth) {
cout << "HairSetNode @ " << this << " { closed = " << closed << " }" << std::endl;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq (%rdi), %r14
testq %r14, %r14
je 0x83ffe
leaq 0xe6034(%rip), %rsi # 0x169b00
leaq 0xe6235(%rip), %rdx # 0x169d08
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x148e0
testq %rax, %rax
je 0x83b2e
movq %rax, %rbx
movq (%rax), %rax
mov... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.cpp |
embree::SceneGraph::resize_randomly(embree::RandomSampler&, embree::Ref<embree::SceneGraph::Node>, unsigned long) | void SceneGraph::HairSetNode::print(std::ostream& cout, int depth) {
cout << "HairSetNode @ " << this << " { closed = " << closed << " }" << std::endl;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq (%rsi), %r12
testq %r12, %r12
je 0x85720
movq %rdx, %rbx
movq %rdi, %r14
leaq 0xe44dd(%rip), %rsi # 0x169b00
leaq 0xe46de(%rip), %rdx # 0x169d08
movq %r12, %rdi
xorl %ecx, %ecx
callq 0x148e0
testq %rax, %rax
je 0x8568d
movq ... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.cpp |
embree::quad_index2(int, int, int, int, int) | std::pair<int,int> quad_index2(int p, int a0, int a1, int b0, int b1)
{
if (b0 == a0) return std::make_pair(p-1,b1);
else if (b0 == a1) return std::make_pair(p+0,b1);
else if (b1 == a0) return std::make_pair(p-1,b0);
else if (b1 == a1) return std::make_pair(p+0,b0);
else return std::make_pair... | movl %edi, %eax
cmpl %esi, %ecx
jne 0x85fc8
decl %eax
shlq $0x20, %r8
jmp 0x85fd2
cmpl %edx, %ecx
jne 0x85fd6
shlq $0x20, %r8
movl %eax, %eax
orq %r8, %rax
retq
cmpl %esi, %r8d
jne 0x85fe3
decl %eax
shlq $0x20, %rcx
jmp 0x85fee
cmpl %edx, %r8d
jne 0x85ff2
shlq $0x20, %rcx
movl %eax, %eax
orq %rcx, %rax
retq
movabsq $-0... | /embree[P]embree/tutorials/common/scenegraph/scenegraph.cpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.