name string | code string | asm string | file string |
|---|---|---|---|
ImStb::stb_text_locate_coord(ImGuiInputTextState*, float, float) | static int stb_text_locate_coord(STB_TEXTEDIT_STRING *str, float x, float y)
{
StbTexteditRow r;
int n = STB_TEXTEDIT_STRINGLEN(str);
float base_y = 0, prev_x;
int i=0, k;
r.x0 = r.x1 = 0;
r.ymin = r.ymax = 0;
r.num_chars = 0;
// search rows to find one that straddles 'y'
while (i < n) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movl 0x4(%rdi), %ebp
leaq 0x10(%rsp), %r15
andq $0x0, (%r15)
andq $0x0, 0xc(%r15)
andl $0x0, 0x14(%r15)
movss %xmm1, 0xc(%rsp)
xorl %ebx, %ebx
xorps %xmm2, %xmm2
movss %xmm0, 0x8(%rsp)
cmpl %ebp, %ebx
jge 0x6d49c
movss %x... | /ggerganov[P]kbd-audio/imgui/imstb_textedit.h |
ImGui::TabBarScrollClamp(ImGuiTabBar*, float) | float GetWidth() const { return Max.x - Min.x; } | movss 0x30(%rdi), %xmm1
movss 0x3c(%rdi), %xmm2
subss 0x28(%rdi), %xmm1
subss %xmm1, %xmm2
minss %xmm2, %xmm0
xorps %xmm1, %xmm1
cmpless %xmm0, %xmm1
andps %xmm1, %xmm0
retq
| /ggerganov[P]kbd-audio/imgui/imgui_internal.h |
char const* ImAtoi<long long>(char const*, long long*) | static const char* ImAtoi(const char* src, TYPE* output)
{
int negative = 0;
if (*src == '-') { negative = 1; src++; }
if (*src == '+') { src++; }
TYPE v = 0;
while (*src >= '0' && *src <= '9')
v = (v * 10) + (*src++ - '0');
*output = negative ? -v : v;
return src;
} | movb (%rdi), %al
xorl %edx, %edx
cmpb $0x2d, %al
sete %dl
xorl %ecx, %ecx
cmpb $0x2b, (%rdi,%rdx)
leaq (%rdi,%rdx), %rdx
sete %cl
addq %rdx, %rcx
xorl %edx, %edx
movb (%rcx), %dil
addb $-0x30, %dil
cmpb $0x9, %dil
ja 0x6d55b
imulq $0xa, %rdx, %r8
incq %rcx
movzbl %dil, %edx
addq %r8, %rdx
jmp 0x6d53e
movq %rdx, %rcx
ne... | /ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp |
bool ImGui::DragBehaviorT<int, int, float>(int, int*, float, int, int, char const*, float, int) | bool ImGui::DragBehaviorT(ImGuiDataType data_type, TYPE* v, float v_speed, const TYPE v_min, const TYPE v_max, const char* format, float power, ImGuiDragFlags flags)
{
ImGuiContext& g = *GImGui;
const ImGuiAxis axis = (flags & ImGuiDragFlags_Vertical) ? ImGuiAxis_Y : ImGuiAxis_X;
const bool is_decimal = (da... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %r9d, %r13d
movl %edi, %r9d
andl $-0x2, %r9d
cmpl $0x8, %r9d
sete %r10b
cmpl %edx, %ecx
setg %r15b
movss %xmm1, 0x14(%rsp)
ucomiss 0xaa46(%rip), %xmm1 # 0x78010
setp %r11b
setne %r12b
cmpl %edx, %ecx
jl 0x6d994
movl %ecx, %ebp
m... | /ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp |
bool ImGui::DragBehaviorT<unsigned int, int, float>(int, unsigned int*, float, unsigned int, unsigned int, char const*, float, int) | bool ImGui::DragBehaviorT(ImGuiDataType data_type, TYPE* v, float v_speed, const TYPE v_min, const TYPE v_max, const char* format, float power, ImGuiDragFlags flags)
{
ImGuiContext& g = *GImGui;
const ImGuiAxis axis = (flags & ImGuiDragFlags_Vertical) ? ImGuiAxis_Y : ImGuiAxis_X;
const bool is_decimal = (da... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r9d, %r13d
movl %edi, %r9d
andl $-0x2, %r9d
cmpl $0x8, %r9d
sete %r10b
cmpl %edx, %ecx
seta %r15b
movss %xmm1, 0x14(%rsp)
ucomiss 0xa631(%rip), %xmm1 # 0x78010
setp %r11b
setne %r12b
cmpl %edx, %ecx
jb 0x6ddac
movl %ecx, %ebp
m... | /ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp |
bool ImGui::SliderBehaviorT<long long, long long, double>(ImRect const&, unsigned int, int, long long*, long long, long long, char const*, float, int, ImRect*) | bool ImGui::SliderBehaviorT(const ImRect& bb, ImGuiID id, ImGuiDataType data_type, TYPE* v, const TYPE v_min, const TYPE v_max, const char* format, float power, ImGuiSliderFlags flags, ImRect* out_grab_bb)
{
ImGuiContext& g = *GImGui;
const ImGuiStyle& style = g.Style;
const ImGuiAxis axis = (flags & ImGui... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r9, %rbx
movq %r8, %r12
movq %rcx, 0x20(%rsp)
movl %edx, %r13d
movl %esi, 0x60(%rsp)
movq %rdi, %rbp
movl 0xd8(%rsp), %r14d
leaq 0x34856(%rip), %rax # 0xa4630
movq (%rax), %r15
andl $0x1, %r14d
movl %edx, 0x2c(%rsp)
andl $-0x2,... | /ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp |
bool ImGui::SliderBehaviorT<unsigned long long, long long, double>(ImRect const&, unsigned int, int, unsigned long long*, unsigned long long, unsigned long long, char const*, float, int, ImRect*) | bool ImGui::SliderBehaviorT(const ImRect& bb, ImGuiID id, ImGuiDataType data_type, TYPE* v, const TYPE v_min, const TYPE v_max, const char* format, float power, ImGuiSliderFlags flags, ImRect* out_grab_bb)
{
ImGuiContext& g = *GImGui;
const ImGuiStyle& style = g.Style;
const ImGuiAxis axis = (flags & ImGui... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r8, %r12
movq %rcx, 0x78(%rsp)
movl %esi, 0x60(%rsp)
movq %rdi, %r15
movq %r8, %rax
subq %r9, %rax
negq %rax
movq %r8, 0x20(%rsp)
movq %r9, 0x88(%rsp)
subq %r9, %r12
movl 0xe8(%rsp), %r13d
leaq 0x340f6(%rip), %rcx # 0xa4630
mov... | /ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp |
bool ImGui::SliderBehaviorT<double, double, double>(ImRect const&, unsigned int, int, double*, double, double, char const*, float, int, ImRect*) | bool ImGui::SliderBehaviorT(const ImRect& bb, ImGuiID id, ImGuiDataType data_type, TYPE* v, const TYPE v_min, const TYPE v_max, const char* format, float power, ImGuiSliderFlags flags, ImRect* out_grab_bb)
{
ImGuiContext& g = *GImGui;
const ImGuiStyle& style = g.Style;
const ImGuiAxis axis = (flags & ImGui... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movl %r9d, %r14d
movq %r8, 0x98(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm0, 0x20(%rsp)
movq %rcx, 0x60(%rsp)
movl %edx, %ebp
movl %esi, 0x4(%rsp)
movq %rdi, %r12
leaq 0x33136(%rip), %rax # 0xa4630
movq (%rax), %r13
andl $0x1, %r14d
... | /ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp |
unsigned int ImGui::RoundScalarWithFormatT<unsigned int, int>(char const*, int, unsigned int) | TYPE ImGui::RoundScalarWithFormatT(const char* format, ImGuiDataType data_type, TYPE v)
{
const char* fmt_start = ImParseFormatFindStart(format);
if (fmt_start[0] != '%' || fmt_start[1] == '%') // Don't apply if the value is not visible in the format string
return v;
char v_str[64];
ImFormatStri... | pushq %rbp
pushq %rbx
subq $0x58, %rsp
movl %edx, %ebx
movl %esi, %ebp
movl %edx, 0xc(%rsp)
callq 0x5f5a5
cmpb $0x25, (%rax)
jne 0x7251f
cmpb $0x25, 0x1(%rax)
je 0x7251f
leaq 0x10(%rsp), %rdi
pushq $0x40
popq %rsi
movq %rax, %rdx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x35877
leaq 0xf(%rsp), %rdi
cmpb $0x20, 0x1(%rdi)
l... | /ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp |
long long ImGui::RoundScalarWithFormatT<long long, long long>(char const*, int, long long) | TYPE ImGui::RoundScalarWithFormatT(const char* format, ImGuiDataType data_type, TYPE v)
{
const char* fmt_start = ImParseFormatFindStart(format);
if (fmt_start[0] != '%' || fmt_start[1] == '%') // Don't apply if the value is not visible in the format string
return v;
char v_str[64];
ImFormatStri... | pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movl %esi, %ebx
movq %rdx, 0x8(%rsp)
callq 0x5f5a5
cmpb $0x25, (%rax)
jne 0x72591
cmpb $0x25, 0x1(%rax)
je 0x72591
leaq 0x10(%rsp), %rdi
pushq $0x40
popq %rsi
movq %rax, %rdx
movq %r14, %rcx
xorl %eax, %eax
callq 0x35877
leaq 0xf(%rsp), %rdi
cmpb $0x20, 0x1(%rdi)
l... | /ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp |
unsigned long long ImGui::RoundScalarWithFormatT<unsigned long long, long long>(char const*, int, unsigned long long) | TYPE ImGui::RoundScalarWithFormatT(const char* format, ImGuiDataType data_type, TYPE v)
{
const char* fmt_start = ImParseFormatFindStart(format);
if (fmt_start[0] != '%' || fmt_start[1] == '%') // Don't apply if the value is not visible in the format string
return v;
char v_str[64];
ImFormatStri... | pushq %rbp
pushq %rbx
subq $0x58, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdx, 0x8(%rsp)
callq 0x5f5a5
cmpb $0x25, (%rax)
jne 0x7261e
cmpb $0x25, 0x1(%rax)
je 0x7261e
leaq 0x10(%rsp), %rdi
pushq $0x40
popq %rsi
movq %rax, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x35877
leaq 0xf(%rsp), %rdi
cmpb $0x20, 0x1(%rdi)
l... | /ggerganov[P]kbd-audio/imgui/imgui_widgets.cpp |
testing::internal::PrintOnOneLine(char const*, int) | static void PrintOnOneLine(const char* str, int max_length) {
if (str != NULL) {
for (int i = 0; *str != '\0'; ++str) {
if (i >= max_length) {
printf("...");
break;
}
if (*str == '\n') {
printf("\\n");
i += 2;
} else {
printf("%c", *str);
++i... | pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x37b6f
movq %rdi, %rbx
movb (%rdi), %al
testb %al, %al
je 0x37b6f
incq %rbx
leaq 0x161ea(%rip), %r14 # 0x4dd22
xorl %ebp, %ebp
cmpl $0xfa, %ebp
jae 0x37b74
cmpb $0xa, %al
jne 0x37b57
movq %r14, %rdi
xorl %eax, %eax
callq 0x20080
movl $0x2, %eax
jmp 0x37b64
movsb... | /gregorburger[P]variant/google-test/src/gtest.cc |
iutest::AssertionResult iutest::internal::backward::NeHelper<false>::Compare<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char [5]>(char const*, char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const (&) [5]) | static AssertionResult Compare(const char* expr1, const char* expr2, const T1& val1, const T2& val2)
{
return CmpHelperNE(expr1, expr2, val1, val2);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %rcx, %rdi
movq %r8, %rsi
callq 0x840e0
testl %eax, %eax
je 0xa4b7f
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movb $0x1, 0x20(%rbx)
movq %rb... | /srz-zumix[P]iutest/samples/../include/internal/../iutest_assertion.hpp |
iutest::AssertionResult iutest::AssertPred1Helper<bool (*)(int), int>(char const*, char const*, bool (*)(int), int) | AssertionResult AssertPred1Helper(const char* pred_str, const char* expr1
, PRED pred, T1 val1)
{
if IUTEST_COND_LIKELY( (*pred)(val1) )
{
return AssertionSuccess();
}
return AssertionFailure() << "error: " << pred_str << "(" << expr1 << ") evaluates to false, where "
<< "\n" << expr... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movl %r8d, 0x4(%rsp)
movl %r8d, %edi
callq *%rcx
testb %al, %al
je 0xa4d41
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movb $0x1, 0x20(%rbx)
movq %rbx, %rax
addq $0x40, %rs... | /srz-zumix[P]iutest/samples/../include/internal/../iutest_pred.hpp |
iutest::detail::TestInstance<iu_DISABLED_TestFailure_x_iutest_x_GE_Test>::TestInstance(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, void*, void (*)(), void (*)()) | TestInstance(const ::std::string& testsuite, const char* name, TestTypeId id
, SetUpMethod setup, TearDownMethod teardown)
: m_mediator(AddTestSuite(testsuite, id, setup, teardown))
, m_info(&m_mediator, name, &m_factory)
{
UnitTest::instance().AddTestInfo(m_mediator.ptr(), &m_info);... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
callq 0x8ed8e
movq %rax, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0xb66e4
movq %rax, 0x8(%rbx)
leaq 0x8ddf0(%r... | /srz-zumix[P]iutest/samples/../include/iutest_core.hpp |
iutest::detail::TestInstance<iu_DISABLED_TestFailure_x_iutest_x_TRUE_Test>::TestInstance(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, void*, void (*)(), void (*)()) | TestInstance(const ::std::string& testsuite, const char* name, TestTypeId id
, SetUpMethod setup, TearDownMethod teardown)
: m_mediator(AddTestSuite(testsuite, id, setup, teardown))
, m_info(&m_mediator, name, &m_factory)
{
UnitTest::instance().AddTestInfo(m_mediator.ptr(), &m_info);... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
callq 0x8ed8e
movq %rax, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0xb66e4
movq %rax, 0x8(%rbx)
leaq 0x8dc92(%r... | /srz-zumix[P]iutest/samples/../include/iutest_core.hpp |
iutest::detail::TestInstance<iu_DISABLED_TestFailure_x_iutest_x_NoFailure_Test>::TestInstance(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, void*, void (*)(), void (*)()) | TestInstance(const ::std::string& testsuite, const char* name, TestTypeId id
, SetUpMethod setup, TearDownMethod teardown)
: m_mediator(AddTestSuite(testsuite, id, setup, teardown))
, m_info(&m_mediator, name, &m_factory)
{
UnitTest::instance().AddTestInfo(m_mediator.ptr(), &m_info);... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
callq 0x8ed8e
movq %rax, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0xb66e4
movq %rax, 0x8(%rbx)
leaq 0x8d878(%r... | /srz-zumix[P]iutest/samples/../include/iutest_core.hpp |
iutest::detail::TestInstance<iu_DISABLED_TestFailure_x_iutest_x_Mix_Test>::TestInstance(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, void*, void (*)(), void (*)()) | TestInstance(const ::std::string& testsuite, const char* name, TestTypeId id
, SetUpMethod setup, TearDownMethod teardown)
: m_mediator(AddTestSuite(testsuite, id, setup, teardown))
, m_info(&m_mediator, name, &m_factory)
{
UnitTest::instance().AddTestInfo(m_mediator.ptr(), &m_info);... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
callq 0x8ed8e
movq %rax, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0xb66e4
movq %rax, 0x8(%rbx)
leaq 0x8d5bc(%r... | /srz-zumix[P]iutest/samples/../include/iutest_core.hpp |
iutest::AssertionResult& iutest::AssertionResult::operator<<<char [12]>(char const (&) [12]) | AssertionResult& operator << (const T& value)
{
Message msg;
msg << value;
m_message += msg.GetString();
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x95916
movq %r15, %rdi
movq %r14, %rsi
callq 0xa7598
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x84690
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rd... | /srz-zumix[P]iutest/samples/../include/internal/../iutest_assertion.hpp |
iutest::AssertionResult& iutest::AssertionResult::operator<<<char const*>(char const* const&) | AssertionResult& operator << (const T& value)
{
Message msg;
msg << value;
m_message += msg.GetString();
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x95916
movq %r15, %rdi
movq %r14, %rsi
callq 0x99820
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x84690
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rd... | /srz-zumix[P]iutest/samples/../include/internal/../iutest_assertion.hpp |
iutest::AssertionResult& iutest::AssertionResult::operator<<<char [2]>(char const (&) [2]) | AssertionResult& operator << (const T& value)
{
Message msg;
msg << value;
m_message += msg.GetString();
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x95916
movq %r15, %rdi
movq %r14, %rsi
callq 0xa7e4a
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x84690
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rd... | /srz-zumix[P]iutest/samples/../include/internal/../iutest_assertion.hpp |
iutest::AssertionResult& iutest::AssertionResult::operator<<<unsigned long>(unsigned long const&) | AssertionResult& operator << (const T& value)
{
Message msg;
msg << value;
m_message += msg.GetString();
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x95916
movq %r15, %rdi
movq %r14, %rsi
callq 0x99b5a
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x84690
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rd... | /srz-zumix[P]iutest/samples/../include/internal/../iutest_assertion.hpp |
iutest::detail::iuStreamMessage& iutest::detail::iuStreamMessage::operator<<<char, 18ul>(char const (&) [18ul]) | iuStreamMessage& operator << (const T(&value)[SIZE])
{
m_stream << PrintToString(value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0xa7d66
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x844f0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa7d33
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84420... | /srz-zumix[P]iutest/samples/../include/internal/../internal/iutest_message.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> iutest::PrintToString<char [18]>(char const (&) [18]) | inline ::std::string PrintToString(const T& v)
{
iu_global_format_stringstream strm;
detail::UniversalTersePrint(v, &strm);
return strm.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x95916
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq %r14, %rdi
callq 0x841a0
leaq (%rax,%r14), %rdx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x90516
leaq 0x38(%rsp), %rsi
leaq ... | /srz-zumix[P]iutest/samples/../include/internal/../internal/../iutest_printers.hpp |
iutest::detail::iuStreamMessage& iutest::detail::iuStreamMessage::operator<<<char, 2ul>(char const (&) [2ul]) | iuStreamMessage& operator << (const T(&value)[SIZE])
{
m_stream << PrintToString(value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0xa7ec2
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x844f0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa7e8f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84420... | /srz-zumix[P]iutest/samples/../include/internal/../internal/iutest_message.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> iutest::PrintToString<char [2]>(char const (&) [2]) | inline ::std::string PrintToString(const T& v)
{
iu_global_format_stringstream strm;
detail::UniversalTersePrint(v, &strm);
return strm.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x95916
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq %r14, %rdi
callq 0x841a0
leaq (%rax,%r14), %rdx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x90516
leaq 0x38(%rsp), %rsi
leaq ... | /srz-zumix[P]iutest/samples/../include/internal/../internal/../iutest_printers.hpp |
iutest::detail::iuStreamMessage& iutest::detail::iuStreamMessage::operator<<<char, 4ul>(char const (&) [4ul]) | iuStreamMessage& operator << (const T(&value)[SIZE])
{
m_stream << PrintToString(value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0xa801e
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x844f0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa7feb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84420... | /srz-zumix[P]iutest/samples/../include/internal/../internal/iutest_message.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> iutest::PrintToString<char [4]>(char const (&) [4]) | inline ::std::string PrintToString(const T& v)
{
iu_global_format_stringstream strm;
detail::UniversalTersePrint(v, &strm);
return strm.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x95916
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq %r14, %rdi
callq 0x841a0
leaq (%rax,%r14), %rdx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x90516
leaq 0x38(%rsp), %rsi
leaq ... | /srz-zumix[P]iutest/samples/../include/internal/../internal/../iutest_printers.hpp |
iutest::AssertionResult& iutest::AssertionResult::operator<<<wchar_t const*>(wchar_t const* const&) | AssertionResult& operator << (const T& value)
{
Message msg;
msg << value;
m_message += msg.GetString();
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x95916
movq %r15, %rdi
movq %r14, %rsi
callq 0xa81e2
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x84690
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rd... | /srz-zumix[P]iutest/samples/../include/internal/../iutest_assertion.hpp |
iutest::internal::EqFailure(char const*, char const*, 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&, bool) | inline AssertionResult EqFailure(const char* expected_expression, const char* actual_expression
, const ::std::string& expected, const ::std::string& actual, bool ignoring_case = false)
{
iu_global_format_stringstream strm;
strm << "error: Value of " << actual_expression
<< "\n Actual: " << actual
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movl %r9d, 0x4(%rsp)
movq %r8, %r13
movq %rcx, %r14
movq %rdx, %rbp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x50(%rsp), %rdi
callq 0x95916
leaq 0x60(%rsp), %r15
leaq 0x55c82(%rip), %rsi # 0xfe3c1
movl $0x10, %e... | /srz-zumix[P]iutest/samples/../include/internal/../iutest_assertion.hpp |
iutest::detail::ShowStringQuoted(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | inline ::std::string ShowStringQuoted(const ::std::string& str)
{
::std::string s = "\""; s += str; s += "\"";
return s;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0x58116(%rip), %rsi # 0x100a99
leaq 0x58110(%rip), %rdx # 0x100a9a
callq 0x90516
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x84110
leaq 0x580f4(%rip), %rsi # 0x100a99
movq %rbx, %... | /srz-zumix[P]iutest/samples/../include/internal/iutest_string.hpp |
iutest::AssertionResult iutest::internal::StrCaseNeHelper::Assertion<char const*, char const*>(char const*, char const*, char const* const&, char const* const&) | inline AssertionResult IUTEST_ATTRIBUTE_UNUSED_ Assertion(
const char* expr1, const char* expr2
, const T1& val1, const T2& val2)
{
if IUTEST_COND_LIKELY( Compare(val1, val2) )
{
return AssertionSuccess();
}
return AssertionFailure() << "error: Expected: " << expr1 << " != " << expr... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movq %r8, %r15
movq %rcx, %r14
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdi
movq (%r8), %rsi
testq %rdi, %rdi
setne %al
testq %rsi, %rsi
setne %cl
testb %cl, %al
jne 0xa8bcb
cmpq %rsi, %rdi
jmp 0xa8bd2
callq 0x84490
... | /srz-zumix[P]iutest/samples/../include/internal/../iutest_assertion.hpp |
iutest::AssertionResult iuutil::MatchesRegexEqHelper::Assertion<char const*, char const*>(char const*, char const*, char const* const&, char const* const&) | inline ::iutest::AssertionResult IUTEST_ATTRIBUTE_UNUSED_ Assertion(const char* regex_str, const char* actual_str
, const T1& regex, const T2& actual)
{
if( Compare(regex, actual) )
{
return ::iutest::AssertionSuccess();
}
::std::string expected_str = "Matches Regex (";
expected_str += r... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbx
movq (%rcx), %rsi
leaq 0x8(%rsp), %rdi
callq 0xa9292
movq (%r15), %rdi
testq %rdi, %rdi
je 0xa90d1
leaq 0x8(%rsp), %rsi
callq 0xb45a8
movl %eax, %ebp
jmp 0xa9... | /srz-zumix[P]iutest/samples/../include/util/iutest_util_assertion.hpp |
iutest::detail::iuRegex::~iuRegex() | iuRegex(const char* pattern) { Init(pattern); } | pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
leaq 0x30(%rbx), %rax
cmpq %rax, %rdi
je 0xa9288
movq (%rax), %rsi
incq %rsi
callq 0x84420
movq %rbx, %rdi
popq %rbx
jmp 0xa933c
nop
| /srz-zumix[P]iutest/samples/../include/internal/../internal/../internal/iutest_regex.hpp |
iutest::TestSuite* iutest::UnitTestImpl::AddTestSuite<iutest::TestSuite>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, void*, void (*)(), void (*)()) | TestSuite* AddTestSuite(const ::std::string& testsuite_name, TestTypeId id
, SetUpMethod setup, TearDownMethod teardown IUTEST_APPEND_EXPLICIT_TEMPLATE_TYPE_(T) )
{
TestSuite* p = FindTestSuite(testsuite_name, id);
if( p == NULL )
{
p = new T (testsuite_name, id, setup, t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq %rdx, (%rsi)
movq (%rbp), %rax
movq %rax, 0x8(%rsi)
leaq 0x20(%rdi), %r14
movq %r14, %rdi
callq 0xb685d
movq %rax, (%rsp)
testq %rax... | /srz-zumix[P]iutest/samples/../include/internal/iutest_core_impl.hpp |
iutest::AssertionResult& iutest::AssertionResult::operator<<<int>(int const&) | AssertionResult& operator << (const T& value)
{
Message msg;
msg << value;
m_message += msg.GetString();
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x95916
movq %r15, %rdi
movq %r14, %rsi
callq 0x99746
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x84690
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rd... | /srz-zumix[P]iutest/samples/../include/internal/../iutest_assertion.hpp |
iutest::detail::NewTestPartResultCheckHelper::Counter<iutest::detail::NewTestPartResultCheckHelper::CondEq<(iutest::TestPartResult::Type)2>, iutest::detail::DefaultGlobalTestPartResultReporter>::~Counter() | class Counter IUTEST_CXX_FINAL : public REPORTER
{
typedef REPORTER _Mybase;
public:
Counter() : m_count(0)
{
m_holder.Attach(this);
}
virtual void ReportTestPartResult(const TestPartResult& result) IUTEST_CXX_OVERRIDE
{
if( m_cond(result) ... | pushq %rbx
movq %rdi, %rbx
addq $0x8, %rdi
callq 0xa7930
movl $0x20, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x84420
nop
| /srz-zumix[P]iutest/samples/../include/internal/iutest_result_reporter.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> iutest::internal::FormatForComparisonFailureMessage<int, int>(int const&, int const&) | inline ::std::string FormatForComparisonFailureMessage(const T1& value, const T2& /*other_operand*/)
{
return PrintToString(value);
} | pushq %r14
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x95916
leaq 0x10(%rsp), %rdi
movl (%r14), %esi
callq 0x84720
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x84690
leaq 0x7bd14(%rip), %rsi # 0x133198
movq %rsp, %rdi
callq 0x84300
leaq 0x80(%rsp), ... | /srz-zumix[P]iutest/samples/../include/internal/../iutest_assertion.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> iutest::internal::FormatForComparisonFailureMessage<int*, int*>(int* const&, int* const&) | inline ::std::string FormatForComparisonFailureMessage(const T1& value, const T2& /*other_operand*/)
{
return PrintToString(value);
} | pushq %r14
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x95916
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0xb7656
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x84690
leaq 0x7bb8d(%rip), %rsi # 0x133198
movq %rsp, %rdi
callq 0x84300
leaq 0x80(%rsp), %r... | /srz-zumix[P]iutest/samples/../include/internal/../iutest_assertion.hpp |
bool iutest::internal::iuOperatorEQ<std::vector<int, std::allocator<int>>, std::vector<int, std::allocator<int>>>(std::vector<int, std::allocator<int>> const&, std::vector<int, std::allocator<int>> const&) | bool iuOperatorEQ(const T1& v1, const T2& v2)
{
IUTEST_PRAGMA_WARN_PUSH()
IUTEST_PRAGMA_WARN_DISABLE_SIGN_COMPARE()
IUTEST_PRAGMA_WARN_DISABLE_IMPLICIT_INT_FLOAT_CONVERSION()
return v1 == v2;
IUTEST_PRAGMA_WARN_POP()
} | movq %rsi, %rax
movq %rdi, %rcx
movq (%rdi), %rdi
movq 0x8(%rcx), %rcx
movq %rcx, %rdx
subq %rdi, %rdx
movq (%rsi), %rsi
movq 0x8(%rax), %rax
subq %rsi, %rax
cmpq %rax, %rdx
jne 0xb77bc
cmpq %rdi, %rcx
je 0xb77bf
pushq %rax
callq 0x84450
testl %eax, %eax
sete %al
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
movb $0x1, %al... | /srz-zumix[P]iutest/samples/../include/internal/../iutest_assertion.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> iutest::internal::FormatForComparisonFailureMessage<std::vector<int, std::allocator<int>>, std::vector<int, std::allocator<int>>>(std::vector<int, std::allocator<int>> const&, std::vector<int, std::allocator<int>> const&) | inline ::std::string FormatForComparisonFailureMessage(const T1& value, const T2& /*other_operand*/)
{
return PrintToString(value);
} | pushq %r14
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x95916
leaq 0x10(%rsp), %rdx
xorl %edi, %edi
movq %r14, %rsi
callq 0xb7847
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x84690
leaq 0x7b99b(%rip), %rsi # 0x133198
movq %rsp, %rdi
callq 0x84300
lea... | /srz-zumix[P]iutest/samples/../include/internal/../iutest_assertion.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> iutest::internal::FormatForComparisonFailureMessage<float, float>(float const&, float const&) | inline ::std::string FormatForComparisonFailureMessage(const T1& value, const T2& /*other_operand*/)
{
return PrintToString(value);
} | pushq %r14
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x95916
leaq 0x10(%rsp), %rdi
cvtss2sd (%r14), %xmm0
callq 0x846a0
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x84690
leaq 0x7b2d5(%rip), %rsi # 0x133198
movq %rsp, %rdi
callq 0x84300
leaq 0x80(%r... | /srz-zumix[P]iutest/samples/../include/internal/../iutest_assertion.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> iutest::internal::FormatForComparisonFailureMessage<double, int>(double const&, int const&) | inline ::std::string FormatForComparisonFailureMessage(const T1& value, const T2& /*other_operand*/)
{
return PrintToString(value);
} | pushq %r14
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x95916
leaq 0x10(%rsp), %rdi
movsd (%r14), %xmm0
callq 0x846a0
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x84690
leaq 0x7b250(%rip), %rsi # 0x133198
movq %rsp, %rdi
callq 0x84300
leaq 0x80(%rsp)... | /srz-zumix[P]iutest/samples/../include/internal/../iutest_assertion.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> iutest::internal::FormatForComparisonFailureMessage<int, double>(int const&, double const&) | inline ::std::string FormatForComparisonFailureMessage(const T1& value, const T2& /*other_operand*/)
{
return PrintToString(value);
} | pushq %r14
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x95916
leaq 0x10(%rsp), %rdi
movl (%r14), %esi
callq 0x84720
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x84690
leaq 0x7b1cd(%rip), %rsi # 0x133198
movq %rsp, %rdi
callq 0x84300
leaq 0x80(%rsp), ... | /srz-zumix[P]iutest/samples/../include/internal/../iutest_assertion.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> iutest::internal::FormatForComparisonFailureMessage<double, double>(double const&, double const&) | inline ::std::string FormatForComparisonFailureMessage(const T1& value, const T2& /*other_operand*/)
{
return PrintToString(value);
} | pushq %r14
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x95916
leaq 0x10(%rsp), %rdi
movsd (%r14), %xmm0
callq 0x846a0
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x84690
leaq 0x7ae94(%rip), %rsi # 0x133198
movq %rsp, %rdi
callq 0x84300
leaq 0x80(%rsp)... | /srz-zumix[P]iutest/samples/../include/internal/../iutest_assertion.hpp |
iutest::floating_point<float>::AlmostEquals(iutest::floating_point<float> const&) const | UInt exponent_bits() const { return m_v.uv & kExpMask; } | 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 0xb8387
movl (%rsi), %ecx
movl %ecx, %edx
notl %edx
testl $0x7f800000, %edx # imm = 0x7F800000
sete %dl
testl $0x7fffff, %ecx # ... | /srz-zumix[P]iutest/samples/../include/internal/../iutest_defs.hpp |
void iutest::detail::PrintToFloatingPoint<float>(iutest::floating_point<float> const&, std::ostream*) | inline void PrintToFloatingPoint(const floating_point<T>& f, iu_ostream* os)
{
iu_stringstream ss;
#if IUTEST_HAS_IOMANIP
ss << ::std::setprecision(::std::numeric_limits<T>::digits10 + 2);
#endif
UniversalPrint(f.raw(), &ss);
*os << ss.str() << "(0x" << ToHexString(f.bits()) << ")";
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1e0, %rsp # imm = 0x1E0
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x58(%rsp), %rdi
callq 0x842d0
leaq 0x68(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movq $0x8, 0x70(%rsp,%rax)
cvtss2sd (%r14), %xmm0
callq 0x846a0
leaq 0x70(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq... | /srz-zumix[P]iutest/samples/../include/internal/../internal/../iutest_printers.hpp |
iutest::floating_point<double>::AlmostEquals(iutest::floating_point<double> const&) const | bool AlmostEquals(const _Myt& rhs) const
{
if( is_nan() || rhs.is_nan() )
{
return false;
}
return NanSensitiveAlmostEquals(rhs);
} | movabsq $0x7ff0000000000000, %rdx # imm = 0x7FF0000000000000
movq (%rdi), %rax
movq %rax, %rcx
notq %rcx
testq %rdx, %rcx
sete %cl
movq %rax, %rdi
shlq $0xc, %rdi
setne %dil
testb %dil, %cl
jne 0xb865e
movabsq $0xfffffffffffff, %rdi # imm = 0xFFFFFFFFFFFFF
movq (%rsi), %rcx
movq %rcx, %rsi
notq %rsi
testq %rsi, %rdx
s... | /srz-zumix[P]iutest/samples/../include/internal/../iutest_defs.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> iutest::PrintToString<char [16]>(char const (&) [16]) | inline ::std::string PrintToString(const T& v)
{
iu_global_format_stringstream strm;
detail::UniversalTersePrint(v, &strm);
return strm.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x95916
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq %r14, %rdi
callq 0x841a0
leaq (%rax,%r14), %rdx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x90516
leaq 0x38(%rsp), %rsi
leaq ... | /srz-zumix[P]iutest/samples/../include/internal/../internal/../iutest_printers.hpp |
iutest::detail::iuStreamMessage& iutest::detail::iuStreamMessage::operator<<<char, 20ul>(char const (&) [20ul]) | iuStreamMessage& operator << (const T(&value)[SIZE])
{
m_stream << PrintToString(value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0xb9d12
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x844f0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb9cdf
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84420... | /srz-zumix[P]iutest/samples/../include/internal/../internal/iutest_message.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> iutest::PrintToString<char [20]>(char const (&) [20]) | inline ::std::string PrintToString(const T& v)
{
iu_global_format_stringstream strm;
detail::UniversalTersePrint(v, &strm);
return strm.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x95916
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq %r14, %rdi
callq 0x841a0
leaq (%rax,%r14), %rdx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x90516
leaq 0x38(%rsp), %rsi
leaq ... | /srz-zumix[P]iutest/samples/../include/internal/../internal/../iutest_printers.hpp |
iutest::detail::iuStreamMessage& iutest::detail::iuStreamMessage::operator<<<char, 8ul>(char const (&) [8ul]) | iuStreamMessage& operator << (const T(&value)[SIZE])
{
m_stream << PrintToString(value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0xb9e6e
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x844f0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb9e3b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x84420... | /srz-zumix[P]iutest/samples/../include/internal/../internal/iutest_message.hpp |
iutest::AssertionResult iutest::internal::CmpHelperEQ<int, char>(char const*, char const*, int const&, char const&) | IUTEST_COND_LIKELY( iuOperatorEQ(actual, expected) )
{
return AssertionSuccess();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movsbl (%r8), %eax
cmpl %eax, (%rcx)
jne 0xbe0a0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movb $0x1, 0x20(%rbx)
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq ... | /srz-zumix[P]iutest/samples/../include/internal/../iutest_assertion.hpp |
iu_EnabledTest_x_iutest_x_Enable_Test::Body() | IUTEST(DISABLED_MacroTest, Enable)
{
IUTEST_ASSERT_EQ(0, 0);
} | pushq %rbx
subq $0x1f0, %rsp # imm = 0x1F0
xorl %eax, %eax
leaq 0x68(%rsp), %rcx
movl %eax, (%rcx)
leaq 0x38(%rsp), %r8
movl %eax, (%r8)
leaq 0x43ef0(%rip), %rdx # 0x102700
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0xb7348
cmpb $0x0, 0x20(%rbx)
jne 0xbe8bd
leaq 0x68(%rsp), %rbx
movl $0x... | /srz-zumix[P]iutest/samples/disabledtest.cpp |
iu_DISABLED_Test_x_iutest_x_NotRun_Test::Body() | IUTEST(MacroTest, NotRun)
{
IUTEST_ASSERT_EQ(2, 3);
} | pushq %rbx
subq $0x1f0, %rsp # imm = 0x1F0
leaq 0x68(%rsp), %rcx
movl $0x2, (%rcx)
leaq 0x38(%rsp), %r8
movl $0x3, (%r8)
leaq 0x43736(%rip), %rsi # 0x10275a
leaq 0x43759(%rip), %rdx # 0x102784
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0xb7348
cmpb $0x0, 0x20(%rbx)
jne 0xbf0d5
leaq 0x68(%rsp), %rbx
... | /srz-zumix[P]iutest/samples/disabledtest.cpp |
iu_DISABLED_TestFixed_x_iutest_x_NotRun_Test::Body() | IUTEST_F(MacroTestF, NotRun)
{
IUTEST_ASSERT_EQ(2, 3);
} | pushq %rbx
subq $0x1f0, %rsp # imm = 0x1F0
leaq 0x68(%rsp), %rcx
movl $0x2, (%rcx)
leaq 0x38(%rsp), %r8
movl $0x3, (%r8)
leaq 0x435d2(%rip), %rsi # 0x10275a
leaq 0x435f5(%rip), %rdx # 0x102784
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0xb7348
cmpb $0x0, 0x20(%rbx)
jne 0xbf239
leaq 0x68(%rsp), %rbx
... | /srz-zumix[P]iutest/samples/disabledtest.cpp |
iutest::detail::TestInstance<iu_TestDisabled_x_iutest_x_Test2_Test>::TestInstance(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, void*, void (*)(), void (*)()) | TestInstance(const ::std::string& testsuite, const char* name, TestTypeId id
, SetUpMethod setup, TearDownMethod teardown)
: m_mediator(AddTestSuite(testsuite, id, setup, teardown))
, m_info(&m_mediator, name, &m_factory)
{
UnitTest::instance().AddTestInfo(m_mediator.ptr(), &m_info);... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
callq 0x8ed8e
movq %rax, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0xb66e4
movq %rax, 0x8(%rbx)
leaq 0x74232(%r... | /srz-zumix[P]iutest/samples/../include/iutest_core.hpp |
iutest::detail::TestInstance<iu_DISABLED_TestCaseDisabled_x_iutest_x_Test1_Test>::TestInstance(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, void*, void (*)(), void (*)()) | TestInstance(const ::std::string& testsuite, const char* name, TestTypeId id
, SetUpMethod setup, TearDownMethod teardown)
: m_mediator(AddTestSuite(testsuite, id, setup, teardown))
, m_info(&m_mediator, name, &m_factory)
{
UnitTest::instance().AddTestInfo(m_mediator.ptr(), &m_info);... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
callq 0x8ed8e
movq %rax, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0xb66e4
movq %rax, 0x8(%rbx)
leaq 0x740d4(%r... | /srz-zumix[P]iutest/samples/../include/iutest_core.hpp |
iutest::detail::TestInstance<iu_DISABLED_TestFailure_x_iutest_x_Exception_Test>::TestInstance(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, void*, void (*)(), void (*)()) | TestInstance(const ::std::string& testsuite, const char* name, TestTypeId id
, SetUpMethod setup, TearDownMethod teardown)
: m_mediator(AddTestSuite(testsuite, id, setup, teardown))
, m_info(&m_mediator, name, &m_factory)
{
UnitTest::instance().AddTestInfo(m_mediator.ptr(), &m_info);... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
callq 0x8ed8e
movq %rax, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0xb66e4
movq %rax, 0x8(%rbx)
leaq 0x70d48(%r... | /srz-zumix[P]iutest/samples/../include/iutest_core.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> iutest::PrintToString<char [91]>(char const (&) [91]) | inline ::std::string PrintToString(const T& v)
{
iu_global_format_stringstream strm;
detail::UniversalTersePrint(v, &strm);
return strm.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
callq 0x95916
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq %r14, %rdi
callq 0x841a0
leaq (%rax,%r14), %rdx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x90516
leaq 0x38(%rsp), %rsi
leaq ... | /srz-zumix[P]iutest/samples/../include/internal/../internal/../iutest_printers.hpp |
iutest::detail::TestInstance<iu_ParamMethodTestFixed_x_Test_EQ245>::TestInstance(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, char const*, void*, void (*)(), void (*)()) | TestInstance(const ::std::string& testsuite, const char* name, const char* value_params, TestTypeId id
, SetUpMethod setup, TearDownMethod teardown)
: m_mediator(AddTestSuite(testsuite, id, setup, teardown))
, m_info(&m_mediator, name, &m_factory)
{
m_info.set_value_param(value_para... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r15
movq %r8, %r12
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
callq 0x8ed8e
movq %rax, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq 0x60(%rsp), %r8
callq 0xb66e4
movq %rax, 0x8(%rbx)
leaq 0x59... | /srz-zumix[P]iutest/samples/../include/iutest_core.hpp |
iu_TestP_x_iutest_x_TestB_Test::iu_TestP_x_iutest_x_TestB_Test() | IUTEST_P(TestP, TestB)
{
IUTEST_ASSERT_EQ(b, GetParam());
++b;
} | pushq %rbx
movq %rdi, %rbx
leaq 0x5789b(%rip), %rax # 0x133e30
movq %rax, (%rdi)
addq $0x18, %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq $0x6c078965, 0x20(%rbx) # imm = 0x6C078965
movabsq $0x714acb3e2016830a, %rax # imm = 0x714ACB3E2016830A
movq %rax, 0x18(%rbx)
callq 0x8e632
movl $0x0, 0x28(%rbx)
movq %rb... | /srz-zumix[P]iutest/samples/parameterized.cpp |
iutest::detail::ParamTestInstance<iu_TestPI_x_iutest_x_TestA_Test>::MakeTestSuite(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, void*, void (*)(), void (*)()) const | virtual TestSuite* MakeTestSuite(const ::std::string& testsuite_name, TestTypeId id
, SetUpMethod setup, TearDownMethod teardown) const IUTEST_CXX_OVERRIDE
{
#if !defined(IUTEST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS)
return UnitTest::instance().AddTestSuite<TestSuite>(testsuite_name, id, setup, te... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
callq 0x8ed8e
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xb66e4
| /srz-zumix[P]iutest/samples/../include/iutest_param_tests.hpp |
iutest::detail::iuParamTestFactory<iu_TestPI_x_iutest_x_TestA_Test>::~iuParamTestFactory() | class iuParamTestFactory IUTEST_CXX_FINAL : public iuParamTestFactoryBase<typename Tester::ParamType>
{
typedef typename Tester::ParamType ParamType;
typedef iuParamTestFactoryBase<ParamType> _Mybase;
public:
iuParamTestFactory() IUTEST_CXX_DEFAULT_FUNCTION
explicit iuParamTestFactory(ParamType param) :... | movl $0x10, %esi
jmp 0x84420
| /srz-zumix[P]iutest/samples/../include/internal/../internal/iutest_factory.hpp |
iutest::WithParamInterface<bool>::MakeTestParamName[abi:cxx11](iutest::TestParamInfo<bool> const&) | static const ::std::string MakeTestParamName(const TestParamInfoType& info)
{
return detail::MakeIndexName(info.index);
} | pushq %r14
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rdi, %rbx
movq 0x8(%rsi), %r14
movq %rsp, %rdi
callq 0x95916
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x842b0
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x84690
leaq 0x563a6(%rip), %rsi # 0x133198
movq %rsp, %rdi
callq 0x84300
leaq 0x80(%rsp... | /srz-zumix[P]iutest/samples/../include/internal/../iutest_body.hpp |
iutest::WithParamInterface<iutest::any>::MakeTestParamName[abi:cxx11](iutest::TestParamInfo<iutest::any> const&) | static const ::std::string MakeTestParamName(const TestParamInfoType& info)
{
return detail::MakeIndexName(info.index);
} | pushq %r14
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rdi, %rbx
movq 0x8(%rsi), %r14
movq %rsp, %rdi
callq 0x95916
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x842b0
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x84690
leaq 0x53d28(%rip), %rsi # 0x133198
movq %rsp, %rdi
callq 0x84300
leaq 0x80(%rsp... | /srz-zumix[P]iutest/samples/../include/internal/../iutest_body.hpp |
iutest::detail::iuCsvFileParamsGenerator<int>::iuCsvFileParamsGenerator(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char) | explicit iuCsvFileParamsGenerator(const ::std::string& path, char delimiter = ',')
: iuValuesInParamsGenerator<T>(ReadParams(path, delimiter))
{
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edx, %ecx
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x577b8(%rip), %r15 # 0x1385e8
movq %r15, (%rdi)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xe0ea8
leaq 0x561ce(%rip), %rax # 0x137018
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
movq %r14, %rsi
ca... | /srz-zumix[P]iutest/samples/../include/internal/iutest_genparams_from_file.hpp |
iutest::detail::iuCsvFileParamsGenerator<int>::ReadParams(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char) | params_t ReadParams(const ::std::string& path, char delimiter = ',')
{
params_t params;
IFile* fp = detail::IFileSystem::New();
if( (fp != NULL) && fp->Open(path.c_str(), IFile::OpenRead) )
{
const ::std::string dataset = fp->ReadAll();
::std::string::size_typ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp # imm = 0x1C8
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, (%rsp)
movq $0x0, 0x10(%rdi)
movq 0x5ad66(%rip), %rdi # 0x13bc40
testq %rdi, %rdi
je 0xe0eea
movq (%rdi), %r... | /srz-zumix[P]iutest/samples/../include/internal/iutest_genparams_from_file.hpp |
iutest::detail::iuCsvFileParamsGenerator<int>::AppendParams(std::vector<int, std::allocator<int>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void AppendParams(params_t& params, const ::std::string& data)
{
if( StringIsBlank(data) )
{
return;
}
T param;
if( !StringToValue(data, param) )
{
return;
}
params.push_back(param);
} | pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq 0x8(%rdx), %rcx
testq %rcx, %rcx
sete %al
je 0xe1256
movq (%rdx), %rsi
addq %rsi, %rcx
movabsq $0x100002600, %rdi # imm = 0x100002600
movzbl (%rsi), %r8d
cmpq $0x20, %r8
ja 0xe123f
btq %r8, %rdi
jae 0xe123f
incq %rsi
cmpl $0x20, %r8d
ja 0xe1256
movl %r8d, %r8d
btq %... | /srz-zumix[P]iutest/samples/../include/internal/iutest_genparams_from_file.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> iutest::internal::FormatForComparisonFailureMessage<char, char>(char const&, char const&) | inline ::std::string FormatForComparisonFailureMessage(const T1& value, const T2& /*other_operand*/)
{
return PrintToString(value);
} | pushq %r14
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %rdi
callq 0x95916
leaq 0x10(%rsp), %rsi
movsbl (%r14), %edi
callq 0xbe164
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x84690
leaq 0x4f01e(%rip), %rsi # 0x133198
movq %rsp, %rdi
callq 0x84300
leaq 0x80(%rsp)... | /srz-zumix[P]iutest/samples/../include/internal/../iutest_assertion.hpp |
iutest::detail::TypeParamTestInstance<iu_TypedPrintToTest_x_iutest_x_Print_Test, iutest::detail::VariadicTypeList<char, unsigned char, short, unsigned short, int, unsigned int, long, unsigned long, int*>>::EachTest<iutest::detail::VariadicTypeList<int, unsigned int, long, unsigned long, int*>, void>::AddTestSuite(char ... | static TestSuite* AddTestSuite(const char* testsuite, size_t index, const char* file, int line)
{
#if !defined(IUTEST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS)
return UnitTest::instance().AddTestSuite<_MyTestSuite>(
#else
return UnitTest::instance().AddTestSuite(
#endif
#if IUTEST_HAS_TYP... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x8ed8e
movq %rax, %r15
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xe1403
leaq 0x51d89(%rip), %rdx # 0x1401e8
movq %r15, %rdi
movq %r12, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xee... | /srz-zumix[P]iutest/samples/../include/iutest_typed_tests.hpp |
iutest::TestSuite* iutest::UnitTestImpl::AddTestSuite<iutest::TypedTestSuite<unsigned int>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, void*, void (*)(), void (*)()) | TestSuite* AddTestSuite(const ::std::string& testsuite_name, TestTypeId id
, SetUpMethod setup, TearDownMethod teardown IUTEST_APPEND_EXPLICIT_TEMPLATE_TYPE_(T) )
{
TestSuite* p = FindTestSuite(testsuite_name, id);
if( p == NULL )
{
p = new T (testsuite_name, id, setup, t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq %rdx, (%rsi)
movq (%rbp), %rax
movq %rax, 0x8(%rsi)
leaq 0x20(%rdi), %r14
movq %r14, %rdi
callq 0xb685d
movq %rax, (%rsp)
testq %rax... | /srz-zumix[P]iutest/samples/../include/internal/iutest_core_impl.hpp |
iutest::detail::GetTypeNameProxy<unsigned int>::GetTypeName[abi:cxx11]() | static ::std::string GetTypeName() { return detail::GetTypeName<T>(); } | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x4bf9c(%rip), %rax # 0x13afa0
movq 0x8(%rax), %rax
xorl %r14d, %r14d
cmpb $0x2a, (%rax)
sete %r14b
addq %rax, %r14
leaq 0x4(%rsp), %r15
movl $0x1, (%r15)
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r15, %rcx
callq 0x84380
movq %r... | /srz-zumix[P]iutest/samples/../include/internal/iutest_internal_defs.hpp |
iutest::TypedTestSuite<unsigned int>::~TypedTestSuite() | class TypedTestSuite IUTEST_CXX_FINAL : public TestSuite
{
public:
typedef T TypeParam; //!< 型
protected:
/**
* @brief コンストラクタ
* @param [in] testsuite_name = TestSuite 名
* @param [in] id = TestSuite ID
* @param [in] setup = テスト事前実行関数
* @param [in] teard... | pushq %rbx
movq %rdi, %rbx
movq 0xb0(%rdi), %rdi
leaq 0xc0(%rbx), %rax
cmpq %rax, %rdi
je 0xef084
movq (%rax), %rsi
incq %rsi
callq 0x84420
movq %rbx, %rdi
popq %rbx
jmp 0xb68b4
nop
| /srz-zumix[P]iutest/samples/../include/internal/../iutest_suite.hpp |
iutest::detail::TypeParamTestInstance<iu_TypedPrintToTest_x_iutest_x_Print_Test, iutest::detail::VariadicTypeList<char, unsigned char, short, unsigned short, int, unsigned int, long, unsigned long, int*>>::EachTest<iutest::detail::VariadicTypeList<short, unsigned short, int, unsigned int, long, unsigned long, int*>, vo... | void AddTest()
{
// 順番通りになるように前から登録
UnitTest::instance().AddTestInfo(m_mediator.ptr(), &m_info);
m_next.AddTest();
} | pushq %rbx
movq %rdi, %rbx
callq 0x8ed8e
movq 0x8(%rbx), %rdi
leaq 0x10(%rbx), %rsi
incl (%rax)
callq 0xb6bac
addq $0xd0, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0xf15ae
| /srz-zumix[P]iutest/samples/../include/iutest_typed_tests.hpp |
iutest::detail::TypeParamTestInstance<iu_TypedTest_x_iutest_x_Equal_Test, iutest::detail::VariadicTypeList<int, long, short>>::EachTest<iutest::detail::VariadicTypeList<long, short>, void>::EachTest(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char const*, unsigned long, char c... | EachTest(const ::std::string& testsuite, const char* name, size_t index, const char* file, int line)
: m_mediator(AddTestSuite(testsuite, index, file, line))
, m_info(&m_mediator, name, &m_factory)
, m_next(testsuite, name, index+1, file, line)
{
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, %ebx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movq (%rsi), %rdi
movq %rcx, %rsi
movq %r8, %rdx
movl %r9d, %ecx
callq 0xf6d18
movq %rax, 0x8(%rbp)
leaq 0x3d5b4(%rip), %rax # 0x133ea8
mo... | /srz-zumix[P]iutest/samples/../include/iutest_typed_tests.hpp |
dasm_getpclabel | int dasm_getpclabel(Dst_DECL, unsigned int pc)
{
dasm_State *D = Dst_REF;
if (pc*sizeof(int) < D->pcsize) {
int pos = D->pclabels[pc];
if (pos < 0) return *DASM_POS2PTR(D, -pos);
if (pos > 0) return -1; /* Undefined. */
}
return -2; /* Unused or out of range. */
} | movq (%rdi), %rax
movl %esi, %ecx
leaq (,%rcx,4), %rdx
cmpq 0x28(%rax), %rdx
jae 0x7892
movq 0x20(%rax), %rdx
movl (%rdx,%rcx,4), %ecx
testl %ecx, %ecx
js 0x7879
sete %cl
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
jmp 0x788e
negl %ecx
movl %ecx, %edx
shrl $0x18, %edx
leaq (%rdx,%rdx,4), %rdx
movq 0x50(%rax,%rdx,8)... | /9chu[P]LuaJIT-cmake/build_O1/../dynasm/dasm_x86.h |
emit_asm | void emit_asm(BuildCtx *ctx)
{
int i, rel;
fprintf(ctx->fp, "\t.file \"buildvm_%s.dasc\"\n", ctx->dasm_arch);
#if LJ_ARCH_PPC_ELFV2
fprintf(ctx->fp, "\t.abiversion 2\n");
#endif
fprintf(ctx->fp, "\t.text\n");
emit_asm_align(ctx, 4);
#if LJ_TARGET_PS3
emit_asm_label(ctx, ctx->beginsym, ctx->codesz, 0);
#el... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq 0x90(%rbx), %rdx
leaq 0x8f85(%rip), %rsi # 0x13964
xorl %eax, %eax
callq 0x6120
movq 0x10(%rbx), %rcx
leaq 0x8f8d(%rip), %rdi # 0x1397e
movl $0x7, %esi
movl $0x1, %edx
callq 0x61c0
mov... | /9chu[P]LuaJIT-cmake/src/host/buildvm_asm.c |
emit_asm_label | static void emit_asm_label(BuildCtx *ctx, const char *name, int size, int isfunc)
{
switch (ctx->mode) {
case BUILD_elfasm:
#if LJ_TARGET_PS3
if (!strncmp(name, "lj_vm_", 6) &&
strcmp(name, ctx->beginsym) &&
!strstr(name, "hook")) {
fprintf(ctx->fp,
"\n\t.globl %s\n"
"\t.section \".opd\",\"aw\"\n"
"%... | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %eax
cmpl $0x2, %eax
je 0xadb1
movl %ecx, %ebp
cmpl $0x1, %eax
je 0xad6a
testl %eax, %eax
jne 0xad65
movl %edx, %r10d
movq 0x10(%r14), %rdi
testl %ebp, %ebp
leaq 0x8cfd(%rip), %rax # 0x13a34
leaq 0x89a7(%rip), %r9 # 0x136e5
cmov... | /9chu[P]LuaJIT-cmake/src/host/buildvm_asm.c |
emit_asm_bytes | static void emit_asm_bytes(BuildCtx *ctx, uint8_t *p, int n)
{
int i;
for (i = 0; i < n; i++) {
if ((i & 15) == 0)
fprintf(ctx->fp, "\t.byte %d", p[i]);
else
fprintf(ctx->fp, ",%d", p[i]);
if ((i & 15) == 15) putc('\n', ctx->fp);
}
if ((n & 15) != 0) putc('\n', ctx->fp);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %edx, 0x4(%rsp)
testl %edx, %edx
jle 0xae38
movq %rsi, %r14
movl 0x4(%rsp), %r15d
leaq 0x8d34(%rip), %r13 # 0x13b29
xorl %ebp, %ebp
movl %ebp, %r12d
andl $0xf, %r12d
movzbl (%r14,%rbp), %edx
movq %r13, %rsi
leaq 0x8d1... | /9chu[P]LuaJIT-cmake/src/host/buildvm_asm.c |
libdef_module | static void libdef_module(BuildCtx *ctx, char *p, int arg)
{
UNUSED(arg);
if (ctx->mode == BUILD_libdef) {
libdef_endmodule(ctx);
optr = obuf;
*optr++ = (uint8_t)ffid;
*optr++ = (uint8_t)ffasmfunc;
*optr++ = 0; /* Hash table size. */
modstate = 1;
fprintf(ctx->fp, "#ifdef %sMO... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpl $0x7, 0x8(%rdi)
jne 0xbb43
movq %rdi, %r14
callq 0xb989
leaq 0xd79e(%rip), %rax # 0x19250
movq %rax, 0xf797(%rip) # 0x1b250
movb 0xd771(%rip), %al # 0x19230
movb %al, 0xd78b(%rip) # 0x19250
movb 0xd76d(%rip), %al # 0x19238
movb %al, 0xd78... | /9chu[P]LuaJIT-cmake/src/host/buildvm_lib.c |
libdef_rec | static void libdef_rec(BuildCtx *ctx, char *p, int arg)
{
UNUSED(arg);
if (ctx->mode == BUILD_recdef) {
char *q;
uint32_t n;
for (; recffid+1 < ffid; recffid++)
fprintf(ctx->fp, ",\n0");
recffid = ffid;
if (*p == '.') p = funcname;
q = strchr(p, ' ');
if (q) *q++ = '\0';... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x8, 0x8(%rdi)
jne 0xbfb9
movq %rsi, %r14
movq %rdi, %rbx
movl 0xd2f2(%rip), %ecx # 0x19234
incl %ecx
movl 0xd2e6(%rip), %eax # 0x19230
cmpl %eax, %ecx
jge 0xbf87
leaq 0x827c(%rip), %r15 # 0x141d1
movq 0x10(%rbx), %rcx
mov... | /9chu[P]LuaJIT-cmake/src/host/buildvm_lib.c |
libdef_set | static void libdef_set(BuildCtx *ctx, char *p, int arg)
{
UNUSED(arg);
if (ctx->mode == BUILD_libdef) {
if (p[0] == '!' && p[1] == '\0') p[0] = '\0'; /* Set env. */
libdef_name(p, LIBINIT_STRING);
*optr++ = LIBINIT_SET;
obuf[2]++; /* Bump hash table size. */
}
} | cmpl $0x7, 0x8(%rdi)
jne 0xc240
cmpb $0x21, (%rsi)
jne 0xc213
cmpb $0x0, 0x1(%rsi)
jne 0xc213
movb $0x0, (%rsi)
pushq %rax
movq %rsi, %rdi
movl $0xc0, %esi
callq 0xc248
movq 0xf028(%rip), %rax # 0x1b250
leaq 0x1(%rax), %rcx
movq %rcx, 0xf01d(%rip) # 0x1b250
movb $-0x6, (%rax)
incb 0xd016(%rip) # 0x... | /9chu[P]LuaJIT-cmake/src/host/buildvm_lib.c |
nexttoken | static uint32_t nexttoken(char **pp, int allowlit, int allowany)
{
char *p = *pp;
if (p) {
uint32_t i;
char *q = strchr(p, ' ');
if (q) *q++ = '\0';
*pp = q;
if (allowlit && !strncmp(p, "IRFPM_", 6)) {
for (i = 0; irfpm_names[i]; i++)
if (!strcmp(irfpm_names[i], p+6))
return i;
} e... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq (%rdi), %rbx
testq %rbx, %rbx
je 0xc6e7
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %r15
movq %rbx, %rdi
movl $0x20, %esi
callq 0x60b0
testq %rax, %rax
je 0xc6fc
movq %rax, %rcx
incq %rcx
movb $0x0, (%rax)
jmp 0xc6fe
xorl %r14d, %r1... | /9chu[P]LuaJIT-cmake/src/host/buildvm_fold.c |
tryhash | static int tryhash(uint32_t *htab, uint32_t sz, uint32_t r, int dorol)
{
uint32_t i;
if (dorol && ((r & 31) == 0 || (r>>5) == 0))
return 0; /* Avoid zero rotates. */
memset(htab, 0xff, (sz+1)*sizeof(uint32_t));
for (i = 0; i < nkeys; i++) {
uint32_t key = foldkeys[i];
uint32_t k = key & 0xffffff;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebx
movl %edx, 0xc(%rsp)
movl %esi, %r14d
movq %rdi, %r15
testl %ecx, %ecx
je 0xc9cc
movl 0xc(%rsp), %ecx
testb $0x1f, %cl
sete %al
cmpl $0x20, %ecx
setb %dl
xorl %ecx, %ecx
orb %al, %dl
jne 0xcad2
movl %r14d, %eax
leaq 0x4(,... | /9chu[P]LuaJIT-cmake/src/host/buildvm_fold.c |
CGL::SceneObjects::SphereObject::get_primitives() const | std::vector<Primitive*> SphereObject::get_primitives() const {
std::vector<Primitive*> primitives;
primitives.push_back(new Sphere(this,o,r));
return primitives;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
vxorpd %xmm0, %xmm0, %xmm0
vmovupd %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x40, %edi
callq 0xe8f0
vmovsd 0x20(%r14), %xmm0
vmovsd 0x30(%r14), %xmm1
movq 0x19aae3(%rip), %rcx # 0x1aaf70
addq $0x10, %rcx
movq %rcx, (%rax)
movq %r14, 0x8(%rax)
vmovaps ... | /aatifjiwani[P]lens-flare/src/scene/object.cpp |
CGL::Collada::ColladaParser::uri_load(tinyxml2::XMLElement*) | void ColladaParser::uri_load( XMLElement* xml ) {
if (xml->Attribute("id")) {
string id = xml->Attribute("id");
sources[id] = xml;
}
XMLElement* child = xml->FirstChildElement();
while (child) {
uri_load(child);
child = child->NextSiblingElement();
}
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0xdefe0(%rip), %rsi # 0xefc51
xorl %edx, %edx
callq 0xa559a
testq %rax, %rax
je 0x10cc8
leaq 0xdefcd(%rip), %rsi # 0xefc51
movq %rbx, %rdi
xorl %edx, %edx
callq 0xa559a
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0xe... | /aatifjiwani[P]lens-flare/src/scene/collada/collada.cpp |
CGL::Collada::ColladaParser::get_element(tinyxml2::XMLElement*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | XMLElement* ColladaParser::get_element( XMLElement* xml, string query ) {
stringstream ss (query);
// find xml element
XMLElement* e = xml; string token;
while( e && getline(ss, token, '/') ) {
e = e->FirstChildElement( token.c_str() );
}
// handle indirection
if (e) {
const char* url = e->Attr... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
movq %rdi, %rbx
leaq 0x60(%rsp), %r14
movq %r14, %rdi
movl $0x18, %edx
callq 0xef30
leaq 0x50(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq 0x40(%rsp), %r15
testq %rbx, %rbx
je 0x10dcf
movq %r14, %rd... | /aatifjiwani[P]lens-flare/src/scene/collada/collada.cpp |
CGL::Collada::ColladaParser::load(char const*, CGL::Collada::SceneInfo*) | int ColladaParser::load( const char* filename, SceneInfo* sceneInfo ) {
ifstream in (filename);
if (!in.is_open()) {
return -1;
} in.close();
XMLDocument doc;
doc.LoadFile(filename);
if (doc.Error()) {
stat("XML error: ");
doc.PrintError();
exit(EXIT_FAILURE);
}
// Check XML schema
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x5a8, %rsp # imm = 0x5A8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x3a0(%rsp), %rdi
movq %rbx, %rsi
movl $0x8, %edx
callq 0xf140
leaq 0x418(%rsp), %rdi
callq 0xe1c0
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
testb %al, %al
je 0x11555
leaq 0x3a0(%rsp), %rdi
... | /aatifjiwani[P]lens-flare/src/scene/collada/collada.cpp |
CGL::Collada::ColladaParser::parse_node(tinyxml2::XMLElement*) | void ColladaParser::parse_node( XMLElement* xml ) {
// create new node
Node node = Node();
// name & id
node.id = xml->Attribute( "id" );
node.name = xml->Attribute("name");
stat(" |- Node: " << node.name << " (id:" << node.id << ")");
// node transformation -
// combine in order of declaration if ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x588, %rsp # imm = 0x588
movq %rdi, %r12
leaq 0x330(%rsp), %rdi
callq 0x15eb8
leaq 0xde615(%rip), %rsi # 0xefc51
movq %r12, %rdi
xorl %edx, %edx
callq 0xa559a
movq %rax, %rbx
leaq 0x330(%rsp), %r14
movq 0x8(%r14), %r15
movq %rax, %r... | /aatifjiwani[P]lens-flare/src/scene/collada/collada.cpp |
CGL::Collada::ColladaParser::parse_light(tinyxml2::XMLElement*, CGL::Collada::LightInfo&) | void ColladaParser::parse_light( XMLElement* xml, LightInfo& light ) {
// name & id
light.id = xml->Attribute( "id" );
light.name = xml->Attribute("name");
light.type = Instance::LIGHT;
XMLElement* technique = NULL;
XMLElement* technique_common = get_technique_common(xml);
XMLElement* technique_CGL = ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3f8, %rsp # imm = 0x3F8
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xdd0e5(%rip), %rsi # 0xefc51
xorl %edx, %edx
callq 0xa559a
movq %rax, %r15
leaq 0x8(%rbx), %r12
movq 0x10(%rbx), %r13
movq %rax, %rdi
callq 0xe3c0
movq %r12, %rdi
xorl %... | /aatifjiwani[P]lens-flare/src/scene/collada/collada.cpp |
CGL::Collada::ColladaParser::parse_material(tinyxml2::XMLElement*, CGL::Collada::MaterialInfo&) | void ColladaParser::parse_material ( XMLElement* xml, MaterialInfo& material ) {
// name & id
material.id = xml->Attribute( "id" );
material.name = xml->Attribute("name");
material.type = Instance::MATERIAL;
// parse effect
XMLElement* e_effect = get_element(xml, "instance_effect");
if (e_effect) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x578, %rsp # imm = 0x578
movq %rsi, %r13
movq %rdi, %rbx
leaq 0xdb37d(%rip), %rsi # 0xefc51
xorl %edx, %edx
callq 0xa559a
movq %rax, %r14
leaq 0x8(%r13), %r15
movq 0x10(%r13), %r12
movq %rax, %rdi
callq 0xe3c0
movq %r15, %rdi
xorl %... | /aatifjiwani[P]lens-flare/src/scene/collada/collada.cpp |
CGL::Collada::operator<<(std::ostream&, CGL::Collada::LightInfo const&) | std::ostream& operator<<(std::ostream& os, const LightInfo& light) {
os << "LightInfo: " << light.name << " (id:" << light.id << ")";
os << " [";
switch (light.light_type) {
case LightType::NONE:
os << "type=none";
case LightType::AMBIENT:
os << " type=ambient"
<< " spe... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xcba15(%rip), %rsi # 0xe3400
movl $0xb, %edx
callq 0xea60
movq 0x28(%r14), %rsi
movq 0x30(%r14), %rdx
movq %rbx, %rdi
callq 0xea60
movq %rax, %r15
leaq 0xcb9fd(%rip), %rsi # 0xe340c
movl $0x5, %edx
movq %rax, %rdi
callq 0xea60
movq 0x8(%r14)... | /aatifjiwani[P]lens-flare/src/scene/collada/light_info.cpp |
CGL::Collada::operator<<(std::ostream&, CGL::Collada::SphereInfo const&) | std::ostream& operator<<( std::ostream& os, const SphereInfo& sphere ) {
return os << "Sphere: " << sphere.name << " (id:" << sphere.id << ") ["
<< " radius=" << sphere.radius << " ]";
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xcb7cf(%rip), %rsi # 0xe34c8
movl $0x8, %edx
callq 0xea60
movq 0x28(%rbx), %rsi
movq 0x30(%rbx), %rdx
movq %r14, %rdi
callq 0xea60
movq %rax, %r14
leaq 0xcb6ef(%rip), %rsi # 0xe340c
movl $0x5, %edx
movq %rax, %rdi
callq 0xea60
movq 0x8(%rbx)... | /aatifjiwani[P]lens-flare/src/scene/collada/sphere_info.cpp |
CGL::GLScene::Mesh::Mesh(CGL::Collada::PolymeshInfo&, CGL::Matrix4x4 const&) | Mesh::Mesh(Collada::PolymeshInfo& polyMesh, const Matrix4x4& transform) {
// Build halfedge mesh from polygon soup
vector< vector<size_t> > polygons;
for (const Collada::Polygon& p : polyMesh.polygons) {
polygons.push_back(p.vertex_indices);
}
vector<Vector3D> vertices = polyMesh.vertices; // DELIBERATE ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, 0x48(%rsp)
movq %rsi, %r12
movq %rdi, %r14
leaq 0x1910e1(%rip), %rax # 0x1a90a0
leaq 0x10(%rax), %rcx
movq %rcx, (%rdi)
movl $0xb8, %ecx
addq %rcx, %rax
movq %rax, 0x8(%rdi)
vxorps %xmm0, %xmm0, %xmm0
vmovaps %xmm0, 0x10(%r... | /aatifjiwani[P]lens-flare/src/scene/gl_scene/mesh.cpp |
CGL::GLScene::Mesh::render_in_opengl() const | void Mesh::render_in_opengl() const {
// TODO: fix drawing with BSDF
// DiffuseBSDF* diffuse = dynamic_cast<DiffuseBSDF*>(bsdf);
// if (diffuse) {
// glBindTexture(GL_TEXTURE_2D, 0);
// glMaterialfv(GL_FRONT, GL_DIFFUSE, diffuse->albedo.unsafe);
// }
// Enable lighting for faces
glEnable(GL_LIGHTI... | pushq %rbx
movq %rdi, %rbx
movl $0xb50, %edi # imm = 0xB50
callq 0xe810
movq %rbx, %rdi
callq 0x182e6
movl $0xb50, %edi # imm = 0xB50
callq 0xe220
movq %rbx, %rdi
callq 0x18400
leaq 0x40(%rbx), %rsi
movq %rbx, %rdi
callq 0x184ea
leaq 0x70(%rbx), %rsi
movq %rbx, %rdi
callq 0x184ea
movl $0xb50, %edi... | /aatifjiwani[P]lens-flare/src/scene/gl_scene/mesh.cpp |
CGL::GLScene::Mesh::draw_edges() const | void Mesh::draw_edges() const {
defaultStyle->style_edge();
for(EdgeCIter e = mesh.edgesBegin(); e != mesh.edgesEnd(); e++) {
DrawStyle *style = get_draw_style(elementAddress(e));
if (style != defaultStyle) {
style->style_edge();
}
glBegin(GL_LINES);
glVertex3dv(&e->halfedge()->vertex()->... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0xa0(%rdi), %rdi
callq 0x1a540
leaq 0xe8(%rbx), %r15
movq 0xe8(%rbx), %r12
cmpq %r15, %r12
je 0x184c6
movl $0xb0, %r13d
leaq 0x10(%r12), %rax
xorl %ecx, %ecx
cmpq %rax, 0x60(%rbx)
sete %cl
cmpq %rax, 0x90(%rbx)
leaq 0xa0(,%rcx,8), %rax
cmoveq %... | /aatifjiwani[P]lens-flare/src/scene/gl_scene/mesh.cpp |
CGL::GLScene::Mesh::triangle_selection_test_4d(CGL::Vector2D const&, CGL::Vector4D const&, CGL::Vector4D const&, CGL::Vector4D const&, CGL::Vector3D*) | double Mesh::triangle_selection_test_4d(const Vector2D& p, const Vector4D& A,
const Vector4D& B, const Vector4D& C,
Vector3D *baryPtr) {
Vector2D a2D(A.x, A.y);
Vector2D b2D(B.x, B.y);
Vector2D c2D(C.x, C.y);
float bU, bV;
if (tr... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %r15
movq %r8, %r14
movq %rcx, %rbx
movq %rdx, %r12
vmovaps (%rdx), %xmm0
leaq 0x30(%rsp), %rdx
vmovaps %xmm0, (%rdx)
vmovaps (%rcx), %xmm0
leaq 0x20(%rsp), %rcx
vmovaps %xmm0, (%rcx)
vmovaps (%r8), %xmm0
leaq 0x10(%rsp), %r8
vmovaps %xmm0, (%r8)
le... | /aatifjiwani[P]lens-flare/src/scene/gl_scene/mesh.cpp |
CGL::GLScene::DrawStyle::style_vertex() const | void style_vertex() const {
GLfloat temp[4];
temp[0] = vertexColor.r;
temp[1] = vertexColor.g;
temp[2] = vertexColor.b;
temp[3] = 1.f;
glColor4fv(temp);
glPointSize(vertexRadius);
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
vmovsd 0xc(%rdi), %xmm0
movq %rsp, %rdi
vmovsd %xmm0, (%rdi)
vmovss 0x14(%rbx), %xmm0
vmovss %xmm0, 0x8(%rdi)
movl $0x3f800000, 0xc(%rdi) # imm = 0x3F800000
callq 0xe330
vmovss 0x34(%rbx), %xmm0
callq 0xe0d0
addq $0x10, %rsp
popq %rbx
retq
| /aatifjiwani[P]lens-flare/src/scene/gl_scene/draw_style.h |
CGL::GLScene::Scene::get_bbox() | BBox Scene::get_bbox() {
BBox bbox;
for (SceneObject *obj : objects) {
bbox.expand(obj->get_bbox());
}
return bbox;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
vmovddup 0xc886a(%rip), %xmm0 # xmm0 = mem[0,0]
vmovaps %xmm0, (%rdi)
movabsq $-0x10000000000000, %rax # imm = 0xFFF0000000000000
movq %rax, 0x10(%rdi)
vmovddup 0xc8858(%rip), %xmm1 # xmm1 = mem[0,0]
vmovaps %xmm1, 0x20(%rdi)
movabsq $0x... | /aatifjiwani[P]lens-flare/src/scene/gl_scene/scene.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.