name string | code string | asm string | file string |
|---|---|---|---|
testing::internal::JsonUnitTestResultPrinter::OnTestIterationEnd(testing::UnitTest const&, int) | void JsonUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test,
int /*iteration*/) {
FILE* jsonout = OpenFileForWriting(output_file_);
std::stringstream stream;
PrintJsonUnitTest(&stream, unit_test);
fprintf(jsonout, "%s", StringStreamToString(&str... | pushq %r14
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rsi, %r14
addq $0x8, %rdi
callq 0x185a0
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x8320
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x1ccd2
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
callq 0x10df9
leaq 0x10(%rsp), %r14
movq -0x10(%r14), %rdi
movq %rbx... | /mlutken[P]nestle/testing/googletest/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::OutputJsonKey(std::ostream*, 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&, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allo... | void JsonUnitTestResultPrinter::OutputJsonKey(
std::ostream* stream,
const std::string& element_name,
const std::string& name,
int value,
const std::string& indent,
bool comma) {
const std::vector<std::string>& allowed_names =
GetReservedOutputAttributesForElement(element_name);
GTEST... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %r9d, %ebp
movq %r8, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movl %ecx, 0xc(%rsp)
leaq 0x30(%rsp), %r13
movq %r13, %rdi
callq 0x1a3da
movq (%r13), %rdi
movq 0x8(%r13), %rsi
movq %r14, %rdx
callq 0x37804
cmpq 0x38(%rsp),... | /mlutken[P]nestle/testing/googletest/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::PrintJsonTestList(std::ostream*, std::vector<testing::TestSuite*, std::allocator<testing::TestSuite*>> const&) | void JsonUnitTestResultPrinter::PrintJsonTestList(
std::ostream* stream, const std::vector<TestSuite*>& test_suites) {
const std::string kTestsuites = "testsuites";
const std::string kIndent = Indent(2);
*stream << "{\n";
int total_tests = 0;
for (auto test_suite : test_suites) {
total_tests += test_s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x58(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x1aee3(%rip), %rsi # 0x3b8d4
leaq 0x1aee6(%rip), %rdx # 0x3b8de
leaq 0x48(%rsp), %rdi
callq 0x35a94
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
l... | /mlutken[P]nestle/testing/googletest/googletest/src/gtest.cc |
testing::UnitTest::Run() | int UnitTest::Run() {
const bool in_death_test_child_process =
GTEST_FLAG_GET(internal_run_death_test).length() > 0;
// Google Test implements this protocol for catching that a test
// program exits before returning control to Google Test:
//
// 1. Upon start, Google Test creates a file whose absolut... | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x2f202(%rip) # 0x506f8
je 0x214fc
xorl %esi, %esi
jmp 0x2150b
leaq 0x1a5f1(%rip), %rdi # 0x3baf4
callq 0x8650
movq %rax, %rsi
movq %rsp, %rdi
callq 0x30bde
movq 0x40(%rbx), %rdi
movb 0x2f098(%rip), %al # 0x505b5
movb %al, 0x258(%rdi)
leaq 0x36(%rip), ... | /mlutken[P]nestle/testing/googletest/googletest/src/gtest.cc |
testing::UnitTest::current_test_info() const | GTEST_LOCK_EXCLUDED_(mutex_) {
internal::MutexLock lock(&mutex_);
return impl_->current_test_info();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x330de
movq 0x40(%rbx), %rax
movq 0x170(%rax), %rbx
movq %r14, %rdi
callq 0x3317c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0xbd33
nop
| /mlutken[P]nestle/testing/googletest/googletest/src/gtest.cc |
testing::KilledBySignal::operator()(int) const | bool KilledBySignal::operator()(int exit_status) const {
# if defined(GTEST_KILLED_BY_SIGNAL_OVERRIDE_)
{
bool result;
if (GTEST_KILLED_BY_SIGNAL_OVERRIDE_(signum_, exit_status, &result)) {
return result;
}
}
# endif // defined(GTEST_KILLED_BY_SIGNAL_OVERRIDE_)
return WIFSIGNALED(exit_status)... | andl $0x7f, %esi
movl %esi, %eax
shll $0x18, %eax
addl $0x1000000, %eax # imm = 0x1000000
cmpl $0x2000000, %eax # imm = 0x2000000
setge %cl
cmpl (%rdi), %esi
sete %al
andb %cl, %al
retq
| /mlutken[P]nestle/testing/googletest/googletest/src/gtest-death-test.cc |
testing::internal::DeathTest::Create(char const*, testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>, char const*, int, testing::internal::DeathTest**) | bool DeathTest::Create(const char* statement,
Matcher<const std::string&> matcher, const char* file,
int line, DeathTest** test) {
return GetUnitTestImpl()->death_test_factory()->Create(
statement, std::move(matcher), file, line, test);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %r8, %rbx
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0xcc86
movq 0x2cc24(%rip), %rax # 0x506e0
movq 0x240(%rax), %rdi
movq 0x8(%r15), %rax
leaq 0x8(%rsp), %rdx
movq %rax, 0x8(%rdx)
movq 0x10(%r15), %rax
movq %rax... | /mlutken[P]nestle/testing/googletest/googletest/src/gtest-death-test.cc |
testing::internal::FormatDeathTestOutput(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static ::std::string FormatDeathTestOutput(const ::std::string& output) {
::std::string ret;
for (size_t at = 0; ; ) {
const size_t line_end = output.find('\n', at);
ret += "[ DEATH ] ";
if (line_end == ::std::string::npos) {
ret += output.substr(at);
break;
}
ret += output.substr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x20(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorl %ebp, %ebp
leaq 0x17d28(%rip), %r15 # 0x3cb74
movq %rsp, %r12
movq %r14, %rdi
movl $0xa, %e... | /mlutken[P]nestle/testing/googletest/googletest/src/gtest-death-test.cc |
testing::internal::FilePath::RemoveFileName() const | FilePath FilePath::RemoveFileName() const {
const char* const last_sep = FindLastPathSeparator();
std::string dir;
if (last_sep) {
dir = std::string(c_str(), static_cast<size_t>(last_sep + 1 - c_str()));
} else {
dir = kCurrentDirectoryString;
}
return FilePath(dir);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq (%rsi), %r14
movq %r14, %rdi
movl $0x2f, %esi
callq 0x8540
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
testq %rax, %rax
je 0x2a016
incq %rax
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x28(%... | /mlutken[P]nestle/testing/googletest/googletest/src/gtest-filepath.cc |
testing::Matcher<std::basic_string_view<char, std::char_traits<char>>>::Matcher(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Matcher<internal::StringView>::Matcher(const std::string& s) { *this = Eq(s); } | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq $0x0, 0x8(%rdi)
leaq 0x249e5(%rip), %r14 # 0x4f818
movq %r14, (%rdi)
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0xbc9e
leaq 0x10(%rsp... | /mlutken[P]nestle/testing/googletest/googletest/src/gtest-matchers.cc |
testing::Matcher<std::basic_string_view<char, std::char_traits<char>>>::Matcher(std::basic_string_view<char, std::char_traits<char>>) | Matcher<internal::StringView>::Matcher(internal::StringView s) {
*this = Eq(std::string(s));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
movq $0x0, 0x8(%rdi)
leaq 0x246f3(%rip), %r14 # 0x4f818
movq %r14, (%rdi)
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq (%rsi,%rdx), %rax
leaq 0x20(%rsp), %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x35a94
leaq 0x10(%rsp), %r12
movq %r... | /mlutken[P]nestle/testing/googletest/googletest/src/gtest-matchers.cc |
testing::internal::RE::Init(char const*) | void RE::Init(const char* regex) {
pattern_ = posix::StrDup(regex);
// Reserves enough bytes to hold the regular expression used for a
// full match.
const size_t full_regex_len = strlen(regex) + 10;
char* const full_pattern = new char[full_regex_len];
snprintf(full_pattern, full_regex_len, "^(%s)$", rege... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r12
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x89d0
movq %rax, (%rbx)
movq %r12, %rdi
callq 0x81e0
leaq 0xa(%rax), %r15
movq %r15, %rdi
callq 0x8040
movq %rax, %r14
leaq 0x10ed7(%rip), %rdx # 0x3c227
movq %rax, %rdi
movq %r15, %rsi
mov... | /mlutken[P]nestle/testing/googletest/googletest/src/gtest-port.cc |
testing::internal::GTestLog::GTestLog(testing::internal::GTestLogSeverity, char const*, int) | GTestLog::GTestLog(GTestLogSeverity severity, const char* file, int line)
: severity_(severity) {
const char* const marker =
severity == GTEST_INFO ? "[ INFO ]" :
severity == GTEST_WARNING ? "[WARNING]" :
severity == GTEST_ERROR ? "[ ERROR ]" : "[ FATAL ]";
GetStream() << ::std::endl << ... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movl %esi, (%rdi)
cmpl $0x2, %esi
leaq 0x10dbc(%rip), %rax # 0x3c30d
leaq 0x10dbf(%rip), %rcx # 0x3c317
cmoveq %rax, %rcx
cmpl $0x1, %esi
leaq 0x10d9d(%rip), %rax # 0x3c303
cmovneq %rcx, %rax
testl %esi, %esi
leaq 0... | /mlutken[P]nestle/testing/googletest/googletest/src/gtest-port.cc |
testing::internal::CaptureStream(int, char const*, testing::internal::CapturedStream**) | static void CaptureStream(int fd, const char* stream_name,
CapturedStream** stream) {
if (*stream != nullptr) {
GTEST_LOG_(FATAL) << "Only one " << stream_name
<< " capturer can exist at a time.";
}
*stream = new CapturedStream(fd);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %edi, %ebp
cmpq $0x0, (%rdx)
je 0x2b78d
movq %rsi, %r14
leaq 0x10b74(%rip), %rdx # 0x3c277
leaq 0x4(%rsp), %rdi
movl $0x3, %esi
movl $0x4b0, %ecx # imm = 0x4B0
callq 0x2b536
movq 0x248ca(%rip), %r15 # 0x4ffe8
leaq 0x1177c(%ri... | /mlutken[P]nestle/testing/googletest/googletest/src/gtest-port.cc |
testing::internal::FlagToEnvVar[abi:cxx11](char const*) | static std::string FlagToEnvVar(const char* flag) {
const std::string full_flag =
(Message() << GTEST_FLAG_PREFIX_ << flag).GetString();
Message env_var;
for (size_t i = 0; i != full_flag.length(); i++) {
env_var << ToUpper(full_flag.c_str()[i]);
}
return env_var.GetString();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x10b90
movq (%r14), %r14
leaq 0x10(%r14), %r12
leaq 0x10781(%rip), %rsi # 0x3c163
movl $0x6, %r13d
movl $0x6, %edx
movq %r12, %rdi
callq 0x8590
testq %r15, %r15
je 0x2b... | /mlutken[P]nestle/testing/googletest/googletest/src/gtest-port.cc |
testing::internal::CharFormat testing::internal::PrintCharsAsStringTo<char32_t>(char32_t const*, unsigned long, std::ostream*) | static CharFormat PrintCharsAsStringTo(
const CharType* begin, size_t len, ostream* os) {
const char* const quote_prefix = GetCharWidthPrefix(*begin);
*os << quote_prefix << "\"";
bool is_previous_hex = false;
CharFormat print_format = kAsIs;
for (size_t index = 0; index < len; ++index) {
const CharTy... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x10fd1(%rip), %rsi # 0x3d2bb
movl $0x1, %edx
movq %rbx, %rdi
callq 0x8590
leaq 0xf6f4(%rip), %rsi # 0x3b9f2
movl $0x1, %edx
movq %rbx, %rdi
callq 0x8590
testq %r14, %r14
je 0x2c38e... | /mlutken[P]nestle/testing/googletest/googletest/src/gtest-printers.cc |
testing::TestPartResultArray::GetTestPartResult(int) const | const TestPartResult& TestPartResultArray::GetTestPartResult(int index) const {
if (index < 0 || index >= size()) {
printf("\nInvalid index (%d) into TestPartResultArray.\n", index);
internal::posix::Abort();
}
return array_[static_cast<size_t>(index)];
} | testl %esi, %esi
js 0x2c676
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
shrq $0x4, %rcx
imull $0xb6db6db7, %ecx, %ecx # imm = 0xB6DB6DB7
cmpl %esi, %ecx
jle 0x2c676
movl %esi, %ecx
imulq $0x70, %rcx, %rcx
addq %rcx, %rax
retq
pushq %rax
leaq 0xfd9b(%rip), %rdi # 0x3c419
xorl %eax, %eax
callq 0x8080
call... | /mlutken[P]nestle/testing/googletest/googletest/src/gtest-test-part.cc |
testing::AssertionResult& testing::AssertionResult::operator<<<char [24]>(char const (&) [24]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x10b90
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x81e0
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x8590
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3303e
movq 0x8(%r... | /mlutken[P]nestle/testing/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult& testing::AssertionResult::operator<<<char [6]>(char const (&) [6]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x10b90
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x81e0
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x8590
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3303e
movq 0x8(%r... | /mlutken[P]nestle/testing/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult& testing::AssertionResult::operator<<<double>(double const&) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x10b90
movq (%r15), %rdi
addq $0x10, %rdi
movsd (%r14), %xmm0
callq 0x88d0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3303e
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2f098
movq (%rdi), %rax
c... | /mlutken[P]nestle/testing/googletest/googletest/include/gtest/gtest.h |
testing::internal::FloatingPoint<double>::AlmostEquals(testing::internal::FloatingPoint<double> const&) const | bool AlmostEquals(const FloatingPoint& rhs) const {
// The IEEE standard says that any comparison operation involving
// a NAN must return false.
if (is_nan() || rhs.is_nan()) return false;
return DistanceBetweenSignAndMagnitudeNumbers(u_.bits_, rhs.u_.bits_)
<= kMaxUlps;
} | 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 0x36e3a
movabsq $0xfffffffffffff, %rdi # imm = 0xFFFFFFFFFFFFF
movq (%rsi), %rcx
movq %rcx, %rsi
notq %rsi
testq %rsi, %rdx
s... | /mlutken[P]nestle/testing/googletest/googletest/include/gtest/internal/gtest-internal.h |
testing::AssertionResult& testing::AssertionResult::operator<<<std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>>(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x10b90
movq %r15, %rdi
movq %r14, %rsi
callq 0x10d06
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x3303e
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x36fae
movq (%rdi), %rax
callq *0x8(%rax)
movq %... | /mlutken[P]nestle/testing/googletest/googletest/include/gtest/gtest.h |
testing::MatcherDescriberInterface const* testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::GetDescriberImpl<testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::ValuePolicy<testing::in... | static const MatcherDescriberInterface* GetDescriberImpl(
const MatcherBase& m) {
// If the impl is a MatcherDescriberInterface, then return it.
// Otherwise use MatcherBase itself.
// This allows us to implement the GetDescriber() function without support
// from the impl, but some users really w... | movq %rdi, %rax
retq
| /mlutken[P]nestle/testing/googletest/googletest/include/gtest/gtest-matchers.h |
testing::MatcherDescriberInterface const* testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char>>>::GetDescriberImpl<testing::internal::MatcherBase<std::basic_string_view<char, std::char_traits<char>>>::ValuePolicy<testing::internal::EqMatcher<std::__cxx11::basic_string<char, std::char_trait... | static const MatcherDescriberInterface* GetDescriberImpl(
const MatcherBase& m) {
// If the impl is a MatcherDescriberInterface, then return it.
// Otherwise use MatcherBase itself.
// This allows us to implement the GetDescriber() function without support
// from the impl, but some users really w... | movq %rdi, %rax
retq
| /mlutken[P]nestle/testing/googletest/googletest/include/gtest/gtest-matchers.h |
testing::internal::ExecDeathTest::AssumeRole() (.cold.1) | static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) {
ExecDeathTestArgs args = {argv, close_fd};
pid_t child_pid = -1;
#ifdef GTEST_OS_QNX
// Obtains the current directory and sets it to be closed in the child
// process.
const int cwd_fd = open(".", O_RDONLY);
GTEST_DEATH_TEST_CHECK_(cwd... | pushq %rbx
subq $0x10, %rsp
leaq 0x53b47(%rip), %rdi # 0x5b7d0
callq 0x7a30
testl %eax, %eax
je 0x7cb8
leaq 0xc(%rsp), %rdi
leaq 0xb(%rsp), %rbx
movq %rbx, %rsi
callq 0x34b92
movb (%rbx), %al
movb %al, 0x53b1c(%rip) # 0x5b7c8
leaq 0x53b1d(%rip), %rdi # 0x5b7d0
callq 0x7310
addq $0x10, %rsp
popq %rbx
retq
| /todo-group[P]exact/build_O3/_deps/googletest-src/googletest/src/gtest-death-test.cc |
ising::dos::square::count(unsigned long, unsigned long) | std::vector<uint_t> count(uint_t Lx, uint_t Ly) {
auto basis = lattice::basis::simple(2);
auto unitcell = lattice::unitcell(2);
unitcell.add_site(lattice::coordinate(0, 0), 0);
unitcell.add_bond(0, 0, lattice::offset(1, 0), 0);
unitcell.add_bond(0, 0, lattice::offset(0, 1), 0);
auto graph = lattice::graph(b... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x88(%rsp), %rdi
movl $0x2, %esi
callq 0x8fb2
leaq 0xa8(%rsp), %rax
movq $0x2, -0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
mova... | /todo-group[P]exact/ising/dos/square.hpp |
testing::internal::SuiteApiResolver<testing::Test>::GetSetUpCaseOrSuite(char const*, int) | static SetUpTearDownSuiteFuncType GetSetUpCaseOrSuite(const char* filename,
int line_num) {
#ifndef GTEST_REMOVE_LEGACY_TEST_CASEAPI_
SetUpTearDownSuiteFuncType test_case_fp =
GetNotDefaultOrNull(&T::SetUpTestCase, &Test::SetUpTestCase);
SetUpTearD... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x1, %edi
callq 0x16534
testb %al, %al
jne 0x9601
leaq 0x38ff3(%rip), %rdx # 0x42544
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x201, %ecx # imm = 0x201
callq 0x1b774
movq 0x51a7c(%rip), %rdi # 0x5afe8
leaq 0x390... | /todo-group[P]exact/build_O3/_deps/googletest-src/googletest/include/gtest/internal/gtest-internal.h |
ising_dos_square_count_Test::~ising_dos_square_count_Test() | TEST(ising_dos_square, count) {
auto dos = ising::dos::square::count(4, 4);
EXPECT_EQ(33, dos.size());
EXPECT_EQ(2, dos[0]);
EXPECT_EQ(0, dos[2]);
EXPECT_EQ(32, dos[4]);
EXPECT_EQ(64, dos[6]);
EXPECT_EQ(20524, dos[16]);
EXPECT_EQ(2, dos[32]);
} | pushq %rbx
movq %rdi, %rbx
callq 0x24c46
movl $0x10, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x74f0
nop
| /todo-group[P]exact/ising/dos/square_count_gt.cpp |
lattice::graph::add_bond(unsigned long, unsigned long, int) | std::size_t add_bond(std::size_t s, std::size_t t, int tp) {
if (s >= sites_.size() || t >= sites_.size())
throw std::invalid_argument("site index out of range");
if (s == t)
throw std::invalid_argument("self loop is not allowed");
std::size_t b = bonds_.size();
bonds_.push_back(bond_t(s, t,... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rdi), %rdx
subq 0x8(%rdi), %rdx
sarq $0x3, %rdx
movabsq $0x6db6db6db6db6db7, %rax # imm = 0x6DB6DB6DB6DB6DB7
imulq %rdx, %rax
cmpq %rsi, %rax
jbe 0xacc9
cmpq %r14, %rax
jbe 0xacc9
movq %rs... | /todo-group[P]exact/build_O3/_deps/lattice-src/lattice/graph.hpp |
testing::internal::DeathTestImpl::Abort(testing::internal::DeathTest::AbortReason) | void DeathTestImpl::Abort(AbortReason reason) {
// The parent process considers the death test to be a failure if
// it finds any data in our pipe. So, here we write a single flag byte
// to the pipe, then exit.
const char status_ch = reason == TEST_DID_NOT_DIE ? kDeathTestLived
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rdi, %rbx
cmpl $0x1, %esi
sete %al
addb %al, %al
addb $0x52, %al
cmpl $0x2, %esi
movzbl %al, %eax
movl $0x4c, %ecx
cmovnel %eax, %ecx
leaq 0xf(%rsp), %r14
movb %cl, (%r14)
movl 0x38(%rbx), %edi
movl $0x1, ... | /todo-group[P]exact/build_O3/_deps/googletest-src/googletest/src/gtest-death-test.cc |
testing::internal::PrintAsStringLiteralTo(char32_t, std::ostream*) | static CharFormat PrintAsStringLiteralTo(char32_t c, ostream* os) {
switch (c) {
case L'\'':
*os << "'";
return kAsIs;
case L'"':
*os << "\\\"";
return kSpecialEscape;
default:
return PrintAsCharLiteralTo(c, os);
}
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movl %edi, %r14d
cmpl $0x21, %edi
jg 0x34e66
cmpl $0xd, %r14d
ja 0x34eeb
movl %r14d, %eax
leaq 0xde34(%rip), %rcx # 0x42c88
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xfde3(%rip), %rsi # 0x44c47
jmp 0x34ed0
cmpl $0x22, %r14d
je... | /todo-group[P]exact/build_O3/_deps/googletest-src/googletest/src/gtest-printers.cc |
void testing::internal::PrintCharAndCodeTo<unsigned char>(unsigned char, std::ostream*) | void PrintCharAndCodeTo(Char c, ostream* os) {
// First, print c as a literal in the most readable form we can find.
*os << GetCharWidthPrefix(c) << "'";
const CharFormat format = PrintAsCharLiteralTo(c, os);
*os << "'";
// To aid user debugging, we also print c's code in decimal, unless
// it's 0 (in whic... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0xe31e(%rip), %rsi # 0x45219
movq %rbx, %rdi
xorl %edx, %edx
callq 0x75c0
leaq 0xd8d8(%rip), %rsi # 0x447e4
movl $0x1, %edx
movq %rbx, %rdi
callq 0x75c0
cmpl $0xd, %ebp
ja 0x36f60
movl %ebp, %eax
leaq 0xce19(%rip), %rcx ... | /todo-group[P]exact/build_O3/_deps/googletest-src/googletest/src/gtest-printers.cc |
void testing::internal::PrintCharAndCodeTo<signed char>(signed char, std::ostream*) | void PrintCharAndCodeTo(Char c, ostream* os) {
// First, print c as a literal in the most readable form we can find.
*os << GetCharWidthPrefix(c) << "'";
const CharFormat format = PrintAsCharLiteralTo(c, os);
*os << "'";
// To aid user debugging, we also print c's code in decimal, unless
// it's 0 (in whic... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0xe0bd(%rip), %rsi # 0x45219
movq %rbx, %rdi
xorl %edx, %edx
callq 0x75c0
leaq 0xd677(%rip), %rsi # 0x447e4
movl $0x1, %edx
movq %rbx, %rdi
callq 0x75c0
movzbl %bpl, %r14d
cmpl $0xd, %ebp
ja 0x371c7
movl %ebp, %e... | /todo-group[P]exact/build_O3/_deps/googletest-src/googletest/src/gtest-printers.cc |
void testing::internal::PrintCharAndCodeTo<wchar_t>(wchar_t, std::ostream*) | void PrintCharAndCodeTo(Char c, ostream* os) {
// First, print c as a literal in the most readable form we can find.
*os << GetCharWidthPrefix(c) << "'";
const CharFormat format = PrintAsCharLiteralTo(c, os);
*os << "'";
// To aid user debugging, we also print c's code in decimal, unless
// it's 0 (in whic... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movl %edi, %r14d
leaq 0xf144(%rip), %rsi # 0x46514
movl $0x1, %edx
movq %rbx, %rdi
callq 0x75c0
leaq 0xd400(%rip), %rsi # 0x447e4
movl $0x1, %edx
movq %rbx, %rdi
callq 0x75c0
cmpl $0xd, %r14d
ja 0x3743c
movl %r14d, %eax
leaq 0xc9af(%... | /todo-group[P]exact/build_O3/_deps/googletest-src/googletest/src/gtest-printers.cc |
void testing::internal::HandleExceptionsInMethodIfSupported<testing::TestSuite, void>(testing::TestSuite*, void (testing::TestSuite::*)(), char const*) | Result HandleExceptionsInMethodIfSupported(T* object, Result (T::*method)(),
const char* location) {
// NOTE: The user code can affect the way in which Google Test handles
// exceptions by setting GTEST_FLAG(catch_exceptions), but only before
// RUN_ALL_TESTS() starts. I... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
callq 0x1d890
movq 0x223de(%rip), %rax # 0x5b7b8
addq %r15, %r14
cmpb $0x1, 0x2c8(%rax)
jne 0x39406
testb $0x1, %r12b
je 0x393f4
movq (%r14), %rax
movq -0x1(%rax,%r12), %r12
movq %r14, %rdi
c... | /todo-group[P]exact/build_O3/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::Passed() const | bool Passed() const { return !Failed(); } | pushq %rbx
movq %rdi, %rbx
callq 0x21020
testl %eax, %eax
jle 0x395cf
xorl %eax, %eax
jmp 0x395e0
addq $0x1e8, %rbx # imm = 0x1E8
movq %rbx, %rdi
callq 0x24b50
xorb $0x1, %al
popq %rbx
retq
| /todo-group[P]exact/build_O3/_deps/googletest-src/googletest/src/gtest-internal-inl.h |
testing::internal::ScopedPrematureExitFile::ScopedPrematureExitFile(char const*) | explicit ScopedPrematureExitFile(const char* premature_exit_filepath)
: premature_exit_filepath_(
premature_exit_filepath ? premature_exit_filepath : "") {
// If a path to the premature-exit file is specified...
if (!premature_exit_filepath_.empty()) {
// create the file with a single "0... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
leaq 0xbb89(%rip), %rax # 0x45219
cmoveq %rax, %r14
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq %r14, %rdi
callq 0x7210
leaq (%rax,%r14), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3dff4
cmpq $0x0, 0x8(%rbx)
je 0x396e7
movq (%rbx)... | /todo-group[P]exact/build_O3/_deps/googletest-src/googletest/src/gtest.cc |
bool testing::internal::HandleExceptionsInMethodIfSupported<testing::internal::UnitTestImpl, bool>(testing::internal::UnitTestImpl*, bool (testing::internal::UnitTestImpl::*)(), char const*) | Result HandleExceptionsInMethodIfSupported(T* object, Result (T::*method)(),
const char* location) {
// NOTE: The user code can affect the way in which Google Test handles
// exceptions by setting GTEST_FLAG(catch_exceptions), but only before
// RUN_ALL_TESTS() starts. I... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
callq 0x1d890
movq 0x220a6(%rip), %rax # 0x5b7b8
addq %r15, %r14
cmpb $0x1, 0x2c8(%rax)
jne 0x3973e
testb $0x1, %r12b
je 0x3972c
movq (%r14), %rax
movq -0x1(%rax,%r12), %r12
movq %r14, %rdi
c... | /todo-group[P]exact/build_O3/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::ScopedPrematureExitFile::~ScopedPrematureExitFile() | ~ScopedPrematureExitFile() {
#ifndef GTEST_OS_ESP8266
if (!premature_exit_filepath_.empty()) {
int retval = remove(premature_exit_filepath_.c_str());
if (retval) {
GTEST_LOG_(ERROR) << "Failed to remove premature exit filepath \""
<< premature_exit_filepath_ << "\" with... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x398f9
movq (%rbx), %rdi
callq 0x7a10
testl %eax, %eax
je 0x398f9
movl %eax, %ebp
leaq 0xad89(%rip), %rdx # 0x44618
leaq 0xc(%rsp), %rdi
movl $0x2, %esi
movl $0x13ef, %ecx # imm = 0x13EF
callq 0x1b774
movq 0x2173e(... | /todo-group[P]exact/build_O3/_deps/googletest-src/googletest/src/gtest.cc |
testing::internal::ParameterizedTestSuiteRegistry::~ParameterizedTestSuiteRegistry() | ~ParameterizedTestSuiteRegistry() {
for (auto& test_suite_info : test_suite_infos_) {
delete test_suite_info;
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %r15
cmpq %r15, %r14
je 0x39a82
movq (%r14), %rdi
testq %rdi, %rdi
je 0x39a7c
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0x39a69
leaq 0x18(%rbx), %rdi
callq 0x3c50a
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x39aa4
movq 0x10(%rbx... | /todo-group[P]exact/build_O3/_deps/googletest-src/googletest/include/gtest/internal/gtest-param-util.h |
testing::internal::ThreadLocal<testing::TestPartResultReporterInterface*>::~ThreadLocal() | ~ThreadLocal() {
// Destroys the managed object for the current thread, if any.
DeleteThreadLocalValue(pthread_getspecific(key_));
// Releases resources associated with the key. This will *not*
// delete managed objects for other threads.
GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_));
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %edi
callq 0x7890
testq %rax, %rax
je 0x39ac5
movq (%rax), %rcx
movq %rax, %rdi
callq *0x8(%rcx)
movl (%rbx), %edi
callq 0x7630
testl %eax, %eax
je 0x39b35
movl %eax, %ebp
leaq 0xc3ec(%rip), %rdx # 0x45ec5
leaq 0x4(%rsp), %rdi
movl $0x3, %esi
movl $0x71... | /todo-group[P]exact/build_O3/_deps/googletest-src/googletest/include/gtest/internal/gtest-port.h |
testing::internal::StreamingListener::StreamingListener(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | StreamingListener(const std::string& host, const std::string& port)
: socket_writer_(new SocketWriter(host, port)) {
Start();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x20ee2(%rip), %rax # 0x5aa58
movq %rax, (%rdi)
movl $0x50, %edi
callq 0x74c0
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x3c646
movq %r15, 0x8(%rbx)
movq %rbx, %rdi
callq 0x3c6f8
a... | /todo-group[P]exact/build_O3/_deps/googletest-src/googletest/src/gtest-internal-inl.h |
testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::operator=(testing::internal::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&&) | MatcherBase& operator=(MatcherBase&& other) {
if (this == &other) return *this;
Destroy();
vtable_ = other.vtable_;
buffer_ = other.buffer_;
other.vtable_ = nullptr;
return *this;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x3acff
movq %rsi, %r14
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x3ace7
cmpq $0x0, 0x18(%rax)
je 0x3ace7
movq 0x10(%rbx), %rax
lock
decl (%rax)
jne 0x3ace7
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rdi
callq *0x18(%rax)
movq 0x8(%r14), %rax
movq %rax, 0x... | /todo-group[P]exact/build_O3/_deps/googletest-src/googletest/include/gtest/gtest-matchers.h |
testing::internal::MutexBase::Unlock() | void Unlock() {
// Since the lock is being released the owner_ field should no longer be
// considered valid. We don't protect writing to has_owner_ here, as it's
// the caller's responsibility to ensure that the current thread holds the
// mutex when this is called.
has_owner_ = false;
GTEST_CH... | pushq %rbx
subq $0x10, %rsp
movb $0x0, 0x28(%rdi)
callq 0x73c0
testl %eax, %eax
je 0x3bcdf
movl %eax, %ebx
leaq 0xa242(%rip), %rdx # 0x45ec5
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x6a6, %ecx # imm = 0x6A6
callq 0x1b774
movq 0x1f34a(%rip), %rdi # 0x5afe8
leaq 0xa2e6(%rip), %rsi # 0x45f8b
mo... | /todo-group[P]exact/build_O3/_deps/googletest-src/googletest/include/gtest/internal/gtest-port.h |
testing::TestSuite::Passed() const | bool Failed() const {
return failed_test_count() > 0 || ad_hoc_test_result().Failed();
} | pushq %rbx
movq %rdi, %rbx
callq 0x2123e
testl %eax, %eax
jle 0x3bd0b
xorl %eax, %eax
jmp 0x3bd1c
addq $0x88, %rbx
movq %rbx, %rdi
callq 0x24b50
xorb $0x1, %al
popq %rbx
retq
| /todo-group[P]exact/build_O3/_deps/googletest-src/googletest/include/gtest/gtest.h |
testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::GetOrCreateValue() const | T* GetOrCreateValue() const {
ThreadLocalValueHolderBase* const holder =
static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_));
if (holder != nullptr) {
return CheckedDowncastToActualType<ValueHolder>(holder)->pointer();
}
ValueHolder* const new_holder = default_factory_->Ma... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movl (%rdi), %edi
callq 0x7890
testq %rax, %rax
je 0x3c34d
movq %rax, %rdi
callq 0x3c3f3
movq %rax, %rbx
jmp 0x3c3ce
movq 0x8(%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rbx
movl (%r14), %edi
movq %rax, %rsi
callq 0x70f0
testl %eax, %eax
... | /todo-group[P]exact/build_O3/_deps/googletest-src/googletest/include/gtest/internal/gtest-port.h |
testing::internal::StreamingListener::OnTestIterationEnd(testing::UnitTest const&, int) | void OnTestIterationEnd(const UnitTest& unit_test,
int /* iteration */) override {
SendLn("event=TestIterationEnd&passed=" + FormatBool(unit_test.Passed()) +
"&elapsed_time=" + StreamableToString(unit_test.elapsed_time()) +
"ms");
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x40(%rsi), %rdi
callq 0x395be
leaq 0x696f(%rip), %rcx # 0x44197
leaq 0x8491(%rip), %rsi # 0x45cc0
testb %al, %al
cmovneq %rcx, %rsi
leaq 0xb8(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x694f(%rip), %rax... | /todo-group[P]exact/build_O3/_deps/googletest-src/googletest/src/gtest-internal-inl.h |
testing::internal::StreamingListener::SocketWriter::~SocketWriter() | ~SocketWriter() override {
if (sockfd_ != -1) CloseConnection();
} | pushq %rbx
movq %rdi, %rbx
leaq 0x1ce0b(%rip), %rax # 0x5ab10
movq %rax, (%rdi)
cmpl $-0x1, 0x8(%rdi)
je 0x3dd16
movq %rbx, %rdi
callq 0x3de82
movq 0x30(%rbx), %rdi
leaq 0x40(%rbx), %rax
cmpq %rax, %rdi
je 0x3dd2e
movq (%rax), %rsi
incq %rsi
callq 0x74f0
movq 0x10(%rbx), %rdi
addq $0x20, %rbx
cmpq %rbx, %rdi
je 0x3... | /todo-group[P]exact/build_O3/_deps/googletest-src/googletest/src/gtest-internal-inl.h |
main | int main() {
cout << "---------------" << endl;
create_dfa("nfa0");
/*
create_dfa("nfa1");
create_dfa("nfa2");
create_dfa("nfa3");
create_dfa("nfa4");
*/
return 0;
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq 0xd365(%rip), %rbx # 0x16fd8
leaq 0x83cd(%rip), %rsi # 0x12047
movl $0xf, %edx
movq %rbx, %rdi
callq 0x92b0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x9220
movsbl %al, %esi
movq %rbx, %rdi
callq 0x9030
movq %rax, %rdi
callq 0x91... | /iamareebjamal[P]nfa-dfa-coverter/main.cpp |
nfa_parser::get_set_items(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | set<string> nfa_parser::get_set_items(const string& key) {
vector<string> items = split(get_item(symbolmap, key), ',');
set<string> item_set(items.begin(), items.end());
symbolmap.erase(key);
return item_set;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0xa5b6
xorps %xmm0, %xmm0
movq %rsp, %rdx
movaps %xmm0, (%rdx)
movq $0x0, 0x10(%rdx)
movq %r12, %rdi
movl $0x2c, %esi
callq 0xb3c6
leaq 0x28(%rsp), %rax
movq -0x10(%ra... | /iamareebjamal[P]nfa-dfa-coverter/nfa_parser.cpp |
void split<std::back_insert_iterator<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, ... | void split(const string &s, const char delim, T result) {
stringstream ss;
ss.str(s);
string item;
while (getline(ss, item, delim)) {
*(result++) = item;
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x28(%rsp), %rdi
callq 0x9190
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
callq 0x9350
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
mov... | /iamareebjamal[P]nfa-dfa-coverter/utils.cpp |
nfa::get_epsilon_closure(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | const set<string> nfa::get_epsilon_closure(const string &state) {
set<string> key;
key.insert(state);
if(epsilon_closures.count(key))
return epsilon_closures[key];
set<string> epsilon_states;
queue<string> remaining;
remaining.push(state);
while (!remaining.empty()) {
str... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x58(%rsp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0x50(%rsp), %rd... | /iamareebjamal[P]nfa-dfa-coverter/nfa.cpp |
DisconnectSBGx | HARDWAREX_API int DisconnectSBGx(SBG* pSBG)
{
int id = 0, res = EXIT_FAILURE;
while (addrsSBG[id] != pSBG)
{
id++;
if (id >= MAX_NB_DEVICES_HARDWAREX) return EXIT_FAILURE;
}
res = DisconnectSBG(pSBG);
if (res != EXIT_SUCCESS) return res;
addrsSBG[id] = NULL;
return EXIT_SUCCESS;
} | pushq %r15
pushq %r14
pushq %rbx
xorl %r14d, %r14d
movq 0x2cfcf(%rip), %r15 # 0x36e58
cmpq %rdi, (%r15,%r14,8)
je 0x9e9f
incq %r14
cmpq $0x10, %r14
jne 0x9e89
movl $0x1, %eax
jmp 0x9ed6
callq 0x9a40
movl %eax, %ebx
testl %eax, %eax
leaq 0x2526e(%rip), %rax # 0x2f11d
leaq 0x25255(%rip), %rdi # 0x2f10b
cmovne... | /ENSTABretagneRobotics[P]Hardware-MATLAB/hardwarex.cpp |
SBGThread(void*) | THREAD_PROC_RETURN_VALUE SBGThread(void* pParam)
{
SBG* pSBG = (SBG*)pParam;
int id = 0, res = EXIT_FAILURE, err = EXIT_SUCCESS;
SBGDATA sbgdata;
while (addrsSBG[id] != pSBG)
{
id++;
if (id >= MAX_NB_DEVICES_HARDWAREX) return 0;
}
memset(&sbgdata, 0, sizeof(SBGDATA));
for (;;)
{
#ifdef ENA... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x11b8, %rsp # imm = 0x11B8
movq %rdi, %rbx
movq 0x2cf59(%rip), %r14 # 0x36e50
movq 0x2ce8a(%rip), %r15 # 0x36d88
xorl %r13d, %r13d
movq 0x2cf50(%rip), %rax # 0x36e58
cmpq %rbx, (%rax,%r13,2)
je 0x9f25
addq $0x28, %r14
addq $0... | /ENSTABretagneRobotics[P]Hardware-MATLAB/hardwarex.cpp |
GetLatestDataFromThreadSBGx | HARDWAREX_API int GetLatestDataFromThreadSBGx(SBG* pSBG, SBGDATA* pSBGData)
{
int id = 0, res = EXIT_FAILURE;
while (addrsSBG[id] != pSBG)
{
id++;
if (id >= MAX_NB_DEVICES_HARDWAREX) return EXIT_FAILURE;
}
EnterCriticalSection(&SBGCS[id]);
*pSBGData = sbgdataSBG[id];
res = resSBG[id];
LeaveCr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq 0x2cea6(%rip), %rbx # 0x36e50
movq 0x2cdd7(%rip), %r15 # 0x36d88
xorl %r12d, %r12d
movq 0x2ce9d(%rip), %rax # 0x36e58
cmpq %rdi, (%rax,%r12,8)
je 0x9fdc
incq %r12
addq $0x28, %rbx
addq $0x11b0, %r15 # imm = 0x11B0
cmpq $0x... | /ENSTABretagneRobotics[P]Hardware-MATLAB/hardwarex.cpp |
ConnectMTx | HARDWAREX_API int ConnectMTx(MT* pMT, char* szCfgFilePath)
{
int id = 0, res = EXIT_FAILURE;
while (addrsMT[id] != NULL)
{
id++;
if (id >= MAX_NB_DEVICES_HARDWAREX) return EXIT_FAILURE;
}
res = ConnectMT(pMT, szCfgFilePath);
if (res != EXIT_SUCCESS) return res;
addrsMT[id] = pMT;
return E... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x2cb68(%rip), %r15 # 0x36d20
cmpq $0x0, (%r15,%r14,8)
je 0xa1cf
incq %r14
cmpq $0x10, %r14
jne 0xa1b8
movl $0x1, %eax
jmp 0xa1e1
movq %rbx, %rdi
callq 0x90b0
testl %eax, %eax
jne 0xa1e1
movq %rbx, (%r15,%r14,8)
xorl %eax, %eax
popq %rbx
popq %... | /ENSTABretagneRobotics[P]Hardware-MATLAB/hardwarex.cpp |
GetLatestDataFromThreadMTx | HARDWAREX_API int GetLatestDataFromThreadMTx(MT* pMT, MTDATA* pMTData)
{
int id = 0, res = EXIT_FAILURE;
while (addrsMT[id] != pMT)
{
id++;
if (id >= MAX_NB_DEVICES_HARDWAREX) return EXIT_FAILURE;
}
EnterCriticalSection(&MTCS[id]);
*pMTData = mtdataMT[id];
res = resMT[id];
LeaveCriticalSectio... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq 0x2c93e(%rip), %rbx # 0x36ca8
movq 0x2c99f(%rip), %r15 # 0x36d10
xorl %r12d, %r12d
movq 0x2c9a5(%rip), %rax # 0x36d20
cmpq %rdi, (%rax,%r12,8)
je 0xa39c
incq %r12
addq $0x28, %rbx
addq $0x130, %r15 # imm = 0x130
cmpq $0x1... | /ENSTABretagneRobotics[P]Hardware-MATLAB/hardwarex.cpp |
StopThreadMTx | HARDWAREX_API int StopThreadMTx(MT* pMT)
{
int id = 0;
while (addrsMT[id] != pMT)
{
id++;
if (id >= MAX_NB_DEVICES_HARDWAREX) return EXIT_FAILURE;
}
bExitMT[id] = TRUE;
WaitForThread(MTThreadId[id]);
DeleteCriticalSection(&MTCS[id]);
resMT[id] = EXIT_FAILURE;
return EXIT_SUCCESS;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x2c7db(%rip), %rbx # 0x36ca8
xorl %r15d, %r15d
movq 0x2c849(%rip), %rax # 0x36d20
cmpq %rdi, (%rax,%r15,2)
je 0xa4f3
addq $0x4, %r15
addq $0x28, %rbx
cmpq $0x40, %r15
jne 0xa4d7
movl $0x1, %r14d
jmp 0xa52b
movq 0x2c81e(%rip), %rax # 0x36d18
movl $... | /ENSTABretagneRobotics[P]Hardware-MATLAB/hardwarex.cpp |
ConnectRazorAHRSx | HARDWAREX_API int ConnectRazorAHRSx(RAZORAHRS* pRazorAHRS, char* szCfgFilePath)
{
int id = 0, res = EXIT_FAILURE;
while (addrsRazorAHRS[id] != NULL)
{
id++;
if (id >= MAX_NB_DEVICES_HARDWAREX) return EXIT_FAILURE;
}
res = ConnectRazorAHRS(pRazorAHRS, szCfgFilePath);
if (res != EXIT_SUCCESS) retur... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x2c918(%rip), %r15 # 0x36e90
cmpq $0x0, (%r15,%r14,8)
je 0xa58f
incq %r14
cmpq $0x10, %r14
jne 0xa578
movl $0x1, %eax
jmp 0xa5a1
movq %rbx, %rdi
callq 0x9540
testl %eax, %eax
jne 0xa5a1
movq %rbx, (%r15,%r14,8)
xorl %eax, %eax
popq %rbx
popq %... | /ENSTABretagneRobotics[P]Hardware-MATLAB/hardwarex.cpp |
DisconnectRazorAHRSx | HARDWAREX_API int DisconnectRazorAHRSx(RAZORAHRS* pRazorAHRS)
{
int id = 0, res = EXIT_FAILURE;
while (addrsRazorAHRS[id] != pRazorAHRS)
{
id++;
if (id >= MAX_NB_DEVICES_HARDWAREX) return EXIT_FAILURE;
}
res = DisconnectRazorAHRS(pRazorAHRS);
if (res != EXIT_SUCCESS) return res;
addrsRazorAHR... | pushq %r15
pushq %r14
pushq %rbx
xorl %r14d, %r14d
movq 0x2c8da(%rip), %r15 # 0x36e90
cmpq %rdi, (%r15,%r14,8)
je 0xa5cc
incq %r14
cmpq $0x10, %r14
jne 0xa5b6
movl $0x1, %eax
jmp 0xa603
callq 0x9a40
movl %eax, %ebx
testl %eax, %eax
leaq 0x24d43(%rip), %rax # 0x2f31f
leaq 0x24d24(%rip), %rdi # 0x2f307
cmovne... | /ENSTABretagneRobotics[P]Hardware-MATLAB/hardwarex.cpp |
RazorAHRSThread(void*) | THREAD_PROC_RETURN_VALUE RazorAHRSThread(void* pParam)
{
RAZORAHRS* pRazorAHRS = (RAZORAHRS*)pParam;
int id = 0, res = EXIT_FAILURE, err = EXIT_SUCCESS;
RAZORAHRSDATA razorahrsdata;
while (addrsRazorAHRS[id] != pRazorAHRS)
{
id++;
if (id >= MAX_NB_DEVICES_HARDWAREX) return 0;
}
memset(&razorahr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
movq 0x2c7d7(%rip), %r14 # 0x36df8
movq 0x2c690(%rip), %r15 # 0x36cb8
xorl %ebp, %ebp
movq 0x2c85f(%rip), %rax # 0x36e90
cmpq %rbx, (%rax,%rbp,2)
je 0xa64e
addq $0x28, %r14
addq $0x60, %r15
addq $0x4, %rbp
cmp... | /ENSTABretagneRobotics[P]Hardware-MATLAB/hardwarex.cpp |
StopThreadRazorAHRSx | HARDWAREX_API int StopThreadRazorAHRSx(RAZORAHRS* pRazorAHRS)
{
int id = 0;
while (addrsRazorAHRS[id] != pRazorAHRS)
{
id++;
if (id >= MAX_NB_DEVICES_HARDWAREX) return EXIT_FAILURE;
}
bExitRazorAHRS[id] = TRUE;
WaitForThread(RazorAHRSThreadId[id]);
DeleteCriticalSection(&RazorAHRSCS[id]);
res... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x2c559(%rip), %rbx # 0x36df8
xorl %r15d, %r15d
movq 0x2c5e7(%rip), %rax # 0x36e90
cmpq %rdi, (%rax,%r15,2)
je 0xa8c5
addq $0x4, %r15
addq $0x28, %rbx
cmpq $0x40, %r15
jne 0xa8a9
movl $0x1, %r14d
jmp 0xa8fd
movq 0x2c574(%rip), %rax # 0x36e40
movl $... | /ENSTABretagneRobotics[P]Hardware-MATLAB/hardwarex.cpp |
SendDataMDMx | HARDWAREX_API int SendDataMDMx(MDM* pMDM, unsigned char* buf, int buflen, int* pSentBytes)
{
return SendDataMDM(pMDM, buf, buflen, pSentBytes);
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl %edx, 0x534(%rdi)
jge 0xa937
leaq 0x23d40(%rip), %r14 # 0x2e675
jmp 0xa999
movq %rcx, %r14
movl 0x310(%rbx), %eax
movl $0x1, %ebp
leal -0x1(%rax), %ecx
cmpl $0x4, %ecx
jae 0xa96b
movl 0x8(%rbx), %edi
movslq %edx, %rdx
xorl %ecx, %ecx
callq 0x92a0
movl %eax, (%r1... | /ENSTABretagneRobotics[P]Hardware-MATLAB/hardwarex.cpp |
RecvDataMDMx | HARDWAREX_API int RecvDataMDMx(MDM* pMDM, unsigned char* buf, int buflen, int* pReceivedBytes)
{
return RecvDataMDM(pMDM, buf, buflen, pReceivedBytes);
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl %edx, 0x534(%rdi)
jge 0xa9da
leaq 0x23d04(%rip), %r14 # 0x2e6dc
jmp 0xaa3c
movq %rcx, %r14
movl 0x310(%rbx), %eax
movl $0x1, %ebp
leal -0x1(%rax), %ecx
cmpl $0x4, %ecx
jae 0xaa0e
movl 0x8(%rbx), %edi
movslq %edx, %rdx
xorl %ecx, %ecx
callq 0x91d0
movl %eax, (%r1... | /ENSTABretagneRobotics[P]Hardware-MATLAB/hardwarex.cpp |
ConnectP33xx | HARDWAREX_API int ConnectP33xx(P33X* pP33x, char* szCfgFilePath)
{
int id = 0, res = EXIT_FAILURE;
while (addrsP33x[id] != NULL)
{
id++;
if (id >= MAX_NB_DEVICES_HARDWAREX) return EXIT_FAILURE;
}
res = ConnectP33x(pP33x, szCfgFilePath);
if (res != EXIT_SUCCESS) return res;
addrsP33x[id] = pP3... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x2c446(%rip), %r15 # 0x36fc8
cmpq $0x0, (%r15,%r14,8)
je 0xab99
incq %r14
cmpq $0x10, %r14
jne 0xab82
movl $0x1, %eax
jmp 0xabab
movq %rbx, %rdi
callq 0x9720
testl %eax, %eax
jne 0xabab
movq %rbx, (%r15,%r14,8)
xorl %eax, %eax
popq %rbx
popq %... | /ENSTABretagneRobotics[P]Hardware-MATLAB/hardwarex.cpp |
P33xThread(void*) | THREAD_PROC_RETURN_VALUE P33xThread(void* pParam)
{
P33X* pP33x = (P33X*)pParam;
int id = 0, res = EXIT_FAILURE, err = EXIT_SUCCESS;
double pressure = 0, temperature = 0;
while (addrsP33x[id] != pP33x)
{
id++;
if (id >= MAX_NB_DEVICES_HARDWAREX) return 0;
}
for (;;)
{
mSleep(pP33x->threadp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x2c24d(%rip), %r14 # 0x36e78
xorl %r12d, %r12d
movq 0x2c393(%rip), %rax # 0x36fc8
cmpq %rbx, (%rax,%r12,2)
je 0xac4e
addq $0x28, %r14
addq $0x4, %r12
cmpq $0x40, %r12
jne 0xac35
jmp 0xade0
xorl %eax, %eax
mo... | /ENSTABretagneRobotics[P]Hardware-MATLAB/hardwarex.cpp |
StartThreadP33xx | HARDWAREX_API int StartThreadP33xx(P33X* pP33x)
{
int id = 0;
while (addrsP33x[id] != pP33x)
{
id++;
if (id >= MAX_NB_DEVICES_HARDWAREX) return EXIT_FAILURE;
}
resP33x[id] = EXIT_FAILURE;
bExitP33x[id] = FALSE;
InitCriticalSection(&P33xCS[id]);
return CreateDefaultThread(P33xThread, (void*)pP... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x2bf93(%rip), %r15 # 0x36e78
movq 0x2c10c(%rip), %r14 # 0x36ff8
xorl %eax, %eax
movq 0x2c0d3(%rip), %rcx # 0x36fc8
cmpq %rbx, (%rcx,%rax,2)
je 0xaf17
addq $0x4, %rax
addq $0x28, %r15
addq $0x8, %r14
cmpq $0x40, %ra... | /ENSTABretagneRobotics[P]Hardware-MATLAB/hardwarex.cpp |
GetLatestDataFromThreadNMEADevicex | HARDWAREX_API int GetLatestDataFromThreadNMEADevicex(NMEADEVICE* pNMEADevice, NMEADATA* pNMEAData)
{
int id = 0, res = EXIT_FAILURE;
while (addrsNMEADevice[id] != pNMEADevice)
{
id++;
if (id >= MAX_NB_DEVICES_HARDWAREX) return EXIT_FAILURE;
}
EnterCriticalSection(&NMEADeviceCS[id]);
*pNMEAData = ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq 0x2bc18(%rip), %rbx # 0x36e38
movq 0x2bc41(%rip), %r15 # 0x36e68
xorl %r12d, %r12d
movq 0x2bc6f(%rip), %rax # 0x36ea0
cmpq %rdi, (%rax,%r12,8)
je 0xb252
incq %r12
addq $0x28, %rbx
addq $0x3d8, %r15 # imm = 0x3D8
cmpq $0x1... | /ENSTABretagneRobotics[P]Hardware-MATLAB/hardwarex.cpp |
Disconnectubloxx | HARDWAREX_API int Disconnectubloxx(UBLOX* publox)
{
int id = 0, res = EXIT_FAILURE;
while (addrsublox[id] != publox)
{
id++;
if (id >= MAX_NB_DEVICES_HARDWAREX) return EXIT_FAILURE;
}
res = Disconnectublox(publox);
if (res != EXIT_SUCCESS) return res;
addrsublox[id] = NULL;
return EXIT_SU... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorl %r15d, %r15d
movq 0x2b999(%rip), %r12 # 0x36e00
cmpq %rbx, (%r12,%r15,8)
je 0xb480
incq %r15
cmpq $0x10, %r15
jne 0xb467
movl $0x1, %eax
jmp 0xb519
cmpl $0x0, 0x830(%rbx)
je 0xb4da
leaq 0x834(%rbx), %r14
movq %r14, %rdi
callq 0x9230
m... | /ENSTABretagneRobotics[P]Hardware-MATLAB/hardwarex.cpp |
ubloxNMEAThread(void*) | THREAD_PROC_RETURN_VALUE ubloxNMEAThread(void* pParam)
{
UBLOX* publox = (UBLOX*)pParam;
int id = 0, res = EXIT_FAILURE, err = EXIT_SUCCESS;
NMEADATA nmeadata;
while (addrsublox[id] != publox)
{
id++;
if (id >= MAX_NB_DEVICES_HARDWAREX) return 0;
}
memset(&nmeadata, 0, sizeof(NMEADATA));
for ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3d8, %rsp # imm = 0x3D8
movq %rdi, %rbx
movq 0x2b8e0(%rip), %r14 # 0x36e20
movq 0x2b851(%rip), %r15 # 0x36d98
xorl %r13d, %r13d
movq 0x2b8af(%rip), %rax # 0x36e00
cmpq %rbx, (%rax,%r13,2)
je 0xb56e
addq $0x28, %r14
addq $0x... | /ENSTABretagneRobotics[P]Hardware-MATLAB/hardwarex.cpp |
StopUBXThreadubloxx | HARDWAREX_API int StopUBXThreadubloxx(UBLOX* publox)
{
int id = 0;
while (addrsublox[id] != publox)
{
id++;
if (id >= MAX_NB_DEVICES_HARDWAREX) return EXIT_FAILURE;
}
bExitUBXublox[id] = TRUE;
WaitForThread(ubloxUBXThreadId[id]);
DeleteCriticalSection(&ubloxCS[id]);
resublox[id] = EXIT_FAILUR... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x2b431(%rip), %rbx # 0x36e20
xorl %r15d, %r15d
movq 0x2b407(%rip), %rax # 0x36e00
cmpq %rdi, (%rax,%r15,2)
je 0xba15
addq $0x4, %r15
addq $0x28, %rbx
cmpq $0x40, %r15
jne 0xb9f9
movl $0x1, %r14d
jmp 0xba4d
movq 0x2b3d4(%rip), %rax # 0x36df0
movl $... | /ENSTABretagneRobotics[P]Hardware-MATLAB/hardwarex.cpp |
IM483IThread(void*) | THREAD_PROC_RETURN_VALUE IM483IThread(void* pParam)
{
IM483I* pIM483I = (IM483I*)pParam;
int id = 0, res = EXIT_FAILURE, err = EXIT_SUCCESS;
double angle = 0;
while (addrsIM483I[id] != pIM483I)
{
id++;
if (id >= MAX_NB_DEVICES_HARDWAREX) return 0;
}
mSleep(pIM483I->threadperiod);
for (;;)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x2b444(%rip), %r14 # 0x36fe0
xorl %r12d, %r12d
movq 0x2b3ba(%rip), %rax # 0x36f60
cmpq %rbx, (%rax,%r12,2)
je 0xbbbf
addq $0x28, %r14
addq $0x4, %r12
cmpq $0x40, %r12
jne 0xbba6
jmp 0xbd07
movslq 0x52c(%rbx)... | /ENSTABretagneRobotics[P]Hardware-MATLAB/hardwarex.cpp |
SetMaxAngleFromThreadIM483Ix | HARDWAREX_API int SetMaxAngleFromThreadIM483Ix(IM483I* pIM483I, double angle)
{
int id = 0, res = EXIT_FAILURE;
while (addrsIM483I[id] != pIM483I)
{
id++;
if (id >= MAX_NB_DEVICES_HARDWAREX) return EXIT_FAILURE;
}
EnterCriticalSection(&IM483ICS[id]);
angleIM483I[id] = angle;
res = resIM483I[id]... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x2b2b9(%rip), %rbx # 0x36fe0
xorl %r14d, %r14d
movq 0x2b22f(%rip), %rax # 0x36f60
cmpq %rdi, (%rax,%r14,8)
je 0xbd4b
incq %r14
addq $0x28, %rbx
cmpq $0x10, %r14
jne 0xbd31
movl $0x1, %ebp
jmp 0xbd7f
movq %rbx, %rdi
movsd %xmm0, 0x8(%rsp)
callq 0x9890
movq ... | /ENSTABretagneRobotics[P]Hardware-MATLAB/hardwarex.cpp |
SetAllPWMsFromThreadSSC32x | HARDWAREX_API int SetAllPWMsFromThreadSSC32x(SSC32* pSSC32, int* selectedchannels, int* pws)
{
int id = 0, res = EXIT_FAILURE;
while (addrsSSC32[id] != pSSC32)
{
id++;
if (id >= MAX_NB_DEVICES_HARDWAREX) return EXIT_FAILURE;
}
EnterCriticalSection(&SSC32CS[id]);
memcpy(selectedchannelsSSC32[id], ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq 0x2ae3f(%rip), %rbx # 0x36f90
xorl %r13d, %r13d
movq 0x2ad5d(%rip), %rax # 0x36eb8
xorl %r12d, %r12d
cmpq %rdi, (%rax,%r13,2)
je 0xc180
addq $0x28, %rbx
subq $-0x80, %r12
addq $0x4, %r13
cmpq $0x800... | /ENSTABretagneRobotics[P]Hardware-MATLAB/hardwarex.cpp |
StopThreadSSC32x | HARDWAREX_API int StopThreadSSC32x(SSC32* pSSC32)
{
int id = 0;
while (addrsSSC32[id] != pSSC32)
{
id++;
if (id >= MAX_NB_DEVICES_HARDWAREX) return EXIT_FAILURE;
}
bExitSSC32[id] = TRUE;
WaitForThread(SSC32ThreadId[id]);
DeleteCriticalSection(&SSC32CS[id]);
resSSC32[id] = EXIT_FAILURE;
retu... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x2acd4(%rip), %rbx # 0x36f90
xorl %r15d, %r15d
movq 0x2abf2(%rip), %rax # 0x36eb8
cmpq %rdi, (%rax,%r15,2)
je 0xc2e2
addq $0x4, %r15
addq $0x28, %rbx
cmpq $0x40, %r15
jne 0xc2c6
movl $0x1, %r14d
jmp 0xc31a
movq 0x2aabf(%rip), %rax # 0x36da8
movl $... | /ENSTABretagneRobotics[P]Hardware-MATLAB/hardwarex.cpp |
ConnectPololux | HARDWAREX_API int ConnectPololux(POLOLU* pPololu, char* szCfgFilePath)
{
int id = 0, res = EXIT_FAILURE;
while (addrsPololu[id] != NULL)
{
id++;
if (id >= MAX_NB_DEVICES_HARDWAREX) return EXIT_FAILURE;
}
res = ConnectPololu(pPololu, szCfgFilePath);
if (res != EXIT_SUCCESS) return res;
addrsPo... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x2a9d9(%rip), %r15 # 0x36d40
cmpq $0x0, (%r15,%r14,8)
je 0xc37e
incq %r14
cmpq $0x10, %r14
jne 0xc367
movl $0x1, %eax
jmp 0xc390
movq %rbx, %rdi
callq 0x90a0
testl %eax, %eax
jne 0xc390
movq %rbx, (%r15,%r14,8)
xorl %eax, %eax
popq %rbx
popq %... | /ENSTABretagneRobotics[P]Hardware-MATLAB/hardwarex.cpp |
StartThreadPololux | HARDWAREX_API int StartThreadPololux(POLOLU* pPololu)
{
int id = 0;
while (addrsPololu[id] != pPololu)
{
id++;
if (id >= MAX_NB_DEVICES_HARDWAREX) return EXIT_FAILURE;
}
resPololu[id] = EXIT_FAILURE;
bExitPololu[id] = FALSE;
InitCriticalSection(&PololuCS[id]);
return CreateDefaultThread(Polol... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x2a51a(%rip), %r15 # 0x36f18
movq 0x2a45b(%rip), %r14 # 0x36e60
xorl %eax, %eax
movq 0x2a332(%rip), %rcx # 0x36d40
cmpq %rbx, (%rcx,%rax,2)
je 0xca30
addq $0x4, %rax
addq $0x28, %r15
addq $0x8, %r14
cmpq $0x40, %ra... | /ENSTABretagneRobotics[P]Hardware-MATLAB/hardwarex.cpp |
GetLatestDataHokuyox | HARDWAREX_API int GetLatestDataHokuyox(HOKUYO* pHokuyo, double* pDistances, double* pAngles)
{
return GetLatestDataHokuyo(pHokuyo, pDistances, pAngles);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2018, %rsp # imm = 0x2018
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x10(%rsp), %r12
movl $0x2000, %edx # imm = 0x2000
movq %r12, %rdi
xorl %esi, %esi
callq 0x9300
leaq 0xc(%rsp), %rcx
movl $0x0, (%rcx)
movq %r15, %rdi
movq %r12, %rsi
mo... | /ENSTABretagneRobotics[P]Hardware-MATLAB/hardwarex.cpp |
DisconnectHokuyox | HARDWAREX_API int DisconnectHokuyox(HOKUYO* pHokuyo)
{
int id = 0, res = EXIT_FAILURE;
while (addrsHokuyo[id] != pHokuyo)
{
id++;
if (id >= MAX_NB_DEVICES_HARDWAREX) return EXIT_FAILURE;
}
res = DisconnectHokuyo(pHokuyo);
if (res != EXIT_SUCCESS) return res;
addrsHokuyo[id] = NULL;
return... | pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
movq 0x29f3d(%rip), %r14 # 0x36cd0
cmpq %rdi, (%r14,%rbx,8)
je 0xcda9
incq %rbx
cmpq $0x10, %rbx
jne 0xcd93
movl $0x1, %eax
jmp 0xcdbc
callq 0x9030
testl %eax, %eax
jne 0xcdbc
movq $0x0, (%r14,%rbx,8)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /ENSTABretagneRobotics[P]Hardware-MATLAB/hardwarex.cpp |
StopThreadHokuyox | HARDWAREX_API int StopThreadHokuyox(HOKUYO* pHokuyo)
{
int id = 0;
while (addrsHokuyo[id] != pHokuyo)
{
id++;
if (id >= MAX_NB_DEVICES_HARDWAREX) return EXIT_FAILURE;
}
bExitHokuyo[id] = TRUE;
WaitForThread(HokuyoThreadId[id]);
DeleteCriticalSection(&HokuyoCS[id]);
resHokuyo[id] = EXIT_FAILUR... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x29c26(%rip), %rbx # 0x36d90
xorl %r15d, %r15d
movq 0x29b5c(%rip), %rax # 0x36cd0
cmpq %rdi, (%rax,%r15,2)
je 0xd190
addq $0x4, %r15
addq $0x28, %rbx
cmpq $0x40, %r15
jne 0xd174
movl $0x1, %r14d
jmp 0xd1c8
movq 0x29bd9(%rip), %rax # 0x36d70
movl $... | /ENSTABretagneRobotics[P]Hardware-MATLAB/hardwarex.cpp |
ResetRequestRPLIDARx | HARDWAREX_API int ResetRequestRPLIDARx(RPLIDAR* pRPLIDAR)
{
return ResetRequestRPLIDAR(pRPLIDAR);
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movw $0x40a5, 0xe(%rsp) # imm = 0x40A5
movl 0x328(%rdi), %eax
leal -0x1(%rax), %ecx
cmpl $0x4, %ecx
jae 0xd334
movl 0x20(%rbx), %ebp
xorl %r14d, %r14d
movl %r14d, %eax
leaq (%rsp,%rax), %rsi
addq $0xe, %rsi
movl $0x2, %eax
subl %r14d, %eax
movslq %e... | /ENSTABretagneRobotics[P]Hardware-MATLAB/hardwarex.cpp |
SetMotorPWMRequestRPLIDARx | HARDWAREX_API int SetMotorPWMRequestRPLIDARx(RPLIDAR* pRPLIDAR, int pwm)
{
return SetMotorPWMRequestRPLIDAR(pRPLIDAR, pwm);
} | pushq %rbp
pushq %rbx
subq $0x18, %rsp
movw $0x0, 0x4(%rsp)
movl $0x2f0a5, (%rsp) # imm = 0x2F0A5
movw %si, 0x3(%rsp)
xorl %eax, %eax
xorl %ecx, %ecx
xorb (%rsp,%rax), %cl
incq %rax
cmpq $0x5, %rax
jne 0xd566
movb %cl, 0x5(%rsp)
movl 0x328(%rdi), %eax
leal -0x1(%rax), %ecx
cmpl $0x4, %ecx
jae 0xd5af
movl 0x20(%r... | /ENSTABretagneRobotics[P]Hardware-MATLAB/hardwarex.cpp |
ConnectRPLIDARx | HARDWAREX_API int ConnectRPLIDARx(RPLIDAR* pRPLIDAR, char* szCfgFilePath)
{
int id = 0, res = EXIT_FAILURE;
while (addrsRPLIDAR[id] != NULL)
{
id++;
if (id >= MAX_NB_DEVICES_HARDWAREX) return EXIT_FAILURE;
}
res = ConnectRPLIDAR(pRPLIDAR, szCfgFilePath);
if (res != EXIT_SUCCESS) return res;
#i... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq 0x29887(%rip), %r12 # 0x36fa0
xorl %r13d, %r13d
cmpq $0x0, (%r12)
je 0xd73f
addq $-0x50, %r13
addq $0x8, %r12
cmpq $-0x500, %r13 # imm = 0xFB00
jne 0xd71c
movl $0x1, %r14d
jmp 0xd7dd
movq %rbx, %rdi
callq 0x9bc0
m... | /ENSTABretagneRobotics[P]Hardware-MATLAB/hardwarex.cpp |
RPLIDARExpressScanThread(void*) | THREAD_PROC_RETURN_VALUE RPLIDARExpressScanThread(void* pParam)
{
RPLIDAR* pRPLIDAR = (RPLIDAR*)pParam;
int id = 0, res = EXIT_FAILURE, err = EXIT_SUCCESS;
double angles[NB_MEASUREMENTS_EXPRESS_SCAN_DATA_RESPONSE_RPLIDAR];
double distances[NB_MEASUREMENTS_EXPRESS_SCAN_DATA_RESPONSE_RPLIDAR];
BOOL bNewScan = ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp # imm = 0x258
movq %rdi, %rbx
movl $0x0, 0x4(%rsp)
movq 0x2907a(%rip), %r12 # 0x36f98
xorl %ebp, %ebp
movq 0x29079(%rip), %rax # 0x36fa0
xorl %r14d, %r14d
xorl %r15d, %r15d
cmpq %rbx, (%rax,%rbp,2)
je 0xdf54
addq $0x2... | /ENSTABretagneRobotics[P]Hardware-MATLAB/hardwarex.cpp |
GetScanDataResponseFromThreadRPLIDARx | HARDWAREX_API int GetScanDataResponseFromThreadRPLIDARx(RPLIDAR* pRPLIDAR, double* pDistance, double* pAngle, BOOL* pbNewScan, int *pQuality)
{
int id = 0, res = EXIT_FAILURE;
while (addrsRPLIDAR[id] != pRPLIDAR)
{
id++;
if (id >= MAX_NB_DEVICES_HARDWAREX) return EXIT_FAILURE;
}
EnterCriticalSectio... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq 0x282f0(%rip), %r14 # 0x36f98
xorl %ebp, %ebp
movq 0x282ef(%rip), %rax # 0x36fa0
cmpq %rdi, (%rax,%rbp,2)
je 0xeccc
addq $0x28, %r14
addq $0x4, %rbp
cmpq $0x40, %rbp
j... | /ENSTABretagneRobotics[P]Hardware-MATLAB/hardwarex.cpp |
StopScanThreadRPLIDARx | HARDWAREX_API int StopScanThreadRPLIDARx(RPLIDAR* pRPLIDAR)
{
int id = 0;
while (addrsRPLIDAR[id] != pRPLIDAR)
{
id++;
if (id >= MAX_NB_DEVICES_HARDWAREX) return EXIT_FAILURE;
}
bExitScanRPLIDAR[id] = TRUE;
WaitForThread(RPLIDARScanThreadId[id]);
DeleteCriticalSection(&RPLIDARCS[id]);
resRPLI... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x27df8(%rip), %rbx # 0x36f98
xorl %r15d, %r15d
movq 0x27df6(%rip), %rax # 0x36fa0
cmpq %rdi, (%rax,%r15,2)
je 0xf1c6
addq $0x4, %r15
addq $0x28, %rbx
cmpq $0x40, %r15
jne 0xf1aa
movl $0x1, %r14d
jmp 0xf1fe
movq 0x27d7b(%rip), %rax # 0x36f48
movl $... | /ENSTABretagneRobotics[P]Hardware-MATLAB/hardwarex.cpp |
StartExpressScanThreadRPLIDARx | HARDWAREX_API int StartExpressScanThreadRPLIDARx(RPLIDAR* pRPLIDAR)
{
int id = 0;
while (addrsRPLIDAR[id] != pRPLIDAR)
{
id++;
if (id >= MAX_NB_DEVICES_HARDWAREX) return EXIT_FAILURE;
}
resRPLIDAR[id] = EXIT_FAILURE;
bExitExpressScanRPLIDAR[id] = FALSE;
InitCriticalSection(&RPLIDARCS[id]);
re... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x27d76(%rip), %r15 # 0x36f98
movq 0x27ad7(%rip), %r14 # 0x36d00
xorl %eax, %eax
movq 0x27d6e(%rip), %rcx # 0x36fa0
cmpq %rbx, (%rcx,%rax,2)
je 0xf254
addq $0x4, %rax
addq $0x28, %r15
addq $0x8, %r14
cmpq $0x40, %ra... | /ENSTABretagneRobotics[P]Hardware-MATLAB/hardwarex.cpp |
StopOtherScanThreadRPLIDARx | HARDWAREX_API int StopOtherScanThreadRPLIDARx(RPLIDAR* pRPLIDAR)
{
int id = 0;
while (addrsRPLIDAR[id] != pRPLIDAR)
{
id++;
if (id >= MAX_NB_DEVICES_HARDWAREX) return EXIT_FAILURE;
}
bExitOtherScanRPLIDAR[id] = TRUE;
WaitForThread(RPLIDAROtherScanThreadId[id]);
DeleteCriticalSection(&RPLIDARCS[... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x27b50(%rip), %rbx # 0x36f98
xorl %r15d, %r15d
movq 0x27b4e(%rip), %rax # 0x36fa0
cmpq %rdi, (%rax,%r15,2)
je 0xf46e
addq $0x4, %r15
addq $0x28, %rbx
cmpq $0x40, %r15
jne 0xf452
movl $0x1, %r14d
jmp 0xf4a6
movq 0x27a63(%rip), %rax # 0x36ed8
movl $... | /ENSTABretagneRobotics[P]Hardware-MATLAB/hardwarex.cpp |
CreateDefaultThread(void* (*)(void*), void*, unsigned long*) | inline int CreateDefaultThread(PTHREAD_PROC pThreadProc, void* pParam, THREAD_IDENTIFIER* pThreadId)
{
#ifdef _WIN32
// CreateThread is not advised when used in combination with the C standard library...
// But it is not clear whether it is a problem in our case...
#ifdef USE_CREATE_THREAD
HANDLE hThread = Cre... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x10(%rsp), %rdi
callq 0x9730
movl $0x1, %ebx
testl %eax, %eax
jne 0x1040f
leaq 0x10(%rsp), %rdi
movl $0x100000, %esi # imm = 0x100000
callq 0x97b0
testl %eax, %eax
jne 0x10405... | /ENSTABretagneRobotics[P]Hardware-MATLAB/OSThread.h |
ConnectP33x(P33X*, char*) | inline int ConnectP33x(P33X* pP33x, char* szCfgFilePath)
{
FILE* file = NULL;
char line[256];
memset(pP33x->szCfgFilePath, 0, sizeof(pP33x->szCfgFilePath));
sprintf(pP33x->szCfgFilePath, "%.255s", szCfgFilePath);
// If szCfgFilePath starts with "hardcoded://", parameters are assumed to be already set in ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x330(%rdi), %r15
movl $0x100, %edx # imm = 0x100
movq %r15, %rdi
xorl %esi, %esi
callq 0x9300
leaq 0x19736(%rip), %rsi # 0x2e3d8
movq %r15, %rdi
movq %r14, %r... | /ENSTABretagneRobotics[P]Hardware-MATLAB/P33x.h |
ConnectNMEADevice(NMEADEVICE*, char*) | inline int ConnectNMEADevice(NMEADEVICE* pNMEADevice, char* szCfgFilePath)
{
FILE* file = NULL;
char line[256];
memset(pNMEADevice->szCfgFilePath, 0, sizeof(pNMEADevice->szCfgFilePath));
sprintf(pNMEADevice->szCfgFilePath, "%.255s", szCfgFilePath);
// If szCfgFilePath starts with "hardcoded://", paramete... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x6f8(%rdi), %r15
movl $0x100, %edx # imm = 0x100
movq %r15, %rdi
xorl %esi, %esi
callq 0x9300
leaq 0x1714e(%rip), %rsi # 0x2e3d8
movq %r15, %rdi
movq %r14, %r... | /ENSTABretagneRobotics[P]Hardware-MATLAB/NMEADevice.h |
GetNMEASentenceublox(UBLOX*, NMEADATA*) | inline int GetNMEASentenceublox(UBLOX* publox, NMEADATA* pNMEAData)
{
char recvbuf[MAX_NB_BYTES_UBLOX];
int BytesReceived = 0, recvbuflen = 0, res = EXIT_FAILURE, nbBytesToRequest = 0, nbBytesDiscarded = 0;
char* ptr = NULL;
int sentencelen = 0;
char talkerid[MAX_NB_BYTES_TALKER_ID_NMEA+1]; // +1 for the nul... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1098, %rsp # imm = 0x1098
movq %rsi, %r14
movq %rdi, %r15
movl $0x0, 0x18(%rsp)
leaq 0x78(%rsp), %rsi
movl $0x4, %edi
callq 0x9b70
testl %eax, %eax
jne 0x17cbb
leaq 0x48(%rsp), %rsi
movl $0x4, %edi
callq 0x9530
testl %eax, %eax
jne 0x17... | /ENSTABretagneRobotics[P]Hardware-MATLAB/ublox.h |
GetUBXPacketublox(UBLOX*, UBXDATA*) | inline int GetUBXPacketublox(UBLOX* publox, UBXDATA* pUBXData)
{
unsigned char recvbuf[MAX_NB_BYTES_UBLOX];
int BytesReceived = 0, recvbuflen = 0, res = EXIT_FAILURE, nbBytesToRequest = 0, nbBytesDiscarded = 0;
unsigned char* ptr = NULL;
int packetlen = 0;
int mclass = 0, mid = 0;
CHRONO chrono;
StartC... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1088, %rsp # imm = 0x1088
movq %rsi, %r14
movq %rdi, %r12
leaq 0x68(%rsp), %rsi
movl $0x4, %edi
callq 0x9b70
testl %eax, %eax
jne 0x18110
leaq 0x38(%rsp), %rsi
movl $0x4, %edi
callq 0x9530
testl %eax, %eax
jne 0x18110
movl $0x0, 0x78(%r... | /ENSTABretagneRobotics[P]Hardware-MATLAB/ublox.h |
SetMotorSpeedIM483I(IM483I*, int) | inline int SetMotorSpeedIM483I(IM483I* pIM483I, int val)
{
char sendbuf[MAX_NB_BYTES_IM483I];
int sendbuflen = 0;
char recvbuf[MAX_NB_BYTES_IM483I];
int recvbuflen = 0;
if (abs(val) < MIN_MOTOR_SPEED_IM483I) val = 0;
else if (val > MAX_MOTOR_SPEED_IM483I) val = MAX_MOTOR_SPEED_IM483I;
else if (val < -M... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp # imm = 0x408
movq %rdi, %rbx
movl %esi, %eax
negl %eax
cmovsl %esi, %eax
xorl %ebp, %ebp
cmpl $0x14, %eax
jb 0x1a690
movl $0x4e20, %ebp # imm = 0x4E20
cmpl $0x4e20, %esi # imm = 0x4E20
jg 0x1a690
cmpl $0x... | /ENSTABretagneRobotics[P]Hardware-MATLAB/IM483I.h |
SetMotorOriginIM483I(IM483I*) | inline int SetMotorOriginIM483I(IM483I* pIM483I)
{
char sendbuf[MAX_NB_BYTES_IM483I];
int sendbuflen = 0;
char recvbuf[MAX_NB_BYTES_IM483I];
int recvbuflen = 0;
// Prepare data to send to device.
memset(sendbuf, 0, sizeof(sendbuf));
sprintf(sendbuf, "O\r");
sendbuflen = (int)strlen(sendbuf);
if (... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp # imm = 0x408
movq %rdi, %rbx
leaq 0x203(%rsp), %r14
movl $0x1fd, %edx # imm = 0x1FD
movq %r14, %rdi
xorl %esi, %esi
callq 0x9300
movw $0xd4f, -0x3(%r14) # imm = 0xD4F
movb $0x0, -0x1(%r14)
leaq 0x200(%rsp), %... | /ENSTABretagneRobotics[P]Hardware-MATLAB/IM483I.h |
GetDigitalInputSSC32(SSC32*, int, int*) | inline int GetDigitalInputSSC32(SSC32* pSSC32, int channel, int* pValue)
{
char sendbuf[MAX_NB_BYTES_SSC32];
int sendbuflen = 0;
char recvbuf[1];
int recvbuflen = 0;
char c = 0;
char v = 0;
switch (channel)
{
case 0: c = 'A'; break;
case 1: c = 'B'; break;
case 2: c = 'C'; break;
case 3: c = ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x210, %rsp # imm = 0x210
movl %esi, %ebp
cmpl $0x4, %esi
jae 0x1bd2b
movq %rdx, %rbx
movq %rdi, %r14
addl $0x41, %ebp
leaq 0x10(%rsp), %r12
movl $0x200, %edx # imm = 0x200
movq %r12, %rdi
xorl %esi, %esi
callq 0x9300
leaq 0x13195(%rip),... | /ENSTABretagneRobotics[P]Hardware-MATLAB/SSC32.h |
SetPWMSSC32(SSC32*, int, int) | inline int SetPWMSSC32(SSC32* pSSC32, int channel, int pw)
{
char sendbuf[MAX_NB_BYTES_SSC32];
int sendbuflen = 0;
if (pSSC32->bProportionalPWs[channel])
{
pw = (int)(pSSC32->CoefPWs[channel]*(pw-DEFAULT_MID_PW_SSC32));
if (pw >= 0)
pw = pSSC32->MidPWs[channel]+pw*(pSSC32->MaxPWs[channel]-pSSC32->M... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movl %esi, %ebp
movq %rdi, %rbx
movslq %esi, %r13
addl $0xfffffa24, %edx # imm = 0xFFFFFA24
cmpl $0x0, 0x938(%rdi,%r13,4)
cvtsi2sd %edx, %xmm0
mulsd 0x838(%rdi,%r13,8), %xmm0
cvttsd2si %xmm0, %eax
je 0x1c0... | /ENSTABretagneRobotics[P]Hardware-MATLAB/SSC32.h |
GetValuePololu(POLOLU*, int, int*) | inline int GetValuePololu(POLOLU* pPololu, int channel, int* pValue)
{
unsigned char sendbuf[MAX_NB_BYTES_POLOLU];
unsigned char recvbuf[MAX_NB_BYTES_POLOLU];
int sendbuflen = 0;
int recvbuflen = 0;
// Prepare data to send to device.
memset(sendbuf, 0, sizeof(sendbuf));
sendbuf[0] = (unsigned char)BAUD... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x400, %rsp # imm = 0x400
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x200(%rsp), %r15
xorl %r12d, %r12d
movl $0x200, %edx # imm = 0x200
movq %r15, %rdi
xorl %esi, %esi
callq 0x9300
movb $-0x56, (%r15)
movb 0x5fc(%r14), %al
mov... | /ENSTABretagneRobotics[P]Hardware-MATLAB/Pololu.h |
GetAllValuesPololu(POLOLU*, int*, int*) | inline int GetAllValuesPololu(POLOLU* pPololu, int* selectedchannels, int* ais)
{
unsigned char sendbuf[MAX_NB_BYTES_POLOLU];
unsigned char recvbuf[MAX_NB_BYTES_POLOLU];
int sendbuflen = 0;
int recvbuflen = 0;
int channel = 0;
int index = 0, nbselectedchannels = 0;
// Prepare data to send to device.
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x418, %rsp # imm = 0x418
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x10(%rsp), %rdi
xorl %r12d, %r12d
movl $0x200, %edx # imm = 0x200
xorl %esi, %esi
callq 0x9300
xorl %r13d, %r13d
xorl %eax, %eax
cmpl $0x0, (%r14,... | /ENSTABretagneRobotics[P]Hardware-MATLAB/Pololu.h |
SetAllPWMsPololu(POLOLU*, int*, int*) | inline int SetAllPWMsPololu(POLOLU* pPololu, int* selectedchannels, int* pws)
{
unsigned char sendbuf[MAX_NB_BYTES_POLOLU];
int sendbuflen = 0;
int channel = 0;
int target = 0;
int pws_tmp[NB_CHANNELS_PWM_POLOLU];
int index = 0, firstselectedchannel = 0, nbselectedchannels = 0;
// Prepare data to send ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp # imm = 0x268
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x60(%rsp), %rdi
xorl %r12d, %r12d
movl $0x200, %edx # imm = 0x200
xorl %esi, %esi
callq 0x9300
cmpl $0x0, 0x1200(%r14)
je 0x1dc9f
movb $-0x56, 0x6... | /ENSTABretagneRobotics[P]Hardware-MATLAB/Pololu.h |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.