name string | code string | asm string | file string |
|---|---|---|---|
destroyContextEGL | static void destroyContextEGL(_GLFWwindow* window)
{
#if defined(_GLFW_X11)
// NOTE: Do not unload libGL.so.1 while the X11 display is still open,
// as it will make XCloseDisplay segfault
if (window->context.client != GLFW_OPENGL_API)
#endif // _GLFW_X11
{
if (window->context.egl.client)
... | pushq %rbx
movq %rdi, %rbx
cmpl $0x30001, 0x1f8(%rdi) # imm = 0x30001
je 0x2c345
movq 0x298(%rbx), %rdi
testq %rdi, %rdi
je 0x2c345
callq 0x143b0
movq $0x0, 0x298(%rbx)
movq 0x290(%rbx), %rsi
testq %rsi, %rsi
je 0x2c370
leaq 0x66168(%rip), %rax # 0x924c0
movq 0x20f88(%rax), %rdi
callq *0x20ff8(%rax)
movq $0x0, 0x... | /tuket[P]gltf_viewer/libs/glfw/src/egl_context.c |
glfwCreateContextOSMesa | GLFWbool _glfwCreateContextOSMesa(_GLFWwindow* window,
const _GLFWctxconfig* ctxconfig,
const _GLFWfbconfig* fbconfig)
{
OSMesaContext share = NULL;
const int accumBits = fbconfig->accumRedBits +
fbconfig->accumGreenBi... | pushq %rbp
pushq %r14
pushq %rbx
subq $0xa0, %rsp
cmpl $0x30002, (%rsi) # imm = 0x30002
jne 0x2c724
leaq 0x253b5(%rip), %rsi # 0x51acd
xorl %ebp, %ebp
movl $0x10006, %edi # imm = 0x10006
jmp 0x2c8e4
movq %rdi, %rbx
movl 0x1c(%rdx), %ecx
addl 0x18(%rdx), %ecx
addl 0x20(%rdx), %ecx
movq 0x28(%rsi), %r... | /tuket[P]gltf_viewer/libs/glfw/src/osmesa_context.c |
destroyContextOSMesa | static void destroyContextOSMesa(_GLFWwindow* window)
{
if (window->context.osmesa.handle)
{
OSMesaDestroyContext(window->context.osmesa.handle);
window->context.osmesa.handle = NULL;
}
if (window->context.osmesa.buffer)
{
free(window->context.osmesa.buffer);
window-... | pushq %rbx
movq %rdi, %rbx
movq 0x2a0(%rdi), %rdi
testq %rdi, %rdi
je 0x2ca13
leaq 0x65abe(%rip), %rax # 0x924c0
callq *0x21050(%rax)
movq $0x0, 0x2a0(%rbx)
movq 0x2b0(%rbx), %rdi
testq %rdi, %rdi
je 0x2ca2f
callq 0x14600
movq $0x0, 0x2a8(%rbx)
popq %rbx
retq
| /tuket[P]gltf_viewer/libs/glfw/src/osmesa_context.c |
glfwGetOSMesaColorBuffer | GLFWAPI int glfwGetOSMesaColorBuffer(GLFWwindow* handle, int* width,
int* height, int* format, void** buffer)
{
void* mesaBuffer;
GLint mesaWidth, mesaHeight, mesaFormat;
_GLFWwindow* window = (_GLFWwindow*) handle;
assert(window != NULL);
_GLFW_REQUIRE_INIT_OR_... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x2caed
leaq 0x65a74(%rip), %rax # 0x924c0
cmpl $0x0, (%rax)
je 0x2cabc
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq 0x2a0(%rdi), %rdi
leaq 0xc(%rsp), %rsi
leaq 0x8(%rsp), %rdx
leaq 0x4(%rsp), %rcx
leaq 0x10(%rsp... | /tuket[P]gltf_viewer/libs/glfw/src/osmesa_context.c |
glfwGetOSMesaContext | GLFWAPI OSMesaContext glfwGetOSMesaContext(GLFWwindow* handle)
{
_GLFWwindow* window = (_GLFWwindow*) handle;
_GLFW_REQUIRE_INIT_OR_RETURN(NULL);
if (window->context.client == GLFW_NO_API)
{
_glfwInputError(GLFW_NO_WINDOW_CONTEXT, NULL);
return NULL;
}
return window->context.os... | pushq %rbx
leaq 0x658d1(%rip), %rax # 0x924c0
cmpl $0x0, (%rax)
je 0x2cc06
cmpl $0x0, 0x1f8(%rdi)
je 0x2cc0f
movq 0x2a0(%rdi), %rbx
jmp 0x2cc1f
xorl %ebx, %ebx
movl $0x10001, %edi # imm = 0x10001
jmp 0x2cc16
xorl %ebx, %ebx
movl $0x1000a, %edi # imm = 0x1000A
xorl %esi, %esi
xorl %eax, %eax
callq ... | /tuket[P]gltf_viewer/libs/glfw/src/osmesa_context.c |
openJoystickDevice | static GLFWbool openJoystickDevice(const char* path)
{
for (int jid = 0; jid <= GLFW_JOYSTICK_LAST; jid++)
{
if (!_glfw.joysticks[jid].present)
continue;
if (strcmp(_glfw.joysticks[jid].linjs.path, path) == 0)
return GLFW_FALSE;
}
_GLFWjoystickLinux linjs = {0}... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20e8, %rsp # imm = 0x20E8
movq %rdi, %rbx
movl $0x484, %r14d # imm = 0x484
addq 0x2b22f(%rip), %r14 # 0x57fd8
xorl %r15d, %r15d
xorl %r12d, %r12d
cmpl $0x0, -0x7c(%r14)
je 0x2cdc5
movq %r14, %rdi
movq %rbx, %rsi
callq 0x14... | /tuket[P]gltf_viewer/libs/glfw/src/linux_joystick.c |
glfwDetectJoystickConnectionLinux | void _glfwDetectJoystickConnectionLinux(void)
{
if (_glfw.linjs.inotify <= 0)
return;
ssize_t offset = 0;
char buffer[16384];
const ssize_t size = read(_glfw.linjs.inotify, buffer, sizeof(buffer));
while (size > offset)
{
regmatch_t match;
const struct inotify_event* e ... | leaq 0x65203(%rip), %rax # 0x924c0
movl 0x20f38(%rax), %edi
testl %edi, %edi
jle 0x2d418
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x5028, %rsp # imm = 0x5028
leaq 0x1020(%rsp), %rsi
movl $0x4000, %edx # imm = 0x4000
callq 0x14710
testq %rax, %rax
jle 0x2d407
movq %... | /tuket[P]gltf_viewer/libs/glfw/src/linux_joystick.c |
pollAbsState | static void pollAbsState(_GLFWjoystick* js)
{
for (int code = 0; code < ABS_CNT; code++)
{
if (js->linjs.absMap[code] < 0)
continue;
struct input_absinfo* info = &js->linjs.absInfo[code];
if (ioctl(js->linjs.fd, EVIOCGABS(code), info) < 0)
continue;
h... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x197c, %r12d # imm = 0x197C
movl $0x187c, %r13d # imm = 0x187C
movl $0x80184540, %ebp # imm = 0x80184540
xorl %r14d, %r14d
cmpl $0x0, (%rbx,%r13)
js 0x2d558
leaq (%rbx,%r12), %r15
movl 0x78(%rbx),... | /tuket[P]gltf_viewer/libs/glfw/src/linux_joystick.c |
Catch::AssertionResult::getExpandedExpression[abi:cxx11]() const | std::string AssertionResult::getExpandedExpression() const {
return m_resultData.reconstructedExpression;
} | pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq 0x70(%rsi), %rax
movq 0x78(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x5c7ae
movq %rbx, %rax
popq %rbx
retq
nop
| /basiliscos[P]cpp-bredis/t/catch.hpp |
Catch::AssertionResult::getMessage[abi:cxx11]() const | std::string AssertionResult::getMessage() const {
return m_resultData.message;
} | pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq 0x90(%rsi), %rax
movq 0x98(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x5c7ae
movq %rbx, %rax
popq %rbx
retq
nop
| /basiliscos[P]cpp-bredis/t/catch.hpp |
Catch::AssertionResult::getSourceInfo() const | SourceLineInfo AssertionResult::getSourceInfo() const {
return m_info.lineInfo;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq 0x20(%rsi), %rsi
movq 0x28(%rbx), %rdx
addq %rsi, %rdx
callq 0x5c7ae
movq 0x40(%rbx), %rax
movq %rax, 0x20(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /basiliscos[P]cpp-bredis/t/catch.hpp |
Catch::AssertionResult::getTestMacroName[abi:cxx11]() const | std::string AssertionResult::getTestMacroName() const {
return m_info.macroName;
} | pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x5c7ae
movq %rbx, %rax
popq %rbx
retq
| /basiliscos[P]cpp-bredis/t/catch.hpp |
Catch::startsWith(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 startsWith( std::string const& s, std::string const& prefix ) {
return s.size() >= prefix.size() && s.substr( 0, prefix.size() ) == prefix;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq 0x8(%rsi), %rcx
cmpq %rcx, 0x8(%rdi)
jae 0x744f3
xorl %ebp, %ebp
jmp 0x74546
movq %rdi, %rsi
movq %rsp, %rbx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x576f0
movq 0x8(%rbx), %rdx
cmpq 0x8(%r14), %rdx
jne 0x74529
movq (%rsp), %rbx
testq %rdx, %rdx
je 0x... | /basiliscos[P]cpp-bredis/t/catch.hpp |
Catch::ResultBuilder::captureExpectedException(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void ResultBuilder::captureExpectedException( std::string const& expectedMessage ) {
if( expectedMessage.empty() )
captureExpectedException( Matchers::Impl::Generic::AllOf<std::string>() );
else
captureExpectedException( Matchers::Equals( expectedMessage ) );
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x77051
movq %rsi, %rdx
xorl %eax, %eax
leaq 0x18(%rsp), %rsi
movl %eax, -0x8(%rsi)
leaq 0x4500d(%rip), %r14 # 0xbc028
movq %r14, -0x10(%rsi)
movl %eax, (%rsi)
leaq 0x20(%rsp), %rdi
callq 0x8454e
leaq 0x8(%rsp), %rsi
movq %rbx... | /basiliscos[P]cpp-bredis/t/catch.hpp |
Catch::TagAliasRegistry::expandAliases(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | std::string TagAliasRegistry::expandAliases( std::string const& unexpandedTestSpec ) const {
std::string expandedTestSpec = unexpandedTestSpec;
for( std::map<std::string, TagAlias>::const_iterator it = m_registry.begin(), itEnd = m_registry.end();
it != itEnd;
++it ) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x60(%rsp)
movq %rax, (%rdi)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
callq 0x5c7ae
movq 0x20(%r14), %r15
addq $0x10, %r14
cmpq %r14, %r15
je 0x77f02
leaq 0x1... | /basiliscos[P]cpp-bredis/t/catch.hpp |
Catch::TestRunStats::~TestRunStats() | TestRunStats::~TestRunStats() {} | pushq %rbx
movq %rdi, %rbx
leaq 0x43299(%rip), %rax # 0xbbc40
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x789bc
callq 0x57630
movq %rbx, %rdi
popq %rbx
jmp 0x57630
nop
| /basiliscos[P]cpp-bredis/t/catch.hpp |
Catch::CumulativeReporterBase::SectionNode::~SectionNode() | CumulativeReporterBase::SectionNode::~SectionNode() {} | pushq %rbx
movq %rdi, %rbx
leaq 0x4328f(%rip), %rax # 0xbbc60
movq %rax, (%rdi)
movq 0xf8(%rdi), %rdi
leaq 0x108(%rbx), %rax
cmpq %rax, %rdi
je 0x789ec
callq 0x57630
movq 0xd8(%rbx), %rdi
leaq 0xe8(%rbx), %rax
cmpq %rax, %rdi
je 0x78a04
callq 0x57630
leaq 0xc0(%rbx), %rdi
callq 0x7adfe
leaq 0xa8(%rbx), %rdi
callq 0... | /basiliscos[P]cpp-bredis/t/catch.hpp |
Catch::CumulativeReporterBase::~CumulativeReporterBase() | CumulativeReporterBase::~CumulativeReporterBase() {} | pushq %rbx
movq %rdi, %rbx
leaq 0x43249(%rip), %rax # 0xbbc90
movq %rax, (%rdi)
addq $0xa8, %rdi
callq 0x7ae42
movq 0xa0(%rbx), %rdi
testq %rdi, %rdi
je 0x78a68
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x98(%rbx), %rdi
testq %rdi, %rdi
je 0x78a7a
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x80(%rbx), %rdi
callq 0x7ae... | /basiliscos[P]cpp-bredis/t/catch.hpp |
Catch::StreamingReporterBase::~StreamingReporterBase() | StreamingReporterBase::~StreamingReporterBase() {} | pushq %rbx
movq %rdi, %rbx
leaq 0x43263(%rip), %rax # 0xbbd38
movq %rax, (%rdi)
addq $0x1b0, %rdi # imm = 0x1B0
callq 0x7af22
leaq 0x90(%rbx), %rdi
callq 0x84b5c
movq 0x50(%rbx), %rax
testq %rax, %rax
je 0x78b0a
movq (%rax), %rdi
addq $0x10, %rax
cmpq %rax, %rdi
je 0x78b0a
callq 0x57630
movq $0x0, 0x50(%... | /basiliscos[P]cpp-bredis/t/catch.hpp |
Catch::WildcardPattern::~WildcardPattern() | WildcardPattern::~WildcardPattern() {} | pushq %rbx
movq %rdi, %rbx
leaq 0x43297(%rip), %rax # 0xbbf58
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x78cd6
callq 0x57630
movq %rbx, %rdi
popq %rbx
jmp 0x57630
nop
| /basiliscos[P]cpp-bredis/t/catch.hpp |
Catch::TestSpec::NamePattern::~NamePattern() | TestSpec::NamePattern::~NamePattern() {} | movq %rdi, %rax
leaq 0x43292(%rip), %rcx # 0xbbf80
movq %rcx, (%rdi)
leaq 0x43260(%rip), %rcx # 0xbbf58
movq %rcx, 0x10(%rdi)
movq 0x20(%rdi), %rdi
addq $0x30, %rax
cmpq %rax, %rdi
jne 0x57630
retq
| /basiliscos[P]cpp-bredis/t/catch.hpp |
Catch::TestSpec::TagPattern::~TagPattern() | TestSpec::TagPattern::~TagPattern() {} | pushq %rbx
movq %rdi, %rbx
leaq 0x4324b(%rip), %rax # 0xbbfb8
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x78d82
callq 0x57630
movq %rbx, %rdi
popq %rbx
jmp 0x57630
nop
| /basiliscos[P]cpp-bredis/t/catch.hpp |
Catch::Matchers::Impl::StdString::Equals::~Equals() | Matchers::Impl::StdString::Equals::~Equals() {} | pushq %rbx
movq %rdi, %rbx
leaq 0x4321f(%rip), %rax # 0xbc028
movq %rax, (%rdi)
movq 0x18(%rdi), %rdi
leaq 0x28(%rbx), %rax
cmpq %rax, %rdi
je 0x78e1e
callq 0x57630
movq %rbx, %rdi
popq %rbx
jmp 0x57630
nop
| /basiliscos[P]cpp-bredis/t/catch.hpp |
Catch::Matchers::Impl::StdString::Contains::~Contains() | Matchers::Impl::StdString::Contains::~Contains() {} | pushq %rbx
movq %rdi, %rbx
leaq 0x4321d(%rip), %rax # 0xbc070
movq %rax, (%rdi)
movq 0x18(%rdi), %rdi
leaq 0x28(%rbx), %rax
cmpq %rax, %rdi
je 0x78e68
callq 0x57630
movq %rbx, %rdi
popq %rbx
jmp 0x57630
nop
| /basiliscos[P]cpp-bredis/t/catch.hpp |
Catch::Matchers::Impl::StdString::StartsWith::~StartsWith() | Matchers::Impl::StdString::StartsWith::~StartsWith() {} | pushq %rbx
movq %rdi, %rbx
leaq 0x4321b(%rip), %rax # 0xbc0b8
movq %rax, (%rdi)
movq 0x18(%rdi), %rdi
leaq 0x28(%rbx), %rax
cmpq %rax, %rdi
je 0x78eb2
callq 0x57630
movq %rbx, %rdi
popq %rbx
jmp 0x57630
nop
| /basiliscos[P]cpp-bredis/t/catch.hpp |
Catch::Matchers::Impl::StdString::EndsWith::~EndsWith() | Matchers::Impl::StdString::EndsWith::~EndsWith() {} | pushq %rbx
movq %rdi, %rbx
leaq 0x43219(%rip), %rax # 0xbc100
movq %rax, (%rdi)
movq 0x18(%rdi), %rdi
leaq 0x28(%rbx), %rax
cmpq %rax, %rdi
je 0x78efc
callq 0x57630
movq %rbx, %rdi
popq %rbx
jmp 0x57630
nop
| /basiliscos[P]cpp-bredis/t/catch.hpp |
Catch::(anonymous namespace)::PosixColourImpl::~PosixColourImpl() | virtual void use( Colour::Code _colourCode ) {
switch( _colourCode ) {
case Colour::None:
case Colour::White: return setColour( "[0m" );
case Colour::Red: return setColour( "[0;31m" );
case Colour::Green: return setColour( "[0;32m... | jmp 0x57630
nop
| /basiliscos[P]cpp-bredis/t/catch.hpp |
Catch::(anonymous namespace)::PosixColourImpl::setColour(char const*) | void setColour( const char* _escapeCode ) {
Catch::cout() << '\033' << _escapeCode;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x7(%rsp), %rsi
movb $0x1b, (%rsi)
movq 0x44d10(%rip), %rdi # 0xbdf90
movl $0x1, %edx
callq 0x57750
movq %rax, %r14
testq %rbx, %rbx
je 0x792aa
movq %rbx, %rdi
callq 0x572f0
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x57750
jmp 0x792c4
movq (%r14), %... | /basiliscos[P]cpp-bredis/t/catch.hpp |
Catch::Ptr<Catch::IStreamingReporter>::operator=(Catch::Ptr<Catch::IStreamingReporter> const&) | Ptr& operator = ( Ptr const& other ){
Ptr temp( other );
swap( temp );
return *this;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %r14
testq %r14, %r14
je 0x792f2
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq (%rbx), %rdi
movq %r14, (%rbx)
testq %rdi, %rdi
je 0x79303
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
... | /basiliscos[P]cpp-bredis/t/catch.hpp |
Catch::RunContext::RunContext(Catch::Ptr<Catch::IConfig const> const&, Catch::Ptr<Catch::IStreamingReporter> const&) | explicit RunContext( Ptr<IConfig const> const& _config, Ptr<IStreamingReporter> const& reporter )
: m_runInfo( _config->name() ),
m_context( getCurrentMutableContext() ),
m_activeTestCase( CATCH_NULL ),
m_config( _config ),
m_reporter( reporter )
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x43f84(%rip), %rax # 0xbd360
movq %rax, (%rdi)
leaq 0x43fea(%rip), %rax # 0xbd3d0
movq %rax, 0x8(%rdi)
movq (%rsi), %rsi
movq (%rsi), %rax
leaq 0x18(%rsp), %rdi
callq *0x30(%r... | /basiliscos[P]cpp-bredis/t/catch.hpp |
Catch::RunContext::testGroupStarting(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, unsigned long) | void testGroupStarting( std::string const& testSpec, std::size_t groupIndex, std::size_t groupsCount ) {
m_reporter->testGroupStarting( GroupInfo( testSpec, groupIndex, groupsCount ) );
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq 0x140(%rdi), %r15
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rsp, %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x5c7ae
movq %r14, 0x20(%r12)
movq %rbx... | /basiliscos[P]cpp-bredis/t/catch.hpp |
Catch::TestSpecParser::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | TestSpecParser& parse( std::string const& arg ) {
m_mode = None;
m_exclusion = false;
m_start = std::string::npos;
m_arg = m_tagAliases->expandAliases( arg );
for( m_pos = 0; m_pos < m_arg.size(); ++m_pos )
visitChar( m_arg[m_pos] );
... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
movl $0x0, (%rdi)
movb $0x0, 0x4(%rdi)
movq $-0x1, 0x8(%rdi)
movq 0x68(%rdi), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq *0x18(%rax)
leaq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0x577f0
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
c... | /basiliscos[P]cpp-bredis/t/catch.hpp |
Catch::RunContext::runTest(Catch::TestCase const&) | Totals runTest( TestCase const& testCase ) {
Totals prevTotals = m_totals;
std::string redirectedCout;
std::string redirectedCerr;
TestCaseInfo testInfo = testCase.getTestCaseInfo();
m_reporter->testCaseStarting( testInfo );
m_activeTestCase = ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x328, %rsp # imm = 0x328
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x110(%rsi), %rax
movq %rax, 0x10(%rsp)
movq 0x118(%rsi), %rax
movq %rax, 0x20(%rsp)
movq 0x120(%rsi), %rax
movq %rax, 0x18(%rsp)
movdqu 0x128(%rsi), %xmm0
mo... | /basiliscos[P]cpp-bredis/t/catch.hpp |
Catch::RunContext::~RunContext() | virtual ~RunContext() {
m_reporter->testRunEnded( TestRunStats( m_runInfo, m_totals, aborting() ) );
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x4363e(%rip), %rax # 0xbd360
movq %rax, (%rdi)
leaq 0x436a4(%rip), %rax # 0xbd3d0
movq %rax, 0x8(%rdi)
movq 0x140(%rdi), %r14
movq 0x108(%rdi), %rdi
movq 0x118(%rbx), %r13
movq (%rdi), %rax
callq *0x50(%rax)... | /basiliscos[P]cpp-bredis/t/catch.hpp |
Catch::TestSpec::matches(Catch::TestCaseInfo const&) const | Generic::AllOf<ExpressionT> Matcher<ExpressionT>::operator && ( Matcher<ExpressionT> const& other ) const {
Generic::AllOf<ExpressionT> allOfExpr;
allOfExpr.add( *this );
allOfExpr.add( other );
return allOfExpr;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r14
movq 0x8(%rdi), %r15
cmpq %r15, %r14
je 0x79efa
movq %rsi, %rbx
movq (%r14), %r12
movq 0x8(%r14), %r13
cmpq %r13, %r12
sete %bpl
je 0x79ef5
movq (%r12), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x20(%rax)
testb %al, %al
... | /basiliscos[P]cpp-bredis/t/catch.hpp |
Catch::Matchers::Impl::StdString::EndsWith::toString[abi:cxx11]() const | virtual std::string toString() const {
return "ends with: \"" + m_data.m_str + "\"" + m_data.toStringSuffix();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsi), %rdx
leaq 0x20937(%rip), %rsi # 0x9c313
leaq 0x40(%rsp), %r15
movq %r15, %rdi
callq 0x5ed11
leaq 0x1fbbc(%rip), %rsi # 0x9b5ac
movq %r15, %rdi
callq 0x57cc0
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax)... | /basiliscos[P]cpp-bredis/t/catch.hpp |
Catch::WildcardPattern::matches(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | virtual bool matches( std::string const& str ) const {
switch( m_wildcard ) {
case NoWildcard:
return m_pattern == adjustCase( str );
case WildcardAtStart:
return endsWith( adjustCase( str ), m_pattern );
case WildcardAt... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movl 0xc(%rdi), %eax
cmpq $0x3, %rax
ja 0x7bca6
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x1f0f1(%rip), %rcx # 0x9aca0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x81d8a
movq 0x18(%rbx), %rdx
cmpq 0x8(%r14), %rd... | /basiliscos[P]cpp-bredis/t/catch.hpp |
Catch::TestCaseTracking::TrackerBase::close() | virtual void close() CATCH_OVERRIDE {
// Close any still open children (e.g. generators)
while( &m_ctx.currentTracker() != this )
m_ctx.currentTracker().close();
switch( m_runState ) {
case NotStarted:
case CompletedSuccessfully:
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq 0x8(%rax), %rdi
cmpq %rbx, %rdi
je 0x7bf6a
movq (%rdi), %rax
callq *0x50(%rax)
movq 0x30(%rbx), %rax
jmp 0x7bf55
movl 0x58(%rbx), %eax
cmpq $0x5, %rax
ja 0x7c003
leaq 0x1ed32(%rip), %rcx # 0x9acb0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
... | /basiliscos[P]cpp-bredis/t/catch.hpp |
Catch::TestCaseTracking::TrackerBase::fail() | virtual void fail() CATCH_OVERRIDE {
m_runState = Failed;
if( m_parent )
m_parent->markAsNeedingAnotherRun();
moveToParent();
m_ctx.completeCycle();
} | pushq %rbx
movq %rdi, %rbx
movl $0x5, 0x58(%rdi)
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x7c07e
movq (%rdi), %rax
callq *0x60(%rax)
movq 0x38(%rbx), %rax
testq %rax, %rax
je 0x7c07e
movq 0x30(%rbx), %rcx
movq %rax, 0x8(%rcx)
movl $0x2, 0x10(%rcx)
popq %rbx
retq
leaq 0x202a8(%rip), %rdi # 0x9c32d
leaq 0x1f605(%ri... | /basiliscos[P]cpp-bredis/t/catch.hpp |
Catch::TestCaseTracking::TrackerBase::findChild(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | virtual ITracker* findChild( std::string const& name ) CATCH_OVERRIDE {
Children::const_iterator it = std::find_if( m_children.begin(), m_children.end(), TrackerHasName( name ) );
return( it != m_children.end() )
? it->get()
: CATCH_NULL;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x40(%rdi), %r14
movq 0x48(%rdi), %r15
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rsp, %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0x5c7ae
movq %r14, %rdi
movq %r15,... | /basiliscos[P]cpp-bredis/t/catch.hpp |
Catch::XmlReporter::sectionEnded(Catch::SectionStats const&) | virtual void sectionEnded( SectionStats const& sectionStats ) CATCH_OVERRIDE {
StreamingReporterBase::sectionEnded( sectionStats );
if( --m_sectionDepth > 0 ) {
XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
e.writeAttribute( "successes", se... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r15
addq $0x1b0, %rdi # imm = 0x1B0
movq 0x1b8(%r15), %rsi
addq $-0x68, %rsi
movq %rsi, 0x1b8(%r15)
callq 0x8e912
movl 0x220(%r15), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x220(%r15)
cmpl $0x2, %eax
jl 0x7df48
leaq 0x18(%... | /basiliscos[P]cpp-bredis/t/catch.hpp |
Catch::RunContext::sectionStarted(Catch::SectionInfo const&, Catch::Counts&) | virtual bool sectionStarted (
SectionInfo const& sectionInfo,
Counts& assertions
)
{
std::ostringstream oss;
oss << sectionInfo.name << "@" << sectionInfo.lineInfo;
ITracker& sectionTracker = SectionTracker::acquire( m_trackerContext, oss.str(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp # imm = 0x198
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x578b0
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r12, %rdi
callq 0x57750
movq %rax, %r13
leaq 0x1c64b(%rip), %rsi ... | /basiliscos[P]cpp-bredis/t/catch.hpp |
Catch::RunContext::getCurrentTestName[abi:cxx11]() const | virtual std::string getCurrentTestName() const {
return m_activeTestCase
? m_activeTestCase->getTestCaseInfo().name
: "";
} | pushq %rbx
movq %rdi, %rbx
movq 0x38(%rsi), %rax
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
testq %rax, %rax
je 0x7f496
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x5c7ae
jmp 0x7f4a8
leaq 0x1d289(%rip), %rdx # 0x9c726
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x5c0d2
movq %rbx, %rax
popq ... | /basiliscos[P]cpp-bredis/t/catch.hpp |
Catch::RunContext::handleFatalErrorCondition(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | virtual void handleFatalErrorCondition( std::string const& message ) {
ResultBuilder resultBuilder = makeUnexpectedResultBuilder();
resultBuilder.setResultType( ResultWas::FatalErrorCondition );
resultBuilder << message;
resultBuilder.captureExpression();
han... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x6d0, %rsp # imm = 0x6D0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x180(%rdi), %rdx
movq 0x160(%rdi), %rsi
movq 0x1a8(%rdi), %rcx
movl 0x1c8(%rdi), %r8d
leaq 0x1d239(%rip), %r9 # 0x9c726
leaq 0x430(%rsp), %r15
movq %r15, %rdi
callq 0x76c86
movl $... | /basiliscos[P]cpp-bredis/t/catch.hpp |
Catch::AssertionStats::AssertionStats(Catch::AssertionResult const&, std::vector<Catch::MessageInfo, std::allocator<Catch::MessageInfo>> const&, Catch::Totals const&) | AssertionStats( AssertionResult const& _assertionResult,
std::vector<MessageInfo> const& _infoMessages,
Totals const& _totals )
: assertionResult( _assertionResult ),
infoMessages( _infoMessages ),
totals( _totals )
{
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x240, %rsp # imm = 0x240
movq %rcx, %r12
movq %rdx, %r13
movq %rdi, %r15
leaq 0x3c216(%rip), %rax # 0xbbbc0
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
callq 0x7fc58
leaq 0xc0(%r15), %r14
movq %r14, %rdi
movq %r13, %rsi
callq 0x7fd7... | /basiliscos[P]cpp-bredis/t/catch.hpp |
Catch::TestCaseTracking::SectionTracker::acquire(Catch::TestCaseTracking::TrackerContext&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static SectionTracker& acquire( TrackerContext& ctx, std::string const& name ) {
SectionTracker* section = CATCH_NULL;
ITracker& currentTracker = ctx.currentTracker();
if( ITracker* childTracker = currentTracker.findChild( name ) ) {
assert( childTracker );
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %r14
movq 0x8(%rdi), %r15
movq (%r15), %rax
movq %r15, %rdi
callq *0x70(%rax)
testq %rax, %rax
je 0x80458
movq %rax, %rbx
movq (%rax), %rax
movq %rbx, %rdi
callq *0x80(%rax)
testb %al, %al
jne 0x804d1
leaq 0x1b4b9(%rip), %rdi # 0x9b8f... | /basiliscos[P]cpp-bredis/t/catch.hpp |
Catch::SectionStats::SectionStats(Catch::SectionInfo const&, Catch::Counts const&, double, bool) | SectionStats( SectionInfo const& _sectionInfo,
Counts const& _assertions,
double _durationInSeconds,
bool _missingAssertions )
: sectionInfo( _sectionInfo ),
assertions( _assertions ),
durationInSeconds( _duratio... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movsd %xmm0, 0x10(%rsp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x3b4ea(%rip), %rax # 0xbbbe0
movq %rax, (%rdi)
addq $0x8, %rdi
leaq 0x18(%r14), %rax
movq %rax, (%rsp)
movq %rax, 0x8(%r14)
movq (%rsi), %r... | /basiliscos[P]cpp-bredis/t/catch.hpp |
nativeFutexWake(void const*, int, unsigned int) | int nativeFutexWake(const void *addr, int count, uint32_t wakeMask) {
#ifndef PSHARED
int rv = syscall(
__NR_futex,
addr, /* addr1 */
FUTEX_WAKE_BITSET | FUTEX_PRIVATE_FLAG, /* op */
count, /* val */
nullptr, /* timeout */
nullptr, /* addr2 */
... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movq 0x18(%rsp), %rsi
movl 0x14(%rsp), %ecx
movl 0x10(%rsp), %eax
movl $0xca, %edi
movl $0x8a, %edx
xorl %r8d, %r8d
movl %r8d, %r9d
movq %r9, %r8
movl %eax, (%rsp)
movb $0x0, %al
callq 0x4040
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jge... | /r10a[P]Event-Counts/Futex.cpp |
nativeFutexWaitImpl(void const*, unsigned int, std::chrono::time_point<std::chrono::_V2::system_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>> const*, std::chrono::time_point<std::chrono::_V2::steady_clock, std::chrono::duration<long, std::ratio<1l, 1000000000l>>> const*, unsigned int) | FutexResult nativeFutexWaitImpl(
const void *addr,
uint32_t expected,
system_clock::time_point const *absSystemTime,
steady_clock::time_point const *absSteadyTime,
uint32_t waitMask) {
assert(absSystemTime == nullptr || absSteadyTime == nullptr);
#ifndef PSHARED
int op =... | subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movl %esi, 0x84(%rsp)
movq %rdx, 0x78(%rsp)
movq %rcx, 0x70(%rsp)
movl %r8d, 0x6c(%rsp)
movb $0x1, %al
cmpq $0x0, 0x78(%rsp)
movb %al, 0x1b(%rsp)
je 0x4330
cmpq $0x0, 0x70(%rsp)
sete %al
movb %al, 0x1b(%rsp)
movb 0x1b(%rsp), %al
testb $0x1, %al
jne 0x433a
jmp 0x433c
jmp 0x435b
lea... | /r10a[P]Event-Counts/Futex.cpp |
timespec timeSpecFromTimePoint<std::chrono::_V2::system_clock>(std::chrono::time_point<std::chrono::_V2::system_clock, std::chrono::_V2::system_clock::duration>) | struct timespec timeSpecFromTimePoint(time_point<Clock> absTime) {
auto epoch = absTime.time_since_epoch();
if (epoch.count() < 0) {
// kernel timespec_valid requires non-negative seconds and nanos in [0,1G)
epoch = Clock::duration::zero();
}
// timespec-safe seconds and nanoseconds;
... | subq $0x58, %rsp
movq %rdi, 0x40(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x46d0
movq %rax, 0x38(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x46f0
cmpq $0x0, %rax
jge 0x45ac
callq 0x4700
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x4740
movq 0x8(%rsp), %rdi
movq %... | /r10a[P]Event-Counts/Futex.cpp |
timespec timeSpecFromTimePoint<std::chrono::_V2::steady_clock>(std::chrono::time_point<std::chrono::_V2::steady_clock, std::chrono::_V2::steady_clock::duration>) | struct timespec timeSpecFromTimePoint(time_point<Clock> absTime) {
auto epoch = absTime.time_since_epoch();
if (epoch.count() < 0) {
// kernel timespec_valid requires non-negative seconds and nanos in [0,1G)
epoch = Clock::duration::zero();
}
// timespec-safe seconds and nanoseconds;
... | subq $0x58, %rsp
movq %rdi, 0x40(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x49b0
movq %rax, 0x38(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x46f0
cmpq $0x0, %rax
jge 0x465c
callq 0x4700
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x4740
movq 0x8(%rsp), %rdi
movq %... | /r10a[P]Event-Counts/Futex.cpp |
notifier(EventCount*) | void notifier(EventCount *eventCount) {
for (int i = 0; i < 100; i++) {
std::cout << "Notifying: " << i << std::endl;
eventCount->notify();
std::cout << "Notified: " << i << std::endl;
usleep(100);
}
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpl $0x64, 0xc(%rsp)
jge 0x4b2c
movq 0x4525(%rip), %rdi # 0x8fd8
leaq 0x16d6(%rip), %rsi # 0x6190
callq 0x40b0
movq %rax, %rdi
movl 0xc(%rsp), %esi
callq 0x4120
movq %rax, %rdi
movq 0x44eb(%rip), %rsi # 0x8fc0
callq 0x40e0
movq 0x10(%rsp), %rdi... | /r10a[P]Event-Counts/main.cpp |
main | int main(int argc, char **argv) {
EventCount eventCount;
std::thread t1(waiter, &eventCount);
usleep(1);
std::thread t2(notifier, &eventCount);
t1.join();
t2.join();
return 0;
} | subq $0x58, %rsp
movl $0x0, 0x54(%rsp)
movl %edi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x4f00
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq -0x1a5(%rip), %rsi # 0x49d0
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x4f20
movl $0x1, %edi
callq 0x40f0
jmp 0x4b90
lea... | /r10a[P]Event-Counts/main.cpp |
EventCount::prepareWait() | inline EventCount::Key EventCount::prepareWait() noexcept {
uint64_t prev = val_.fetch_add(kAddWaiter, std::memory_order_acq_rel);
return Key(prev >> kEpochShift);
} | subq $0x58, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x50(%rsp)
movq $0x1, 0x48(%rsp)
movl $0x4, 0x44(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x44(%rsp), %eax
movq 0x48(%rsp), %rcx
movq %rcx, 0x38(%rsp)
decl %eax
movl %eax, %ecx
movq %rcx, 0x10(%rsp)
subl $0x4, %eax
ja 0x4c8f
movq 0x10(... | /r10a[P]Event-Counts/EventCount.hpp |
EventCount::wait(EventCount::Key) | inline void EventCount::wait(Key key) noexcept {
while ((val_.load(std::memory_order_acquire) >> kEpochShift) == key.epoch_) {
futexWait(
reinterpret_cast<Futex<std::atomic> *>(&val_) + kEpochOffset,
key.epoch_);
}
// memory_order_relaxed would suffice for correctnes... | subq $0x88, %rsp
movl %esi, 0x44(%rsp)
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x80(%rsp)
movl $0x2, 0x7c(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x7c(%rsp), %edi
movl $0xffff, %esi # imm = 0xFFFF
callq 0x5090
movl %eax, 0x2c(%rsp)
jmp ... | /r10a[P]Event-Counts/EventCount.hpp |
EventCount::doNotify(int) | inline void EventCount::doNotify(int n) noexcept {
uint64_t prev = val_.fetch_add(kAddEpoch, std::memory_order_acq_rel);
if (UNLIKELY(prev & kWaiterMask)) {
futexWake(reinterpret_cast<Futex<std::atomic> *>(&val_) + kEpochOffset, n);
}
} | subq $0x58, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq %rax, 0x50(%rsp)
movabsq $0x100000000, %rax # imm = 0x100000000
movq %rax, 0x48(%rsp)
movl $0x4, 0x44(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x44(%rsp), %eax
movq 0x48(%rsp), %rcx
movq %rcx, 0x3... | /r10a[P]Event-Counts/EventCount.hpp |
alsa_stream_get_latency | static int
alsa_stream_get_latency(cubeb_stream * stm, uint32_t * latency)
{
snd_pcm_sframes_t delay;
/* This function returns the delay in frames until a frame written using
snd_pcm_writei is sent to the DAC. The DAC delay should be < 1ms anyways.
*/
if (WRAP(snd_pcm_delay)(stm->pcm, &delay)) {
retur... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x52423(%rip), %rax # 0x668c8
movq 0x18(%rsp), %rcx
movq 0x38(%rcx), %rdi
leaq 0x8(%rsp), %rsi
callq *%rax
cmpl $0x0, %eax
je 0x144c4
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x144da
movq 0x8(%rsp), %rax
movl %eax, %ecx
movq 0x10(%rsp), %r... | /kinetiknz[P]cubeb/src/cubeb_alsa.c |
sndio_stream_start | static int
sndio_stream_start(cubeb_stream * s)
{
int err;
DPR("sndio_stream_start()\n");
s->active = 1;
err = pthread_create(&s->th, NULL, sndio_mainloop, s);
if (err) {
s->active = 0;
return CUBEB_ERROR;
}
return CUBEB_OK;
} | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
jmp 0x15abb
movq 0x8(%rsp), %rax
movl $0x1, 0x4c(%rax)
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
movq 0x8(%rsp), %rcx
xorl %eax, %eax
movl %eax, %esi
leaq 0x190(%rip), %rdx # 0x15c70
callq 0x6ab0
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
je 0x15b06
movq 0x8(%rsp), %rax
movl $0x0,... | /kinetiknz[P]cubeb/src/cubeb_sndio.c |
sndio_stream_set_volume | static int
sndio_stream_set_volume(cubeb_stream * s, float volume)
{
DPR("sndio_stream_set_volume(%f)\n", volume);
pthread_mutex_lock(&s->mtx);
if (volume < 0.)
volume = 0.;
else if (volume > 1.0)
volume = 1.;
s->volume = volume;
pthread_mutex_unlock(&s->mtx);
return CUBEB_OK;
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movss %xmm0, 0xc(%rsp)
jmp 0x15bc1
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
callq 0x6870
movss 0xc(%rsp), %xmm0
cvtss2sd %xmm0, %xmm1
xorps %xmm0, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x15bed
xorps %xmm0, %xmm0
movss %xmm0, 0xc(%rsp)
jmp 0x15c15
movss 0xc(%rsp), %xmm0
cvtss2sd %xmm0, %xmm... | /kinetiknz[P]cubeb/src/cubeb_sndio.c |
sndio_mainloop | static void *
sndio_mainloop(void * arg)
{
struct pollfd * pfds;
cubeb_stream * s = arg;
int n, eof = 0, prime, nfds, events, revents, state = CUBEB_STATE_STARTED;
size_t pstart = 0, pend = 0, rstart = 0, rend = 0;
long nfr;
nfds = WRAP(sio_nfds)(s->hdl);
pfds = calloc(nfds, sizeof(struct pollfd));
if ... | subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x48(%rsp)
movl $0x0, 0x40(%rsp)
movl $0x0, 0x2c(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x50d0a(%rip), %rax # 0x669c8
movq 0x48(%rsp), %rcx
movq 0x40(%rcx), %rdi
callq *%rax
movl %eax, ... | /kinetiknz[P]cubeb/src/cubeb_sndio.c |
s16_to_float | static void
s16_to_float(void * ptr, long nsamp)
{
int16_t * src = ptr;
float * dst = ptr;
src += nsamp;
dst += nsamp;
while (nsamp-- > 0)
*(--dst) = (1. / 32768) * *(--src);
} | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rax
shlq %rax
addq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rax
shlq $0x2, %rax
addq -0x20(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %ra... | /kinetiknz[P]cubeb/src/cubeb_sndio.c |
float_to_s16 | static void
float_to_s16(void * ptr, long nsamp, float volume)
{
int16_t * dst = ptr;
float * src = ptr;
float mult = volume * 32768;
int s;
while (nsamp-- > 0) {
s = lrintf(*(src++) * mult);
if (s < -32768)
s = -32768;
else if (s > 32767)
s = 32767;
*(dst++) = s;
}
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movss %xmm0, 0x24(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movss 0x2fbb4(%rip), %xmm0 # 0x45f74
mulss 0x24(%rsp), %xmm0
movss %xmm0, 0xc(%rsp)
movq 0x28(%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq ... | /kinetiknz[P]cubeb/src/cubeb_sndio.c |
s16_setvol | static void
s16_setvol(void * ptr, long nsamp, float volume)
{
int16_t * dst = ptr;
int32_t mult = volume * 32768;
int32_t s;
while (nsamp-- > 0) {
s = *dst;
s = (s * mult) >> 15;
*(dst++) = s;
}
} | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movss %xmm0, -0x14(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movss 0x2faf2(%rip), %xmm0 # 0x45f74
mulss -0x14(%rsp), %xmm0
cvttss2si %xmm0, %eax
movl %eax, -0x24(%rsp)
movq -0x10(%rsp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x10(%rsp)
cmpq $0x0, %rax
... | /kinetiknz[P]cubeb/src/cubeb_sndio.c |
cubeb_channel_layout_nb_channels | unsigned int
cubeb_channel_layout_nb_channels(cubeb_channel_layout x)
{
#if __GNUC__ || __clang__
return __builtin_popcount(x);
#else
x -= (x >> 1) & 0x55555555;
x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
x = (x + (x >> 4)) & 0x0F0F0F0F;
x += x >> 8;
return (x + (x >> 16)) & 0x3F;
#endif
} | movl %edi, -0x4(%rsp)
movl -0x4(%rsp), %ecx
movl %ecx, %eax
shrl %eax
andl $0x55555555, %eax # imm = 0x55555555
subl %eax, %ecx
movl %ecx, %eax
andl $0x33333333, %eax # imm = 0x33333333
shrl $0x2, %ecx
andl $0x33333333, %ecx # imm = 0x33333333
addl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
addl %ecx,... | /kinetiknz[P]cubeb/src/cubeb_mixer.cpp |
MixerContext::init() | int
MixerContext::init()
{
int r = auto_matrix();
if (r) {
return r;
}
// Determine if matrix operation would overflow
if (_format == CUBEB_SAMPLE_S16NE) {
int maxsum = 0;
for (uint32_t i = 0; i < _out_ch_count; i++) {
double rem = 0;
int sum = 0;
for (uint32_t j = 0; j < _in_c... | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x16530
movl %eax, 0x44(%rsp)
cmpl $0x0, 0x44(%rsp)
je 0x170e0
movl 0x44(%rsp), %eax
movl %eax, 0x54(%rsp)
jmp 0x1731d
movq 0x8(%rsp), %rax
cmpl $0x0, (%rax)
jne 0x17203
movl $0x0, 0x40(%rsp)
movl $0x0, 0x3c(%rsp)
movq 0x8(%rsp), %r... | /kinetiknz[P]cubeb/src/cubeb_mixer.cpp |
cubeb_channel_layout_check(unsigned int, unsigned int) | static cubeb_channel_layout
cubeb_channel_layout_check(cubeb_channel_layout l, uint32_t c)
{
if (l == CUBEB_LAYOUT_UNDEFINED) {
switch (c) {
case 1:
return CUBEB_LAYOUT_MONO;
case 2:
return CUBEB_LAYOUT_STEREO;
}
}
return l;
} | movl %edi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
cmpl $0x0, -0x8(%rsp)
jne 0x1743f
movl -0xc(%rsp), %eax
movl %eax, -0x10(%rsp)
subl $0x1, %eax
je 0x17429
jmp 0x1741e
movl -0x10(%rsp), %eax
subl $0x2, %eax
je 0x17433
jmp 0x1743d
movl $0x4, -0x4(%rsp)
jmp 0x17447
movl $0x3, -0x4(%rsp)
jmp 0x17447
jmp 0x1743f
movl -0x8(%rsp),... | /kinetiknz[P]cubeb/src/cubeb_mixer.cpp |
int rematrix<float, float, 32ul, cubeb_mixer::mix(unsigned long, void const*, unsigned long, void*, unsigned long) const::'lambda'(float)&>(MixerContext const*, float*, float const*, float const (&) [32ul][32ul], cubeb_mixer::mix(unsigned long, void const*, unsigned long, void*, unsigned long) const::'lambda'(float)&, ... | static int
rematrix(const MixerContext * s, TYPE * aOut, const TYPE * aIn,
const TYPE_COEFF (&matrix_coeff)[COLS][COLS], F && aF, uint32_t frames)
{
static_assert(
std::is_same<TYPE_COEFF, decltype(aF(matrix_coeff[0][0]))>::value,
"function must return the same type as used by matrix_coeff");
... | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movl %r9d, 0x3c(%rsp)
movl $0x0, 0x38(%rsp)
movl 0x38(%rsp), %eax
movq 0x60(%rsp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x1779b
movq 0x58(%rsp), %rax
movl 0x38(%rsp), %ecx
leaq (%rax,%rcx,4), %rax
mov... | /kinetiknz[P]cubeb/src/cubeb_mixer.cpp |
int rematrix<short, int, 32ul, cubeb_mixer::mix(unsigned long, void const*, unsigned long, void*, unsigned long) const::'lambda'(int)&>(MixerContext const*, short*, short const*, int const (&) [32ul][32ul], cubeb_mixer::mix(unsigned long, void const*, unsigned long, void*, unsigned long) const::'lambda'(int)&, unsigned... | static int
rematrix(const MixerContext * s, TYPE * aOut, const TYPE * aIn,
const TYPE_COEFF (&matrix_coeff)[COLS][COLS], F && aF, uint32_t frames)
{
static_assert(
std::is_same<TYPE_COEFF, decltype(aF(matrix_coeff[0][0]))>::value,
"function must return the same type as used by matrix_coeff");
... | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movl %r9d, 0x4c(%rsp)
movl $0x0, 0x48(%rsp)
movl 0x48(%rsp), %eax
movq 0x70(%rsp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x17ae8
movq 0x68(%rsp), %rax
movl 0x48(%rsp), %ecx
leaq (%rax,%rcx,2), %rax
mov... | /kinetiknz[P]cubeb/src/cubeb_mixer.cpp |
int rematrix<short, int, 32ul, cubeb_mixer::mix(unsigned long, void const*, unsigned long, void*, unsigned long) const::'lambda0'(int)&>(MixerContext const*, short*, short const*, int const (&) [32ul][32ul], cubeb_mixer::mix(unsigned long, void const*, unsigned long, void*, unsigned long) const::'lambda0'(int)&, unsign... | static int
rematrix(const MixerContext * s, TYPE * aOut, const TYPE * aIn,
const TYPE_COEFF (&matrix_coeff)[COLS][COLS], F && aF, uint32_t frames)
{
static_assert(
std::is_same<TYPE_COEFF, decltype(aF(matrix_coeff[0][0]))>::value,
"function must return the same type as used by matrix_coeff");
... | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movl %r9d, 0x4c(%rsp)
movl $0x0, 0x48(%rsp)
movl 0x48(%rsp), %eax
movq 0x70(%rsp), %rcx
cmpl 0x10(%rcx), %eax
jae 0x17e28
movq 0x68(%rsp), %rax
movl 0x48(%rsp), %ecx
leaq (%rax,%rcx,2), %rax
mov... | /kinetiknz[P]cubeb/src/cubeb_mixer.cpp |
void sum2<float, float, cubeb_mixer::mix(unsigned long, void const*, unsigned long, void*, unsigned long) const::'lambda'(float)&>(float*, unsigned int, float const*, float const*, unsigned int, float, float, cubeb_mixer::mix(unsigned long, void const*, unsigned long, void*, unsigned long) const::'lambda'(float)&, unsi... | void
sum2(TYPE_SAMPLE * out, uint32_t stride_out, const TYPE_SAMPLE * in1,
const TYPE_SAMPLE * in2, uint32_t stride_in, TYPE_COEFF coeff1,
TYPE_COEFF coeff2, F && operand, uint32_t frames)
{
static_assert(
std::is_same<TYPE_COEFF, decltype(operand(coeff1))>::value,
"function must return the same... | subq $0x48, %rsp
movl 0x50(%rsp), %eax
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movl %r8d, 0x24(%rsp)
movss %xmm0, 0x20(%rsp)
movss %xmm1, 0x1c(%rsp)
movq %r9, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x50(%rsp), %eax
jae 0x18a45
movq 0x10(%rsp), %rdi
movs... | /kinetiknz[P]cubeb/src/cubeb_mixer.cpp |
cubeb_strings_init | int
cubeb_strings_init(cubeb_strings ** strings)
{
cubeb_strings * strs = NULL;
if (!strings) {
return CUBEB_ERROR;
}
strs = calloc(1, sizeof(cubeb_strings));
assert(strs);
if (!strs) {
return CUBEB_ERROR;
}
strs->size = sizeof(strs->small_store) / sizeof(strs->small_store[0]);
strs->count... | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq $0x0, (%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x18de3
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x18e40
movl $0x1, %edi
movl $0x30, %esi
callq 0x62e0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x18e07
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x18e40
movq (%rsp), %rax... | /kinetiknz[P]cubeb/src/cubeb_strings.c |
cubeb_strings_lookup | static char const *
cubeb_strings_lookup(cubeb_strings * strings, char const * s)
{
char ** sp = NULL;
char ** se = NULL;
if (!strings || !s) {
return NULL;
}
sp = strings->data;
se = sp + strings->count;
for (; sp != se; sp++) {
if (*sp && strcmp(*sp, s) == 0) {
return *sp;
}
}
... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x18fbf
cmpq $0x0, 0x10(%rsp)
jne 0x18fca
movq $0x0, 0x20(%rsp)
jmp 0x19047
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movl 0x4(%rc... | /kinetiknz[P]cubeb/src/cubeb_strings.c |
testing::internal::BoolFromGTestEnv(char const*, bool) | bool BoolFromGTestEnv(const char* flag, bool default_value) {
const String env_var = FlagToEnvVar(flag);
const char* const string_value = posix::GetEnv(env_var.c_str());
return string_value == NULL ?
default_value : strcmp(string_value, "0") != 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x2b390
movq -0x48(%rbp), %rdi
callq 0x8200
movq %rax, -0x40(%rbp)
jmp 0x192a4
movq -0x40(%rbp), %rdi
callq 0x30990
movq %rax, -0... | /kinetiknz[P]cubeb/googletest/src/gtest-port.cc |
testing::internal::UnitTestOptions::GetOutputFormat() | String UnitTestOptions::GetOutputFormat() {
const char* const gtest_output_flag = GTEST_FLAG(output).c_str();
if (gtest_output_flag == NULL) return String("");
const char* const colon = strchr(gtest_output_flag, ':');
return (colon == NULL) ?
String(gtest_output_flag) :
String(gtest_output_flag, co... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
leaq 0x4c932(%rip), %rdi # 0x66a50
callq 0x8200
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1a140
movq -0x28(%rbp), %rdi
leaq 0x3217a(%rip), %rsi # 0x4c2b3
callq 0x2d060
jmp 0x... | /kinetiknz[P]cubeb/googletest/src/gtest.cc |
testing::ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter() | ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter() {
internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
if (intercept_mode_ == INTERCEPT_ALL_THREADS) {
impl->SetGlobalTestPartResultReporter(old_reporter_);
} else {
impl->SetTestPartResultReporterForCurrentThread(old_repor... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x4a405(%rip), %rcx # 0x65420
movq %rcx, (%rax)
callq 0x2d4b0
movq %rax, -0x18(%rbp)
jmp 0x1b029
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0x10(%rbp)
cmpl $0x1, 0x8(%rax)
jne 0x1b050
m... | /kinetiknz[P]cubeb/googletest/src/gtest.cc |
testing::internal::GetTimeInMillis() | TimeInMillis GetTimeInMillis() {
#if GTEST_OS_WINDOWS_MOBILE || defined(__BORLANDC__)
// Difference between 1970-01-01 and 1601-01-01 in milliseconds.
// http://analogous.blogspot.com/2005/04/epoch.html
const TimeInMillis kJavaEpochToWinFileTimeDelta =
static_cast<TimeInMillis>(116444736UL) * 100000UL;
cons... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6970
imulq $0x3e8, -0x10(%rbp), %rax # imm = 0x3E8
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl $0x3e8, %ecx # imm = 0x3E8
cqto
idivq %rcx
movq %rax, %rcx
movq -0x18(%rbp), %rax
addq %rcx, %rax
add... | /kinetiknz[P]cubeb/googletest/src/gtest.cc |
testing::internal::StringStreamToString(std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>*) | String StringStreamToString(::std::stringstream* ss) {
const ::std::string& str = ss->str();
const char* const start = str.c_str();
const char* const end = start + str.length();
// We need to use a helper stringstream to do this transformation
// because String doesn't support push_back().
::std::stringstr... | pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp # imm = 0x230
movq %rdi, -0x228(%rbp)
movq %rdi, %rax
movq %rax, -0x220(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x218(%rbp)
callq 0x64c0
movq -0x218(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(... | /kinetiknz[P]cubeb/googletest/src/gtest.cc |
testing::internal::CmpHelperSTREQ(char const*, char const*, wchar_t const*, wchar_t const*) | AssertionResult CmpHelperSTREQ(const char* expected_expression,
const char* actual_expression,
const wchar_t* expected,
const wchar_t* actual) {
if (String::WideCStringEquals(expected, actual)) {
return AssertionSuccess()... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1ecb0
testb $0x1, %al
jne 0x1ed4d
jmp 0x1ed5b
m... | /kinetiknz[P]cubeb/googletest/src/gtest.cc |
testing::internal::String::CaseInsensitiveWideCStringEquals(wchar_t const*, wchar_t const*) | bool String::CaseInsensitiveWideCStringEquals(const wchar_t* lhs,
const wchar_t* rhs) {
if (lhs == NULL) return rhs == NULL;
if (rhs == NULL) return false;
#if GTEST_OS_WINDOWS
return _wcsicmp(lhs, rhs) == 0;
#elif GTEST_OS_LINUX && !GTEST_OS_LINUX_ANDROID
return ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1eff6
cmpq $0x0, -0x18(%rbp)
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1f01b
cmpq $0x0, -0x18(%rbp)
jne 0x1f003
movb $0x0, -0x1(%rbp)
jmp 0x1f01b
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
... | /kinetiknz[P]cubeb/googletest/src/gtest.cc |
testing::internal::String::EndsWithCaseInsensitive(char const*) const | bool String::EndsWithCaseInsensitive(const char* suffix) const {
if (suffix == NULL || CStringEquals(suffix, "")) return true;
if (c_str() == NULL) return false;
const size_t this_len = strlen(c_str());
const size_t suffix_len = strlen(suffix);
return (this_len >= suffix_len) &&
CaseInsensitiveCStr... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1f2b5
movq -0x18(%rbp), %rdi
leaq 0x2d009(%rip), %rsi # 0x4c2b3
callq 0x1bf70
testb $0x1, %al
jne 0x1f2b5
jmp 0x1f2bb
movb $0x1, -0x1(%rbp)
jmp 0x1f32e
... | /kinetiknz[P]cubeb/googletest/src/gtest.cc |
testing::TestResult::ValidateTestProperty(testing::TestProperty const&) | bool TestResult::ValidateTestProperty(const TestProperty& test_property) {
internal::String key(test_property.key());
if (key == "name" || key == "status" || key == "time" || key == "classname") {
ADD_FAILURE()
<< "Reserved key used in RecordProperty(): "
<< key
<< " ('name', 'status', '... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2ee80
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x2d060
movq -0x50(%rbp), %rdi
leaq 0x2588a(%rip), %rsi # 0x44f1d
callq 0x2f010
movb %al, -0x45(%rbp)
jmp 0x1f69d
movb -0x45(%rbp), %al
testb $0... | /kinetiknz[P]cubeb/googletest/src/gtest.cc |
testing::internal::ReportFailureInUnknownLocation(testing::TestPartResult::Type, testing::internal::String const&) | void ReportFailureInUnknownLocation(TestPartResult::Type result_type,
const String& message) {
// This function is a friend of UnitTest and as such has access to
// AddTestPartResult.
UnitTest::GetInstance()->AddTestPartResult(
result_type,
NULL, // No info about t... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x19980
movq %rax, -0x50(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x2d170
movq -0x50(%rbp), %rdi
movl -0x44(%rbp), %e... | /kinetiknz[P]cubeb/googletest/src/gtest.cc |
testing::Test::HasSameFixtureClass() | bool Test::HasSameFixtureClass() {
internal::UnitTestImpl* const impl = internal::GetUnitTestImpl();
const TestCase* const test_case = impl->current_test_case();
// Info about the first test in the current test case.
const TestInfo* const first_test_info = test_case->test_info_list()[0];
const internal::Type... | pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp # imm = 0x1B0
callq 0x2d4b0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2f5f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2f610
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2f630
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%r... | /kinetiknz[P]cubeb/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::os_stack_trace_getter() | OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() {
if (os_stack_trace_getter_ == NULL) {
os_stack_trace_getter_ = new OsStackTraceGetter;
}
return os_stack_trace_getter_;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x188(%rax)
jne 0x20371
movl $0x40, %edi
callq 0x64f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0x33040
jmp 0x20349
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, 0x188(... | /kinetiknz[P]cubeb/googletest/src/gtest.cc |
testing::TestInfo::TestInfo(char const*, char const*, char const*, char const*, void const*, testing::internal::TestFactoryBase*) | TestInfo::TestInfo(const char* a_test_case_name,
const char* a_name,
const char* a_type_param,
const char* a_value_param,
internal::TypeId fixture_class_id,
internal::TestFactoryBase* factory)
: test_case_name_(a_test_cas... | pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq ... | /kinetiknz[P]cubeb/googletest/src/gtest.cc |
testing::internal::ReportInvalidTestCaseType(char const*, char const*, int) | void ReportInvalidTestCaseType(const char* test_case_name,
const char* file, int line) {
Message errors;
errors
<< "Attempted redefinition of test case " << test_case_name << ".\n"
<< "All tests in the same test case must use the same test fixture\n"
<< "class. Howe... | pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x80e0
movq -0x70(%rbp), %rdi
leaq 0x2b6ab(%rip), %rsi # 0x4bf49
callq 0x2fe00
movq %rax, -0x68(%rbp)
jmp 0x208a9
movq -0x68(%rbp), %rdi
leaq -0x8(%rbp)... | /kinetiknz[P]cubeb/googletest/src/gtest.cc |
testing::internal::FormatFileLocation[abi:cxx11](char const*, int) | GTEST_API_ ::std::string FormatFileLocation(const char* file, int line) {
const char* const file_name = file == NULL ? kUnknownFile : file;
if (line < 0) {
return String::Format("%s:", file_name).c_str();
}
#ifdef _MSC_VER
return String::Format("%s(%d):", file_name, line).c_str();
#else
return String::Fo... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x20ae5
leaq 0x2a09c(%rip), %rax # 0x4ab7b
movq %rax, -0x70(%rbp)
jmp 0x20aed
movq -0x10(%rbp), %rax
movq %rax, -0x... | /kinetiknz[P]cubeb/googletest/src/gtest-port.cc |
testing::internal::PrintFullTestCommentIfPresent(testing::TestInfo const&) | void PrintFullTestCommentIfPresent(const TestInfo& test_info) {
const char* const type_param = test_info.type_param();
const char* const value_param = test_info.value_param();
if (type_param != NULL || value_param != NULL) {
printf(", where ");
if (type_param != NULL) {
printf("TypeParam = %s", typ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x309f0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x30a40
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x217a4
cmpq $0x0, -0x18(%rbp)
je 0x217fd
leaq 0x2a982(%rip), %rdi # 0x4c12d
movb $0x0, %al
callq 0x6070
... | /kinetiknz[P]cubeb/googletest/src/gtest.cc |
testing::internal::XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(testing::TestResult const&) | String XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes(
const TestResult& result) {
Message attributes;
for (int i = 0; i < result.test_property_count(); ++i) {
const TestProperty& property = result.GetTestProperty(i);
attributes << " " << property.key() << "="
<< "\"" << EscapeXmlAttrib... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x80e0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x64(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1f4b0
movl %eax, %ecx
movl -0x64(... | /kinetiknz[P]cubeb/googletest/src/gtest.cc |
bool testing::internal::ParseNaturalNumber<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int*) | bool ParseNaturalNumber(const ::std::string& str, Integer* number) {
// Fail fast if the given string does not begin with a digit;
// this bypasses strtoXXX's "optional leading whitespace and plus
// or minus sign" semantics, which are undesirable here.
if (str.empty() || !IsDigit(str[0])) {
return false;
... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x69e0
testb $0x1, %al
jne 0x347f6
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x6590
movsbl (%rax), %edi
callq 0x42df0
testb $0x1, %al
jne 0x347ff
movb $0x0, -0x1(%rbp)
jmp 0x348e5
ca... | /kinetiknz[P]cubeb/googletest/src/gtest-internal-inl.h |
QtMWidgets::BlurEffect::paintEvent(QPaintEvent*) | void
BlurEffect::paintEvent( QPaintEvent * )
{
QPainter p( this );
p.setRenderHint( QPainter::Antialiasing );
switch( policy )
{
case AbstractScrollArea::BlurAlwaysOff :
return;
case AbstractScrollArea::BlurHorizontalOnly :
{
if( orientation == Qt::Vertical )
drawBlur( &p, color );
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x38(%rbp)
addq $0x10, %rsi
leaq -0x18(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x98a80
movq -0x30(%rbp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x971e0
jmp 0xb4f5b
movq -0x38(%rbp), %rax
movl ... | /igormironchik[P]qtmwidgets/src/abstractscrollarea.cpp |
QtMWidgets::DateTimePicker::DateTimePicker(QVariant const&, QMetaType::Type, QWidget*) | DateTimePicker::DateTimePicker( const QVariant & val, QMetaType::Type parserType,
QWidget * parent )
: QWidget( parent )
, d( new DateTimePickerPrivate( this, parserType ) )
{
setSizePolicy( QSizePolicy( QSizePolicy::Fixed,
QSizePolicy::Fixed ) );
switch( val.metaType().id() )
{
case QMetaType::QDa... | pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp # imm = 0x140
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x100(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x108(%rbp)
leaq -0x24(%rbp), %rdi
callq 0x9a500
movq -0x108(%rbp), %rsi
movq ... | /igormironchik[P]qtmwidgets/src/datetimepicker.cpp |
QtMWidgets::FingerGeometry::longTouchBounce() | int
FingerGeometry::longTouchBounce()
{
static const int bounce = qRound(
(qreal) qMax( FingerGeometry::height(), FingerGeometry::width() ) * 0.6 );
return bounce;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
cmpb $0x0, 0x80799(%rip) # 0x145798
jne 0xc5078
leaq 0x80790(%rip), %rdi # 0x145798
callq 0x982c0
cmpl $0x0, %eax
je 0xc5078
callq 0xc4e40
movl %eax, -0x1c(%rbp)
jmp 0xc501c
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
callq 0xc4d50
movl %eax, -0x20(%rbp)
jmp 0xc502c
... | /igormironchik[P]qtmwidgets/src/fingergeometry.cpp |
QtMWidgets::TableViewCellLayout::sizeHint() const | QSize
TableViewCellLayout::sizeHint() const
{
const QSize imageSize = imageLabel->sizeHint();
int width = imageSize.width();
int height = imageSize.height();
const QSize textSize = textLabel->sizeHint();
const QSize detailedTextSize = detailedTextLabel->sizeHint();
width += qMax( textSize.width(), d... | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq 0x20(%rax), %rdi
movq (%rdi), %rax
callq *0x70(%rax)
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xb9860
movl %eax, -0x1c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xb9870
movl %eax, %ecx
movq -0xa0(%r... | /igormironchik[P]qtmwidgets/src/tableview.cpp |
QtMWidgets::MsgBoxTitlePrivate::init() | void
MsgBoxTitlePrivate::init()
{
q->setBackgroundRole( QPalette::Window );
q->setAutoFillBackground( true );
q->setSizePolicy( QSizePolicy::Expanding, QSizePolicy::Fixed );
q->setMinimumHeight( qMax( FingerGeometry::height(),
q->fontMetrics().height() + q->fontMetrics().height() / 3 ) );
prepareTitle(... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq (%rax), %rdi
movl $0xa, %esi
callq 0x98360
movq -0x48(%rbp), %rax
movq (%rax), %rdi
movl $0x1, %esi
callq 0x98160
movq -0x48(%rbp), %rax
movq (%rax), %rdi
movl $0x7, %esi
xorl %edx, %edx
callq 0xb97b0
mov... | /igormironchik[P]qtmwidgets/src/messagebox.cpp |
QtMWidgets::MessageBoxPrivate::init(QString const&, QString const&) | void
MessageBoxPrivate::init( const QString & titl, const QString & txt )
{
q->setModal( true );
QVBoxLayout * layout = new QVBoxLayout( q );
layout->setContentsMargins( 0, 0, 0, 0 );
frame = new QFrame( q );
frame->setFrameStyle( QFrame::Box | QFrame::Plain );
layout->addWidget( frame );
vbox = n... | pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq (%rax), %rdi
movl $0x1, %esi
callq 0x97820
movl $0x20, %edi
callq 0x980d0
movq %rax, %rdi
movq -0xa8(%rbp), %rax
movq %rdi, %rcx
mov... | /igormironchik[P]qtmwidgets/src/messagebox.cpp |
QtMWidgets::ToolBar::_q_rightArrowClicked() | void
ToolBar::_q_rightArrowClicked()
{
int delta = 0;
if( d->layout->orientation() == Qt::Horizontal )
delta = d->iconSize.width() + d->layout->spacing();
else
delta = d->iconSize.height() + d->layout->spacing();
d->layout->setOffset( delta );
update();
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
addq $0x28, %rdi
callq 0xebc90
movq 0x10(%rax), %rdi
callq 0xe8f60
cmpl $0x1, %eax
jne 0xeab21
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0xebc90
movq %rax, %rdi
addq $0x8, %rdi
callq ... | /igormironchik[P]qtmwidgets/src/toolbar.cpp |
QtMWidgets::SwitchPrivate::drawText(QPainter*, QStyleOption const&, QColor const&, QColor const&) | void
SwitchPrivate::drawText( QPainter * p, const QStyleOption & opt,
const QColor & on, const QColor & off )
{
const QRect r( radius, 0, opt.rect.width() - radius * 2, radius * 2 );
switch( state )
{
case Switch::NotAcceptedCheck :
case Switch::AcceptedCheck :
{
if( !onText.isEmpty() )
{
... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl 0x50(%rax), %eax
movl %eax, -0x54(%rbp)
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0xb1a10
movl -0x54(%rbp), %... | /igormironchik[P]qtmwidgets/src/switch.cpp |
QtMWidgets::Switch::mouseMoveEvent(QMouseEvent*) | void
Switch::mouseMoveEvent( QMouseEvent * event )
{
if( d->leftMouseButtonPressed )
{
const int delta = event->pos().x() - d->mousePos.x();
d->offset += delta;
d->mouseMoveDelta += qAbs( delta );
d->mousePos = event->pos();
if( d->offset < 0 )
d->offset = 0;
else if( d->offset > rect().wi... | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x28, %rdi
callq 0xef3d0
testb $0x1, 0x60(%rax)
je 0xef2a2
movq -0x10(%rbp), %rdi
callq 0xb4490
movq %rax, -0x1c(%rbp)
leaq -0x1c(%rbp), %rdi
callq 0xb2350
movq -0x50(%rbp), %rdi
m... | /igormironchik[P]qtmwidgets/src/switch.cpp |
QtMWidgets::Picker::setModel(QAbstractItemModel*) | void
Picker::setModel( QAbstractItemModel * model )
{
if( !model )
{
qWarning( "QtMWidgets::Picker::setModel: cannot set a 0 model" );
return;
}
if( d->model )
{
disconnect( d->model, &QAbstractItemModel::dataChanged,
this, &Picker::_q_dataChanged );
disconnect( d->model, &QAbstractItemMod... | pushq %rbp
movq %rsp, %rbp
subq $0x3a0, %rsp # imm = 0x3A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x300(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xef6fe
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
xorl %edx, %edx
movq %rcx, %rsi
callq 0x9aa30
leaq -0x30(%rbp), %rdi
... | /igormironchik[P]qtmwidgets/src/picker.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.