name string | code string | asm string | file string |
|---|---|---|---|
ffgsdt | int ffgsdt( int *day, int *month, int *year, int *status )
{
/*
This routine is included for backward compatibility
with the Fortran FITSIO library.
ffgsdt : Get current System DaTe (GMT if available)
Return integer values of the day, month, and year
Function parameters:
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %edi, %edi
callq 0x6610
movq %rsp, %rdi
movq %rax, (%rdi)
callq 0x61d0
testq %rax, %rax
jne 0xb11c8
movq %rsp, %rdi
callq 0x6570
movl 0xc(%rax), %ecx
movl %ecx, (%r12)
movl 0x10(%rax), %ecx
incl %... | /Helioviewer-Project[P]fits2img/support/cfitsio/cfitsio-4.6.2/putkey.c |
main | int main(int argc, char *argv[]) {
int sockfd;
struct sockaddr_in servaddr;
sockfd = socket(AF_INET, SOCK_STREAM, 0);
bzero(&servaddr, sizeof(servaddr));
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(SERV_PORT);
inet_pton(AF_INET, IPADDRESS, &servaddr.sin_addr);
// inet_pton(AF_INET, const ... | subq $0x1098, %rsp # imm = 0x1098
movl $0x0, 0x1094(%rsp)
movl %edi, 0x1090(%rsp)
movq %rsi, 0x1088(%rsp)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x1060
movl %eax, 0x1084(%rsp)
leaq 0x1074(%rsp), %rdi
movl $0x10, %esi
callq 0x1120
movw $0x2, 0x1074(%rsp)
movl $0x1f98, %edi # imm = 0x1F... | /ruanyvan[P]WebServer/WebServer/tests/HTTPClient.cpp |
main | int main() {
std::pair<int, int> p[10000];
int n;
std::cin >> n;
int sum = 0;
for (int i = 0; i < n; ++i) {
std::cin >> p[i].second;
sum += p[i].second;
p[i].first = i + 1;
}
sort(p, p + n, comp);
while (sum--) {
std::cout << p[0].first << " ";... | pushq %rbp
movq %rsp, %rbp
subq $0x138d0, %rsp # imm = 0x138D0
movl $0x0, -0x4(%rbp)
leaq -0x13890(%rbp), %rax
movq %rax, %rcx
addq $0x13880, %rcx # imm = 0x13880
movq %rcx, -0x138c0(%rbp)
movq %rax, -0x138b8(%rbp)
movq -0x138b8(%rbp), %rdi
movq %rdi, -0x138c8(%rbp)
callq 0x15a0
movq -0x138c8(%rbp), %... | /KaluginaMarina[P]algorithms_and_data_structures/1604.cpp |
(anonymous namespace)::QSBROOMTest_Resume_Test::QSBROOMTest_Resume_Test() | UNODB_TEST_F(QSBROOMTest, Resume) {
qsbr_pause();
UNODB_ASSERT_EQ(get_qsbr_thread_count(), 0);
oom_test(
3, [] { unodb::this_thread().qsbr_resume(); },
[]() noexcept { UNODB_ASSERT_EQ(get_qsbr_thread_count(), 0); });
UNODB_ASSERT_EQ(get_qsbr_thread_count(), 1);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x287b0
movq -0x10(%rbp), %rax
leaq 0xb06dc(%rip), %rcx # 0xbd7b0
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /laurynas-biveinis[P]unodb/test/test_qsbr_oom.cpp |
std::thread unodb::qsbr_thread::make_qsbr_thread<(anonymous namespace)::QSBROOMTest_StartThread_Test::TestBody()::$_0::operator()() const::'lambda'()>((anonymous namespace)::QSBROOMTest_StartThread_Test::TestBody()::$_0::operator()() const::'lambda'()&&) | [[nodiscard]] static std::thread make_qsbr_thread(Function &&f,
Args &&...args) {
auto new_qsbr_per_thread = std::make_unique<qsbr_per_thread>();
return std::thread{
[inner_new_qsbr_per_thread = std::move(new_qsbr_per_thread)](
auto &&f2, a... | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x18c90
movq -0x48(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x18d00
movq -0x40(%rbp), %rdi
mov... | /laurynas-biveinis[P]unodb/./qsbr.hpp |
testing::internal::SuiteApiResolver<unodb::test::QSBRTestBase>::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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x12eea(%rip), %rsi # 0x223a0
movq %rsi, %rdi
callq 0x22370
movq %rax, -0x18(%rbp)
leaq 0x12ee7(%rip), %rsi # 0x223b0
movq %rsi, %rdi
callq 0x22370
movq %rax, -0x20(%rbp)
movb $0x1, %al
cmpq $0x0, -0x18(%rbp)
movb %al, ... | /laurynas-biveinis[P]unodb/3rd_party/googletest/googletest/include/gtest/internal/gtest-internal.h |
unodb::qsbr_per_thread::~qsbr_per_thread() | ~qsbr_per_thread() noexcept {
if (!is_qsbr_paused()) {
#ifdef UNODB_DETAIL_WITH_STATS
// TODO(laurynas): to avoid try/catch below:
// - replace std::mutex with noexcept synchronization, realistically only
// spinlock fits, which might not be good enough;
// - replace Boost.Accumulator with o... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x19760
testb $0x1, %al
jne 0x19715
movq -0x30(%rbp), %rdi
callq 0x100a0
jmp 0x1960c
jmp 0x19687
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl ... | /laurynas-biveinis[P]unodb/./qsbr.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
movq %rsp, %rbp
subq $0x150, %rsp # imm = 0x150
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x140(%rbp)
cmpl $0x2, -0xc(%rbp)
jne 0x2a1dd
movb $0x4c, %al
movb %al, -0x141(%rbp)
jmp 0x2a20d
movl -0xc(%rbp), %ecx
movb $0x54, %al
movb $0x52, %dl
movb %dl, -0x143(%rbp... | /laurynas-biveinis[P]unodb/3rd_party/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(a... | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xba20
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
movl $0xa, %esi
callq 0xb980
movq -0x88(%rbp), %rdi
movq %rax, -... | /laurynas-biveinis[P]unodb/3rd_party/googletest/googletest/src/gtest-death-test.cc |
testing::internal::DeathTestThreadWarning[abi:cxx11](unsigned long) | static std::string DeathTestThreadWarning(size_t thread_count) {
Message msg;
msg << "Death tests use fork(), which is unsafe particularly"
<< " in a threaded context. For this test, " << GTEST_NAME_ << " ";
if (thread_count == 0) {
msg << "couldn't detect the number of threads.";
} else {
msg << ... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x37a40
movq -0x38(%rbp), %rdi
leaq 0x599e0(%rip), %rsi # 0x856e6
callq 0x611d0
movq %rax, -0x30(%rbp)
jmp 0x2bd1... | /laurynas-biveinis[P]unodb/3rd_party/googletest/googletest/src/gtest-death-test.cc |
testing::internal::DefaultDeathTestFactory::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 DefaultDeathTestFactory::Create(const char* statement,
Matcher<const std::string&> matcher,
const char* file, int line,
DeathTest** test) {
UnitTestImpl* const impl = GetUnitTestImpl();
const Internal... | pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp # imm = 0x1F0
movq %rdx, -0x1b0(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq %r9, -0x38(%rbp)
callq 0x56490
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x56c90
movq %rax, -0x4... | /laurynas-biveinis[P]unodb/3rd_party/googletest/googletest/src/gtest-death-test.cc |
testing::internal::FilePath::RemoveExtension(char const*) const | FilePath FilePath::RemoveExtension(const char* extension) const {
const std::string dot_extension = std::string(".") + extension;
if (String::EndsWithCaseInsensitive(pathname_, dot_extension)) {
return FilePath(
pathname_.substr(0, pathname_.length() - dot_extension.length()));
}
return *this;
} | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xb8(%rbp)
movq %rdi, %rax
movq %rax, -0xb0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0xbcd0
movq -0xa0(%rbp), %rdx
leaq 0x51d3d(%rip)... | /laurynas-biveinis[P]unodb/3rd_party/googletest/googletest/src/gtest-filepath.cc |
testing::internal::FilePath::FindLastPathSeparator() const | const char* FilePath::FindLastPathSeparator() const {
const char* const last_sep = strrchr(c_str(), kPathSeparator);
#if GTEST_HAS_ALT_PATH_SEP_
const char* const last_alt_sep = strrchr(c_str(), kAlternatePathSeparator);
// Comparing two pointers of which only one is NULL is undefined.
if (last_alt_sep != nullp... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x574a0
movq %rax, %rdi
movl $0x2f, %esi
callq 0xb790
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
| /laurynas-biveinis[P]unodb/3rd_party/googletest/googletest/src/gtest-filepath.cc |
testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::Matcher(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Matcher<std::string>::Matcher(const std::string& s) { *this = Eq(s); } | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x57a80
movq -0x80(%rbp), %rax
leaq 0x8e92d(%rip), %rcx # 0xbe488
movq %rcx, (%rax)
movq -0x10(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0xb2b0
jmp 0x2fb6d
leaq -0x48(%rbp), %rd... | /laurynas-biveinis[P]unodb/3rd_party/googletest/googletest/src/gtest-matchers.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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x57cb0
movq -0x80(%rbp), %rax
leaq 0x8e3cd(%rip), %rcx # 0xbe4e8
movq %rcx, (%rax)
movq -0x10(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0xb2b0
jmp 0x3012d
leaq -0x48(%rbp), %rd... | /laurynas-biveinis[P]unodb/3rd_party/googletest/googletest/src/gtest-matchers.cc |
testing::internal::RE::Init(char const*) | void RE::Init(const char* regex) {
pattern_ = regex;
// NetBSD (and Android, which takes its regex implemntation from NetBSD) does
// not include the GNU regex extensions (such as Perl style character classes
// like \w) in REG_EXTENDED. REG_EXTENDED is only specified to include the
// [[:alpha:]] style char... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
movq -0x10(%rbp), %rsi
callq 0x16640
movl $0x1, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb2c0
addq $0xa, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xb040
movq %rax, -0x2... | /laurynas-biveinis[P]unodb/3rd_party/googletest/googletest/src/gtest-port.cc |
testing::internal::FormatCompilerIndependentFileLocation[abi:cxx11](char const*, int) | GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(const char* file,
int line) {
const std::string file_name(file == nullptr ? kUnknownFile : file);
if (line < 0)
return file_name;
else
return file_name + ":" + StreamableToString(... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x30e4e
leaq 0x51b4b(%rip), %rax # 0x82990
movq %rax, -0xa8(%rbp)
jmp 0x30e59
movq -0x10(%rbp), %rax
movq %rax, -0x... | /laurynas-biveinis[P]unodb/3rd_party/googletest/googletest/src/gtest-port.cc |
testing::internal::GTestLog::~GTestLog() | GTestLog::~GTestLog() {
GetStream() << ::std::endl;
if (severity_ == GTEST_FATAL) {
fflush(stderr);
posix::Abort();
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x223c0
movq %rax, -0x10(%rbp)
jmp 0x3110f
movq -0x10(%rbp), %rdi
movq 0x8de6e(%rip), %rsi # 0xbef88
callq 0xb700
jmp 0x31121
movq -0x18(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x31142
movq 0x8de9f(%rip), ... | /laurynas-biveinis[P]unodb/3rd_party/googletest/googletest/src/gtest-port.cc |
testing::internal::ParseInt32(testing::Message const&, char const*, int*) | bool ParseInt32(const Message& src_text, const char* str, int32_t* value) {
// Parses the environment variable as a decimal integer.
char* end = nullptr;
const long long_value = strtol(str, &end, 10); // NOLINT
// Has strtol() consumed all characters in the string?
if (*end != '\0') {
// No - an invalid... | pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp # imm = 0x100
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
movl $0xa, %edx
callq 0xba60
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
j... | /laurynas-biveinis[P]unodb/3rd_party/googletest/googletest/src/gtest-port.cc |
testing::internal::HasNewFatalFailureHelper::HasNewFatalFailureHelper() | HasNewFatalFailureHelper::HasNewFatalFailureHelper()
: has_new_fatal_failure_(false),
original_reporter_(
GetUnitTestImpl()->GetTestPartResultReporterForCurrentThread()) {
GetUnitTestImpl()->SetTestPartResultReporterForCurrentThread(this);
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x588f0
movq -0x30(%rbp), %rax
leaq 0x8a9b4(%rip), %rcx # 0xbdb18
movq %rcx, (%rax)
movb $0x0, 0x8(%rax)
addq $0x10, %rax
movq %rax, -0x28(%rbp)
callq 0x56490
movq %rax, -0x20(%rbp)
jmp 0x3317e
movq ... | /laurynas-biveinis[P]unodb/3rd_party/googletest/googletest/src/gtest-test-part.cc |
testing::UnitTest::GetInstance() | UnitTest* UnitTest::GetInstance() {
// CodeGear C++Builder insists on a public destructor for the
// default implementation. Use this implementation to keep good OO
// design with private destructor.
#if defined(__BORLANDC__)
static UnitTest* const instance = new UnitTest;
return instance;
#else
static Un... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpb $0x0, 0x8c191(%rip) # 0xbff10
jne 0x33dc6
leaq 0x8c188(%rip), %rdi # 0xbff10
callq 0xbd20
cmpl $0x0, %eax
je 0x33dc6
leaq 0x8c12f(%rip), %rdi # 0xbfec8
callq 0x4e670
jmp 0x33da0
leaq 0x1a969(%rip), %rdi # 0x4e710
leaq 0x8c11a(%rip), %rsi # 0xbfec8
lea... | /laurynas-biveinis[P]unodb/3rd_party/googletest/googletest/src/gtest.cc |
testing::internal::AppendUserMessage(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::Message const&) | std::string AppendUserMessage(const std::string& gtest_msg,
const Message& user_msg) {
// Appends the user message if it's non-empty.
const std::string user_msg_string = user_msg.GetString();
if (user_msg_string.empty()) {
return gtest_msg;
}
if (gtest_msg.empty()) {
retu... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x2adb0
leaq -0x38(%rbp), %rdi
callq 0xbc20
testb $0x1, %al
jne 0x3425e
jmp 0x3428a
movq -0x78... | /laurynas-biveinis[P]unodb/3rd_party/googletest/googletest/src/gtest.cc |
testing::TestInfo* testing::RegisterTest<testing::internal::InsertSyntheticTestCase(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, testing::internal::CodeLocation, bool)::$_0>(char const*, char const*, char const*, char const*, char const*, int, testing::internal::InsertSynthetic... | TestInfo* RegisterTest(const char* test_suite_name, const char* test_name,
const char* type_param, const char* value_param,
const char* file, int line, Factory factory) {
using TestT = typename std::remove_pointer<decltype(factory())>::type;
class FactoryImpl : public ... | pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movq 0x10(%rbp), %rax
movq %rax, -0x120(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x118(%rbp)
leaq -0x51(%rbp), %rdi... | /laurynas-biveinis[P]unodb/3rd_party/googletest/googletest/include/gtest/gtest.h |
testing::internal::(anonymous namespace)::PositiveAndNegativeUnitTestFilter::PositiveAndNegativeUnitTestFilter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | explicit PositiveAndNegativeUnitTestFilter(const std::string& filter) {
std::vector<std::string> positive_and_negative_filters;
// NOTE: `SplitString` always returns a non-empty container.
SplitString(filter, '-', &positive_and_negative_filters);
const auto& positive_filter = positive_and_negative_filt... | pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp # imm = 0x1F0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x1d8(%rbp)
movq %rdi, %rax
movq %rax, -0x1e0(%rbp)
callq 0x52430
movq -0x1d8(%rbp), %rdi
addq $0x50, %rdi
movq %rdi, -0x1d0(%rbp)
callq 0x52430
leaq -0x28(%rbp), %rdi
mov... | /laurynas-biveinis[P]unodb/3rd_party/googletest/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 0x870e5(%rip), %rcx # 0xbdb40
movq %rcx, (%rax)
callq 0x56490
movq %rax, -0x18(%rbp)
jmp 0x36a69
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, -0x10(%rbp)
cmpl $0x1, 0x8(%rax)
jne 0x36a90
m... | /laurynas-biveinis[P]unodb/3rd_party/googletest/googletest/src/gtest.cc |
testing::internal::edit_distance::(anonymous namespace)::Hunk::Hunk(unsigned long, unsigned long) | Hunk(size_t left_start, size_t right_start)
: left_start_(left_start),
right_start_(right_start),
adds_(),
removes_(),
common_() {} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movq $0x0, 0x20(%rdi)
addq $0x28, ... | /laurynas-biveinis[P]unodb/3rd_party/googletest/googletest/src/gtest.cc |
testing::internal::edit_distance::(anonymous namespace)::Hunk::PrintTo(std::ostream*) | void PrintTo(std::ostream* os) {
PrintHeader(os);
FlushEdits();
for (std::list<std::pair<char, const char*> >::const_iterator it =
hunk_.begin();
it != hunk_.end(); ++it) {
*os << it->first << it->second << "\n";
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x10(%rbp), %rsi
callq 0x52590
movq -0x38(%rbp), %rdi
callq 0x524f0
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
callq 0x68890
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%... | /laurynas-biveinis[P]unodb/3rd_party/googletest/googletest/src/gtest.cc |
testing::internal::CmpHelperSTREQ(char const*, char const*, char const*, char const*) | AssertionResult CmpHelperSTREQ(const char* lhs_expression,
const char* rhs_expression, const char* lhs,
const char* rhs) {
if (String::CStringEquals(lhs, rhs)) {
return AssertionSuccess();
}
return EqFailure(lhs_expression, rhs_expression, PrintTo... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%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 0x379a0
testb $0x1, %al
jne 0x39fe0
jmp 0x39ff1
m... | /laurynas-biveinis[P]unodb/3rd_party/googletest/googletest/src/gtest.cc |
testing::internal::JsonUnitTestResultPrinter::PrintJsonUnitTest(std::ostream*, testing::UnitTest const&) | void JsonUnitTestResultPrinter::PrintJsonUnitTest(std::ostream* stream,
const UnitTest& unit_test) {
const std::string kTestsuites = "testsuites";
const std::string kIndent = Indent(2);
*stream << "{\n";
OutputJsonKey(stream, kTestsuites, "tests", unit_test.rep... | pushq %rbp
movq %rsp, %rbp
subq $0x380, %rsp # imm = 0x380
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x238(%rbp)
callq 0xbcd0
movq -0x238(%rbp), %rdx
leaq 0x3d96d(%rip), %rsi # 0x8515e
leaq -0x30(%rbp), %rdi
callq 0xf3b0
jmp 0x477fc
leaq -0x31(%rbp), %rdi
callq 0xb75... | /laurynas-biveinis[P]unodb/3rd_party/googletest/googletest/src/gtest.cc |
void CCEXP::AddTable<int>(CCEXP::CCEXP&, char const*, char const*, unsigned long) | inline void AddTable (
CCEXP &obj,
const char* matname,
const char* typeName,
size_t MaxRows = 0
) {
obj.ErrorId = 0;
if (!obj.isActive) return;
CECS_ERR(CCEXPECS,obj.Status != CCEXPORTMAT_READY,"[%s]: AddTable():: CCEXP object has wrong status." , obj.SavingFile );
obj.Status = CCEXPORTMAT_ACTIVE;
size_t rd =... | pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x8(%rbp), %rax
testb $0x1, 0x10(%rax)
jne 0x2e015
jmp 0x2e376
movq -0x8(%rbp), %rax
cmpl $0x1, 0x8(%rax)
je 0x2e0d6
leaq 0x27509(%rip)... | /terablade2001[P]CCEXP/C++/test/../src/include/CCEXP.hpp |
CCEXP::CCEXPMat<int>::CCEXPMat() | MVECTOR<T>* CCEXPMat<T>::getDataRowPtr(size_t row) {
const size_t N = data.size();
CECS_ERRN(CCEXPECS,row >= N,"CCEXPMat::getDataRowPtr():: Requested Row is not exist yet! (row(=" __ZU__ ") >= N(=" __ZU__ "))", row, N);
MVECTOR<T>* pRow = nullptr;
#ifdef __CCEXP__USE_VECTOR_INSTEAD_OF_LIST
pRow = &data[row];
#el... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x30620
movq -0x10(%rbp), %rdi
leaq 0x2f464(%rip), %rax # 0x65a38
addq $0x10, %rax
movq %rax, (%rdi)
movb $0x0, 0x8a(%rdi)
movb $0x1, 0x8b(%rdi)
addq $0x90, %rdi
callq 0x36850
callq 0x260a0
movq %rax... | /terablade2001[P]CCEXP/C++/test/../src/include/CCEXP.hpp |
CCEXP::CCEXPMat<int>::NewRow(int) | int CCEXPMat<T>::NewRow(int empty) {
if (IgnoreM) return 0;
const size_t N = data.size();
CECS_ERRI(CCEXPECS,N >= _maxRows,"CCEXPMat::NewRow():: Maximum Rows (=" __ZU__ ") already Reached!", _maxRows);
newRowFlag=true;
if (empty == 1) {
MVECTOR<T> dl; dl.clear(); data.push_back(dl);
}
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
testb $0x1, 0x8a(%rax)
je 0x3698f
movl $0x0, -0x4(%rbp)
jmp 0x36ae9
movq -0x78(%rbp), %rdi
addq $0x90, %rdi
callq 0x37b00
movq -0x78(%rbp), %rcx
movq %rax, -0x20(%rbp)
movq -0x20(%rbp)... | /terablade2001[P]CCEXP/C++/test/../src/include/CCEXP.hpp |
CCEXP::CCEXPMat<int>::AppendRow(unsigned long, int*, unsigned long) | int CCEXPMat<T>::AppendRow(size_t row, T* ptr, size_t n) {
if (IgnoreM) return 0;
MVECTOR<T>* it = getDataRowPtr(row); CECS_ERRI(CCEXPECS, it == nullptr, "CCEXPMat::AppendRow():: 'it' is nullptr");
const size_t currentData = (*it).size();
(*it).resize(currentData + n);
T* Dptr = (*it).data();
memcpy(&Dptr[current... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
testb $0x1, 0x8a(%rax)
je 0x3f4f5
movl $0x0, -0x4(%rbp)
jmp 0x3f60e
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x38e50
movq %rax,... | /terablade2001[P]CCEXP/C++/test/../src/include/CCEXP.hpp |
CCEXP::CCEXPMat<unsigned long>::AddValue(unsigned long) | int CCEXPMat<T>::AddValue(T val) {
if (IgnoreM) return 0; // This is not an error - We just ignore the Table...
const size_t N = data.size();
if ((N == 0) || (newRowFlag==true)) {
MVECTOR<T> dl; dl.clear(); data.push_back(dl);
newRowFlag = false;
}
data.back().push_back(val);
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
testb $0x1, 0x8a(%rax)
je 0x407f0
movl $0x0, -0x4(%rbp)
jmp 0x4089b
movq -0x78(%rbp), %rdi
addq $0x90, %rdi
callq 0x3a850
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x4081f
movq ... | /terablade2001[P]CCEXP/C++/test/../src/include/CCEXP.hpp |
void CCEXP::LoadTable<float>(CCEXP::CCEXP&, char const*, char const*) | inline void LoadTable(CCEXP &obj, const char* name, const char* type) {
obj.ErrorId = 0;
if (!obj.isActive) return;
int prevStatus = obj.Status;
// If any error occurs, then it should be critical error!
obj.Status = CCEXPORTMAT_ACTIVE;
CECS_ERR(CCEXPECS,(prevStatus != CCEXPORTMAT_INIT) && (prevStatus != CCEXPORTM... | pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x328, %rsp # imm = 0x328
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x10(%rbp), %rax
testb $0x1, 0x10(%rax)
jne 0x45892
jmp 0x46636
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, ... | /terablade2001[P]CCEXP/C++/test/../src/include/CCEXP.hpp |
ns_MVECTOR::MVECTOR<float>* CCEXP::getRow<float>(CCEXP::CCEXP&, char const*, unsigned long) | inline MVECTOR<T>* getRow(
CCEXP &obj, const char* matname, size_t row
) {
obj.ErrorId = 0;
size_t sel = obj.getTableIndexByName(matname);
CECS_ERRN(CCEXPECS,sel == MAXSIZE_T,"[%s]: getRow():: Failed to find table with name [%s]!", obj.SavingFile, matname);
MVECTOR<T>* vret = getRow<T>(obj, sel, row);
return vret... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x21d40
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x260a0
movq %rax, %rcx
mov... | /terablade2001[P]CCEXP/C++/test/../src/include/CCEXP.hpp |
float* CCEXP::getRow<float>(CCEXP::CCEXP&, char const*, unsigned long, unsigned long&) | inline T* getRow(
CCEXP &obj, const char* matname, size_t row, size_t &cols
) {
obj.ErrorId = 0;
size_t sel = obj.getTableIndexByName(matname);
CECS_ERRN(CCEXPECS,sel == MAXSIZE_T,"[%s]:: getRow():: Failed to find table with name [%s]!", obj.SavingFile, matname);
T* vret = getRow<T>(obj, sel, row, cols);
return v... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x21d40
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
callq 0x26... | /terablade2001[P]CCEXP/C++/test/../src/include/CCEXP.hpp |
CECS::Shutdown() | void CECS::Shutdown(void) {
if (pCECS != NULL) { CECS_Shutdown(pCECS); pCECS = NULL; }
if (EcsName != NULL) { free(EcsName); EcsName = NULL; }
if (ModName != NULL) { free(ModName); ModName = NULL; }
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, 0x10(%rax)
je 0x531f4
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x51310
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x53215
movq -0x10(%rbp), %r... | /terablade2001[P]CCEXP/sub_modules/CECS/C++/src/CECS.cpp |
aGLTextureUpdate | void aGLTextureUpdate(AGLTexture *tex, const AGLTextureData *data) {
ATTO_ASSERT(data->type == tex->type);
struct A__GLTextureFormat tf = getTextureFormat(data->format);
a__gl_texture_upload_func *upload_func = NULL;
GLenum binding = 0;
switch (data->type) {
case AGLTT_1D:
upload_func = &a__GLTexureUpload1... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
je 0x3d49
leaq 0x45d4(%rip), %rdi # 0x82f9
leaq 0x45e8(%rip), %rsi # 0x8314
movl $0x42d, %edx # imm = 0x42D
leaq 0x462b(%rip), %r... | /w23[P]atto/include/atto/gl.h |
getTextureFormat | static struct A__GLTextureFormat getTextureFormat(AGLTextureFormat aformat) {
struct A__GLTextureFormat tf = {0};
switch (aformat) {
case AGLTF_U8_R:
tf.internal = tf.format = GL_LUMINANCE;
tf.type = GL_UNSIGNED_BYTE;
break;
case AGLTF_U8_RA:
tf.internal = tf.format = GL_LUMINANCE_ALPHA;
tf.type = GL_UNSI... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x14(%rbp)
movl $0x0, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x30(%rbp)
subq $0x9, %rax
ja 0x4008
movq -0x30(%rbp), %rax
leaq 0x412e(%rip), %rcx # 0x8024
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1909, -0xc(%r... | /w23[P]atto/include/atto/gl.h |
aGLDraw | void aGLDraw(const AGLDrawSource *src, const AGLDrawMerge *merge, const AGLDrawTarget *target) {
ATTO_GL_PROFILE_PREAMBLE
a__GLTargetBind(target);
a__GLDepthBind(merge->depth);
a__GLBlendBind(&merge->blend);
a__GLProgramBind(src->program, src->uniforms.p, src->uniforms.n);
a__GLAttribsBind(src->attribs.p, src->... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x47b0
movq -0x10(%rbp), %rax
movq 0x2c(%rax), %rdi
callq 0x4860
movq -0x10(%rbp), %rdi
callq 0x48f0
movq -0x8(%rbp), %rax
movl (%rax), %edi
movq -0x8(%rbp), %rax
movq 0x8(%rax), ... | /w23[P]atto/include/atto/gl.h |
a__GLTargetBind | static void a__GLTargetBind(const AGLDrawTarget *target) {
ATTO_GL_PROFILE_PREAMBLE
a__GLFramebufferBind(target->framebuffer);
if (target->viewport.x != a__gl_state.viewport.x || target->viewport.y != a__gl_state.viewport.y ||
target->viewport.w != a__gl_state.viewport.w || target->viewport.h != a__gl_state.viewp... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x5b10
movq -0x8(%rbp), %rax
movl (%rax), %eax
cmpl 0x6e37(%rip), %eax # 0xb60c
jne 0x4804
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
cmpl 0x6e2c(%rip), %eax # 0xb610
jne 0x4804
movq -0x8(%rbp),... | /w23[P]atto/include/atto/gl.h |
a__GLDepthBind | static void a__GLDepthBind(AGLDepthParams depth) {
AGLDepthParams *cur = &a__gl_state.depth;
if (depth.mode != cur->mode) {
if (depth.mode == AGLDM_Disabled) {
AGL__CALL(glDisable(GL_DEPTH_TEST));
} else {
AGL__CALL(glEnable(GL_DEPTH_TEST));
AGL__CALL(glDepthMask(depth.mode == AGLDM_TestAndWrite));
}
... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x6b4d(%rip), %rax # 0xb3c0
addq $0x38, %rax
movq %rax, -0x10(%rbp)
movl -0x8(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
je 0x48bf
cmpl $0x0, -0x8(%rbp)
jne 0x4898
movl $0xb71, %edi # imm = 0xB71
callq 0x30e0
jmp 0x48b6
mov... | /w23[P]atto/include/atto/gl.h |
a__GLBlendBind | static void a__GLBlendBind(const AGLBlendParams *blend) {
AGLBlendParams *cur = &a__gl_state.blend;
if (blend->enable != cur->enable) {
cur->enable = blend->enable;
if (!blend->enable)
AGL__CALL(glDisable(GL_BLEND));
else
AGL__CALL(glEnable(GL_BLEND));
}
if (!cur->enable)
return;
if (blend->color.r... | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x6abd(%rip), %rax # 0xb3c0
addq $0xc, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
je 0x4946
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq ... | /w23[P]atto/include/atto/gl.h |
a__GLProgramBind | void a__GLProgramBind(AGLProgram program, const AGLProgramUniform *uniforms, int nuniforms) {
ATTO_GL_PROFILE_START
int i, texture_unit = 0;
AGL__CALL(glUseProgram(program));
for (i = 0; i < nuniforms; ++i) {
ATTO_GL_PROFILE_START
const int loc = uniforms[i]._.location;
if (loc == -1) { /*AGL_PRINTFLN("Skippi... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x4(%rbp), %edi
callq 0x31f0
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x4dfb
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
shlq $0x5, %rcx
addq %... | /w23[P]atto/include/atto/gl.h |
a__GLAttribsBind | static void a__GLAttribsBind(const AGLAttribute *attribs, int nattribs) {
ATTO_GL_PROFILE_START
int i;
++a__gl_state.attribs_serial;
for (i = 0; i < nattribs; ++i) {
const AGLAttribute *a = attribs + i;
const GLint loc = a->_.location;
GLint buffer = a->buffer ? a->buffer->name : 0;
if (loc < 0) { /*AGL_PRI... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl 0x65db(%rip), %eax # 0xb400
addl $0x1, %eax
movl %eax, 0x65d2(%rip) # 0xb400
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x503b
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
imulq $0x30, %... | /w23[P]atto/include/atto/gl.h |
a__appProcessXButton | static void a__appProcessXButton(const XEvent *e) {
unsigned int button = 0;
ATimeUs timestamp = aAppTime();
int dx, dy;
unsigned int buttons_changed_bits;
const unsigned int pressed = e->xbutton.type == ButtonPress;
switch (e->xbutton.button) {
case Button1: button = AB_Left; break;
case Button2: button = AB_... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
callq 0x6790
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
subl $0x4, %eax
sete %al
movzbl %al, %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x54(%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp... | /w23[P]atto/src/app_x11.c |
a__appProcessXMotion | static void a__appProcessXMotion(const XEvent *e) {
ATimeUs timestamp = aAppTime();
int dx = e->xmotion.x - a__app_state.pointer.x, dy = e->xmotion.y - a__app_state.pointer.y;
a__app_state.pointer.x = e->xmotion.x;
a__app_state.pointer.y = e->xmotion.y;
if (a__app_state.grabbed) {
if (e->xmotion.x == (int)a__a... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
callq 0x6790
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x40(%rax), %eax
subl 0x4d33(%rip), %eax # 0xbff4
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x44(%rax), %eax
subl 0x4d27(%rip), %eax # 0xbff8
movl %eax, -0x14(%rbp)
movq -0x8... | /w23[P]atto/src/app_x11.c |
a__appProcessXKeyEvent | static void a__appProcessXKeyEvent(XEvent *e) {
ATimeUs timestamp = aAppTime();
AKey key = AK_Unknown;
int down = KeyPress == e->type;
switch (XLookupKeysym(&e->xkey, 0)) {
#define ATTOMAPK__(x, a) \
case XK_##x: key = AK_##a; break;
ATTOMAPK__(BackSpace, Backspace)
ATTOMAPK__(Tab, Tab)
ATTOMAPK__(Return, En... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x6790
movl %eax, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
subl $0x2, %eax
sete %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x3030
movq %rax, %rcx
movq %rcx, -0x20(%rbp)
s... | /w23[P]atto/src/app_x11.c |
aAppGrabInput | void aAppGrabInput(int grab) {
if (grab == a_app_state->grabbed)
return;
if (grab) {
XGrabPointer(
a__x11.display, a__x11.window, True, 0, GrabModeAsync, GrabModeAsync, a__x11.window, None, CurrentTime);
XFixesHideCursor(a__x11.display, a__x11.window);
XWarpPointer(a__x11.display, None, a__x11.window, 0, 0... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movq 0x3633(%rip), %rcx # 0xb3a8
cmpl 0x428(%rcx), %eax
jne 0x7d82
jmp 0x7e4f
cmpl $0x0, -0x4(%rbp)
je 0x7e23
movq 0x4275(%rip), %rdi # 0xc008
movq 0x4276(%rip), %rsi # 0xc010
movq 0x426f(%rip), %rax # 0xc010
mov... | /w23[P]atto/src/app_x11.c |
archs_enable | static void archs_enable(void)
{
static bool initialized = false;
if (initialized)
return;
#ifdef CAPSTONE_HAS_ARM
ARM_enable();
#endif
#ifdef CAPSTONE_HAS_ARM64
AArch64_enable();
#endif
#ifdef CAPSTONE_HAS_MIPS
Mips_enable();
#endif
#ifdef CAPSTONE_HAS_POWERPC
PPC_enable();
#endif
#ifdef CAPSTONE_HAS_SPARC
... | cmpb $0x0, 0x24c678(%rip) # 0x290f64
jne 0x44922
pushq %rax
callq 0x44200
callq 0x44380
callq 0x44270
callq 0x44780
callq 0x446b0
callq 0x442a0
callq 0x44110
callq 0x44340
movb $0x1, 0x24c646(%rip) # 0x290f64
addq $0x8, %rsp
retq
| /bughoho[P]capstone/cs.c |
cs_close | CAPSTONE_EXPORT
cs_err cs_close(csh *handle)
{
struct cs_struct *ud;
if (*handle == 0)
// invalid handle
return CS_ERR_CSH;
ud = (struct cs_struct *)(*handle);
if (ud->printer_info)
cs_mem_free(ud->printer_info);
cs_mem_free(ud->insn_cache);
memset(ud, 0, sizeof(*ud));
cs_mem_free(ud);
// invalidate... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0x44af4
movq %rdi, %rbx
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x44ac6
movq 0x158344(%rip), %rax # 0x19ce08
callq *(%rax)
movq 0x15833b(%rip), %r15 # 0x19ce08
movq 0x78(%r14), %rdi
callq *(%r15)
xorl %ebp, %ebp
movl $0... | /bughoho[P]capstone/cs.c |
cs_reg_read | CAPSTONE_EXPORT
bool cs_reg_read(csh ud, const cs_insn *insn, unsigned int reg_id)
{
struct cs_struct *handle;
if (!ud)
return false;
handle = (struct cs_struct *)(uintptr_t)ud;
if (!handle->detail) {
handle->errnum = CS_ERR_DETAIL;
return false;
}
if(!insn->id) {
handle->errnum = CS_ERR_SKIPDATA;
re... | testq %rdi, %rdi
je 0x45590
movl $0x7, %eax
cmpl $0x0, 0x68(%rdi)
je 0x4558d
cmpl $0x0, (%rsi)
je 0x45588
movq 0xe8(%rsi), %rcx
testq %rcx, %rcx
je 0x4558d
movzbl 0xc(%rcx), %esi
testq %rsi, %rsi
setne %al
je 0x45587
movzbl (%rcx), %edi
movb $0x1, %al
cmpl %edx, %edi
je 0x45587
movl $0x1, %edi
movq %rdi, %rax
cmpq %rdi... | /bughoho[P]capstone/cs.c |
cs_op_count | CAPSTONE_EXPORT
int cs_op_count(csh ud, const cs_insn *insn, unsigned int op_type)
{
struct cs_struct *handle;
unsigned int count = 0, i;
if (!ud)
return -1;
handle = (struct cs_struct *)(uintptr_t)ud;
if (!handle->detail) {
handle->errnum = CS_ERR_DETAIL;
return -1;
}
if(!insn->id) {
handle->errnum =... | movl $0xffffffff, %eax # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x457de
cmpl $0x0, 0x68(%rdi)
je 0x45679
cmpl $0x0, (%rsi)
je 0x45681
movq 0xe8(%rsi), %rcx
testq %rcx, %rcx
je 0x45679
movl $0x0, 0x58(%rdi)
movl (%rdi), %esi
cmpq $0x7, %rsi
ja 0x457d7
leaq 0x849e4(%rip), %rax # 0xca020
movslq (%rax,%rsi,4), %rsi... | /bughoho[P]capstone/cs.c |
SStream_concat0 | void SStream_concat0(SStream *ss, char *s)
{
#ifndef CAPSTONE_DIET
unsigned int len = (unsigned int) strlen(s);
memcpy(ss->buffer + ss->index, s, len);
ss->index += len;
ss->buffer[ss->index] = '\0';
#endif
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x441d0
movq %rax, %r15
movslq 0x200(%r14), %rdi
addq %r14, %rdi
movl %r15d, %edx
movq %rbx, %rsi
callq 0x44420
addl 0x200(%r14), %r15d
movl %r15d, 0x200(%r14)
movslq %r15d, %rax
movb $0x0, (%r14,%rax)
popq %rbx
popq %r14
popq %r15
r... | /bughoho[P]capstone/SStream.c |
SStream_concat | void SStream_concat(SStream *ss, const char *fmt, ...)
{
#ifndef CAPSTONE_DIET
va_list ap;
int ret;
va_start(ap, fmt);
ret = cs_vsnprintf(ss->buffer + ss->index, sizeof(ss->buffer) - (ss->index + 1), fmt, ap);
va_end(ap);
ss->index += ret;
#endif
} | pushq %rbx
subq $0xd0, %rsp
movq %rsi, %r10
movq %rdi, %rbx
leaq 0x20(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x45df3
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
m... | /bughoho[P]capstone/SStream.c |
printInt64Bang | void printInt64Bang(SStream *O, int64_t val)
{
if (val >= 0) {
if (val > HEX_THRESHOLD)
SStream_concat(O, "#0x%"PRIx64, val);
else
SStream_concat(O, "#%"PRIu64, val);
} else {
if (val <- HEX_THRESHOLD)
SStream_concat(O, "#-0x%"PRIx64, -val);
else
SStream_concat(O, "#-%"PRIu64, -val);
}
} | movq %rsi, %rax
testq %rsi, %rsi
js 0x45e57
cmpq $0xa, %rax
jl 0x45e6c
leaq 0x84441(%rip), %rsi # 0xca296
jmp 0x45e73
movq %rax, %rdx
negq %rdx
cmpq $-0xa, %rax
jg 0x45e78
leaq 0x84438(%rip), %rsi # 0xca2a2
jmp 0x45e7f
leaq 0x8442a(%rip), %rsi # 0xca29d
movq %rax, %rdx
jmp 0x45e7f
leaq 0x8442b(%rip), %rsi ... | /bughoho[P]capstone/SStream.c |
printInt64 | void printInt64(SStream *O, int64_t val)
{
if (val >= 0) {
if (val > HEX_THRESHOLD)
SStream_concat(O, "0x%"PRIx64, val);
else
SStream_concat(O, "%"PRIu64, val);
} else {
if (val <- HEX_THRESHOLD)
SStream_concat(O, "-0x%"PRIx64, -val);
else
SStream_concat(O, "-%"PRIu64, -val);
}
} | movq %rsi, %rax
testq %rsi, %rsi
js 0x45ebd
cmpq $0xa, %rax
jl 0x45ed2
leaq 0x101fdf(%rip), %rsi # 0x147e9a
jmp 0x45ed9
movq %rax, %rdx
negq %rdx
cmpq $-0xa, %rax
jg 0x45ede
leaq 0x843d3(%rip), %rsi # 0xca2a3
jmp 0x45ee5
leaq 0x101fca(%rip), %rsi # 0x147ea3
movq %rax, %rdx
jmp 0x45ee5
leaq 0x843c6(%rip), %rsi... | /bughoho[P]capstone/SStream.c |
Thumb_getInstruction | static DecodeStatus _Thumb_getInstruction(cs_struct *ud, MCInst *MI, const uint8_t *code, size_t code_len,
uint16_t *Size, uint64_t Address)
{
uint8_t bytes[4];
uint16_t insn16;
DecodeStatus result;
bool InITBlock;
unsigned Firstcond, Mask;
uint32_t NEONLdStInsn, insn32, NEONDataInsn, NEONCryptoInsn, NEONv8Ins... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x2, %rdx
jae 0x46209
xorl %ebp, %ebp
jmp 0x462ed
movq %r8, %r15
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %r14
movq 0x310(%rcx), %rax
movq 0xe8(%rax), %rdi
testq %rdi, %rdi
je 0x46261
addq $0x30, %rdi
movl $0x5c8, %edx ... | /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeDoubleRegLoad | static DecodeStatus DecodeDoubleRegLoad(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rt = fieldFromInstruction_4(Insn, 12, 4);
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned pred = fieldFromInstruction_4(Insn, 28, 4);
if (R... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
shrl $0xc, %eax
andl $0xf, %eax
movl %esi, %r15d
shrl $0x10, %r15d
andl $0xf, %r15d
xorl %r12d, %r12d
cmpl $0xf, %r15d
setne %r12b
xorl %ebp, %ebp
cmpl $0xd, %eax
ja 0x4ff45
xorl %ecx, %ecx
btl $0xc, %ebx
setae %cl
le... | /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodePostIdxReg | static DecodeStatus DecodePostIdxReg(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rm = fieldFromInstruction_4(Insn, 0, 4);
unsigned add = fieldFromInstruction_4(Insn, 4, 1);
if (!Check(&S, DecodeGPRnopcRegisterClass(Inst, Rm, Address, Dec... | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
andl $0xf, %esi
callq 0x4f3a3
movl %eax, %r14d
movb $0x1, %cl
cmpl $0x3, %eax
je 0x4ffe1
cmpl $0x1, %r14d
je 0x4ffe1
testl %r14d, %r14d
je 0x4ffdf
movl $0x3, %r14d
xorl %ecx, %ecx
xorl %eax, %eax
testb %cl, %cl
je 0x4fffa
shrl $0x4, %ebp
andl $0x1, %ebp
m... | /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeLDR | static DecodeStatus DecodeLDR(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Cond;
unsigned Rn = fieldFromInstruction_4(Val, 16, 4);
unsigned Rt = fieldFromInstruction_4(Val, 12, 4);
unsigned Rm = fieldFromInstruction_4(Val, 0, 4);
Rm |= (f... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %ebp
shrl $0x10, %ebp
andl $0xf, %ebp
shrl $0xc, %esi
andl $0xf, %esi
xorl %eax, %eax
cmpl %esi, %ebp
setne %al
testl $0xf00, %ebx # imm = 0xF00
leal 0x1(%rax,%rax), %eax
movl $0x1, %r15d
cmovel %eax, %r15d
call... | /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeArmMOVTWInstruction | static DecodeStatus DecodeArmMOVTWInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rd = fieldFromInstruction_4(Insn, 12, 4);
unsigned pred = fieldFromInstruction_4(Insn, 28, 4);
unsigned imm = 0;
imm |= (fieldFromInstruction_4(I... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %r12d
shrl $0xc, %r12d
andl $0xf, %r12d
callq 0x44490
movl $0x3, %r15d
cmpl $0xd8, %eax
jne 0x50167
movq %r14, %rdi
movl %r12d, %esi
callq 0x4f3a3
movl %eax, %r15d
movb $0x1, %al
cmpl $0x3, %r15d
je 0x50161
cmpl $0x1, %r15... | /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeAddrMode2IdxInstruction | static DecodeStatus DecodeAddrMode2IdxInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
ARM_AM_AddrOpc Op;
ARM_AM_ShiftOpc Opc;
bool writeback;
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned Rt = fieldFromInstruction_4(Insn, 1... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %ebp
shrl $0x10, %ebp
andl $0xf, %ebp
movl %esi, %r12d
shrl $0xc, %r12d
andl $0xf, %r12d
callq 0x44490
addl $0xfffffe62, %eax # imm = 0xFFFFFE62
movl %ebp, %r15d
cmpl $0x1b, %eax
ja 0x50232
movl... | /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeAddrModeImm12Operand | static DecodeStatus DecodeAddrModeImm12Operand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned add = fieldFromInstruction_4(Val, 12, 1);
unsigned imm = fieldFromInstruction_4(Val, 0, 12);
unsigned Rn = fieldFromInstruction_4(Val, 13, 4);
if... | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
shrl $0xc, %eax
movl %eax, %ebp
andl $0x1, %ebp
andl $0xfff, %ebx # imm = 0xFFF
andl $0x1e, %eax
leaq 0x7d5f1(%rip), %rcx # 0xcda00
movzwl (%rax,%rcx), %esi
callq 0x44520
movl %ebx, %eax
negl %eax
testl %ebp, %ebp
cmovnel %e... | /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeLDRPreImm | static DecodeStatus DecodeLDRPreImm(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned pred;
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned Rt = fieldFromInstruction_4(Insn, 12, 4);
unsigned imm = fieldFromInstruction_4(Insn, 0, 12... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %r12d
shrl $0x10, %r12d
andl $0xf, %r12d
movl %esi, %eax
shrl $0xc, %eax
andl $0xf, %eax
movl %esi, %ecx
andl $0xfff, %ecx # imm = 0xFFF
movl %r12d, %edx
shll $0xd, %edx
orl %ecx, %edx
movl... | /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeSORegMemOperand | static DecodeStatus DecodeSORegMemOperand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
ARM_AM_ShiftOpc ShOp;
unsigned shift;
unsigned Rn = fieldFromInstruction_4(Val, 13, 4);
unsigned Rm = fieldFromInstruction_4(Val, 0, 4);
unsigned type = fieldF... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
shrl $0x5, %eax
andl $0x3, %eax
leaq 0x7b0f0(%rip), %rcx # 0xcb6fc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x4000, %eax # imm = 0x4000
jmp 0x50631
movl $0x2000, ... | /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeSTRPreReg | static DecodeStatus DecodeSTRPreReg(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned pred;
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned Rt = fieldFromInstruction_4(Insn, 12, 4);
unsigned imm = fieldFromInstruction_4(Insn, 0, 12... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %eax
shrl $0x10, %eax
andl $0xf, %eax
movl %esi, %r12d
shrl $0xc, %r12d
andl $0xf, %r12d
movl %esi, %ecx
andl $0xfff, %ecx # imm = 0xFFF
movl %eax, %edx
shll $0xd, %edx
orl %ecx, %edx
movl ... | /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeLDRPreReg | static DecodeStatus DecodeLDRPreReg(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned pred, Rm;
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned Rt = fieldFromInstruction_4(Insn, 12, 4);
unsigned imm = fieldFromInstruction_4(Insn, 0... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl %esi, %r12d
shrl $0x10, %r12d
andl $0xf, %r12d
movl %esi, %eax
shrl $0xc, %eax
andl $0xf, %eax
movl %esi, %ecx
andl $0xfff, %ecx # imm = 0xFFF
movl %r12d, %edx
shll $0xd, %edx
orl %ecx, %edx
movl... | /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeBitfieldMaskOperand | static DecodeStatus DecodeBitfieldMaskOperand(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
// This operand encodes a mask of contiguous zeros between a specified MSB
// and LSB. To decode it, we create the mask of all bits MSB-and-lower,
// the mask of all bits LSB-and-lower, and then xor ... | pushq %rbx
movl %esi, %edx
movl %esi, %eax
shrl $0x5, %eax
andl $0x1f, %eax
andl $0x1f, %edx
xorl %r8d, %r8d
cmpl %eax, %edx
setbe %r8b
cmovael %eax, %edx
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
movl %eax, %ecx
shll %cl, %esi
leal 0x1(,%r8,2), %ebx
movl $0xffffffff, %r8d # imm = 0xFFFFFFFF
xorl %r8d, %esi... | /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeMemMultipleWritebackInstruction | static DecodeStatus DecodeMemMultipleWritebackInstruction(MCInst *Inst,
unsigned Insn, uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned pred = fieldFromInstruction_4(Insn, 28, 4);
unsigned reglist = fieldFromInstruction_... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
movl %esi, %ebp
shrl $0x1c, %ebp
cmpl $0xf, %ebp
jne 0x50a44
movq %rbx, %rdi
callq 0x44490
xorl %ebp, %ebp
leal -0x8e(%rax), %ecx
cmpl $0x8, %ecx
ja 0x50ac5
leaq 0x7ad0b(%rip), %rax # 0xcb73c
movslq (%rax,%rcx,4), %rcx
addq %rax... | /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeBranchImmInstruction | static DecodeStatus DecodeBranchImmInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned pred = fieldFromInstruction_4(Insn, 28, 4);
unsigned imm = fieldFromInstruction_4(Insn, 0, 24) << 2;
if (pred == 0xF) {
MCInst_setOpcode(Inst, ... | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %r14d
shrl $0x1c, %r14d
cmpl $0xf, %r14d
jne 0x50c0a
movq %rbx, %rdi
movl $0x3b, %esi
callq 0x44180
movl %ebp, %eax
shll $0x8, %eax
shrl $0x11, %ebp
andl $0x80, %ebp
orl %eax, %ebp
sarl $0x6, %ebp
movslq %ebp, %rsi
movq %rbx, %rdi
callq 0x44040... | /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeCopMemInstruction | static DecodeStatus DecodeCopMemInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned pred = fieldFromInstruction_4(Insn, 28, 4);
unsigned CRd = fieldFromInstruction_4(Insn, 12, 4);
unsigned coproc = fieldFromInstruction_4(Insn, 8, 4);... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x44490
cmpl $0x934, %eax # imm = 0x934
jg 0x50c6a
leal -0x86(%rax), %ecx
cmpl $0x8, %ecx
jb 0x50c7f
addl $0xfffffe7a, %eax # imm = 0xFFFFFE7A
cmpl $0x8, %eax
jb 0x50c7f
jmp 0x50c95
leal -... | /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeMRRC2 | static DecodeStatus DecodeMRRC2(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned CRm = fieldFromInstruction_4(Val, 0, 4);
unsigned opc1 = fieldFromInstruction_4(Val, 4, 4);
unsigned cop = fieldFromInstruction_4(Val, 8, 4);
unsigned Rt = fiel... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %eax
andl $0xe00, %eax # imm = 0xE00
xorl %ebp, %ebp
cmpl $0xa00, %eax # imm = 0xA00
je 0x50eba
movl %esi, %r14d
movq %rdi, %rbx
movl %esi, %r15d
shrl $0x10, %r15d
andl $0xf, %r15d
shrl $0x8, %esi
andl $0xf, %e... | /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeGPRwithAPSRRegisterClass | static DecodeStatus DecodeGPRwithAPSRRegisterClass(MCInst *Inst, unsigned RegNo,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
if (RegNo == 15) {
MCOperand_CreateReg0(Inst, ARM_APSR_NZCV);
return MCDisassembler_Success;
}
Check(&S, DecodeGPRRegisterClass(Inst, RegNo, Addr... | pushq %rax
cmpl $0xf, %esi
jne 0x50ee2
movl $0x2, %esi
callq 0x44520
movl $0x3, %eax
jmp 0x50f09
jbe 0x50ee8
xorl %eax, %eax
jmp 0x50eff
movl %esi, %eax
leaq 0x7cb0f(%rip), %rcx # 0xcda00
movzwl (%rcx,%rax,2), %esi
callq 0x44520
movl $0x3, %eax
leaq 0x7cb7a(%rip), %rcx # 0xcda80
movl (%rcx,%rax,4), %eax
popq %r... | /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeVSHLMaxInstruction | static DecodeStatus DecodeVSHLMaxInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rm, size;
unsigned Rd = fieldFromInstruction_4(Insn, 12, 4);
Rd |= fieldFromInstruction_4(Insn, 22, 1) << 4;
Rm = fieldFromInstruction_4(Insn, 0, 4)... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
xorl %r15d, %r15d
btl $0xc, %esi
jb 0x50f4e
movl %r14d, %eax
shrl $0xd, %eax
andl $0x7, %eax
movl %r14d, %ecx
shrl $0x13, %ecx
andl $0x8, %ecx
orl %eax, %ecx
leaq 0x7cae4(%rip), %rax # 0xcda20
movzwl (%rax,%rcx,2), %esi
movq %rb... | /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeNEONModImmInstruction | static DecodeStatus DecodeNEONModImmInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned imm, Q;
unsigned Rd = fieldFromInstruction_4(Insn, 12, 4);
Rd |= fieldFromInstruction_4(Insn, 22, 1) << 4;
imm = fieldFromInstruction_4(Insn, 0, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %r12d
shrl $0xc, %r12d
movl %r12d, %eax
andl $0xf, %eax
movl %esi, %r15d
shrl $0x12, %r15d
andl $0x10, %r15d
orl %eax, %r15d
testb $0x40, %bpl
jne 0x51111
movl %r15d, %eax
leaq 0x7bea2(%rip), %rcx # 0xccfa0
movzwl (%rc... | /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeVCVTD | static DecodeStatus DecodeVCVTD(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Vm, imm, cmode, op;
unsigned Vd = (fieldFromInstruction_4(Insn, 12, 4) << 0);
Vd |= (fieldFromInstruction_4(Insn, 22, 1) << 4);
Vm = (fieldFromInstruction_4(Insn... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %r14d
shrl $0x5, %r14d
andl $0x1, %r14d
movl %esi, %eax
andl $0x380f00, %eax # imm = 0x380F00
cmpl $0xf00, %eax # imm = 0xF00
jne 0x51273
testl %r14d, %r14d
jne 0x51279
movq %rbx, %rdi
movl $0x556, %esi ... | /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeVLDST4Instruction | static DecodeStatus DecodeVLDST4Instruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
unsigned load;
unsigned size = fieldFromInstruction_4(Insn, 6, 2);
if (size == 3) return MCDisassembler_Fail;
load = fieldFromInstruction_4(Insn, 21, 1);
return load ? DecodeVLDInstruction(Inst, Ins... | movl %esi, %eax
notl %eax
testb $-0x40, %al
jne 0x51419
xorl %eax, %eax
retq
btl $0x15, %esi
jb 0x54125
jmp 0x544c1
| /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeVST1LN | static DecodeStatus DecodeVST1LN(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned size, align = 0, index = 0;
unsigned Rn = fieldFromInstruction_4(Insn, 16, 4);
unsigned Rm = fieldFromInstruction_4(Insn, 0, 4);
unsigned Rd = fieldFromInstruct... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %ecx
shrl $0xa, %ecx
andl $0x3, %ecx
xorl %eax, %eax
leaq 0x7a397(%rip), %rdx # 0xcb7e0
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
testb $0x10, %bpl
jne 0x5156e
movl %ebp, %r15d
shrl $0... | /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeVLD3DupInstruction | static DecodeStatus DecodeVLD3DupInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned Rn, Rm, inc;
unsigned Rd = fieldFromInstruction_4(Insn, 12, 4);
Rd |= fieldFromInstruction_4(Insn, 22, 1) << 4;
Rn = fieldFromInstruction_4(Insn, 16... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %eax
shrl $0xc, %eax
andl $0xf, %eax
movl %esi, %r12d
shrl $0x12, %r12d
andl $0x10, %r12d
orl %eax, %r12d
movl %esi, %r15d
shrl $0x10, %r15d
andl $0xf, %r15d
movl %esi, %ebp
andl $0xf, %ebp
movq $0x0, (%rsp)
btl $0x5... | /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeT2SOImm | static DecodeStatus DecodeT2SOImm(MCInst *Inst, unsigned Val,
uint64_t Address, const void *Decoder)
{
unsigned ctrl = fieldFromInstruction_4(Val, 10, 2);
if (ctrl == 0) {
unsigned byte = fieldFromInstruction_4(Val, 8, 2);
unsigned imm = fieldFromInstruction_4(Val, 0, 8);
switch (byte) {
case 0:
MCOper... | testl $0xc00, %esi # imm = 0xC00
je 0x5306e
movl %esi, %eax
orl $0x80, %eax
movzbl %al, %eax
shrl $0x7, %esi
movl %esi, %ecx
rorl %cl, %eax
movl %eax, %esi
jmp 0x44040
movl %esi, %ecx
shrl $0x8, %ecx
andl $0x3, %ecx
movzbl %sil, %eax
leaq 0x7892f(%rip), %rdx # 0xcb9b0
movslq (%rdx,%rcx,4), %rcx
addq %rdx... | /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
DecodeVLDInstruction | static DecodeStatus DecodeVLDInstruction(MCInst *Inst, unsigned Insn,
uint64_t Address, const void *Decoder)
{
DecodeStatus S = MCDisassembler_Success;
unsigned wb, Rn, Rm;
unsigned Rd = fieldFromInstruction_4(Insn, 12, 4);
Rd |= fieldFromInstruction_4(Insn, 22, 1) << 4;
wb = fieldFromInstruction_4(Insn, 16, 4);... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %eax
shrl $0xc, %eax
andl $0xf, %eax
movl %esi, %r12d
shrl $0x12, %r12d
andl $0x10, %r12d
orl %eax, %r12d
callq 0x44490
leal -0x391(%rax), %ecx
cmpl $0xc, %ecx
jb 0x54174
leal -0x3d2(%rax), %ecx
cmpl ... | /bughoho[P]capstone/arch/ARM/ARMDisassembler.c |
printSBitModifierOperand | static void printSBitModifierOperand(MCInst *MI, unsigned OpNum, SStream *O)
{
if (MCOperand_getReg(MCInst_getOperand(MI, OpNum))) {
//assert(MCOperand_getReg(MCInst_getOperand(MI, OpNum)) == ARM_CPSR &&
// "Expect ARM CPSR register!");
SStream_concat0(O, "s");
if (MI->csh->detail)
MI->flat_insn->deta... | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
callq 0x444e0
movq %rax, %rdi
callq 0x44310
testl %eax, %eax
je 0x61a59
leaq 0x7cee3(%rip), %rsi # 0xde915
movq %r14, %rdi
callq 0x441c0
movq 0x320(%rbx), %rax
cmpl $0x0, 0x68(%rax)
je 0x61a59
movq 0x310(%rbx), %rax
movq 0xe8(%rax), %rax
movb $0x1, 0x... | /bughoho[P]capstone/arch/ARM/ARMInstPrinter.c |
printOperand | static void printOperand(MCInst *MI, unsigned OpNo, SStream *O)
{
int32_t imm;
MCOperand *Op = MCInst_getOperand(MI, OpNo);
if (MCOperand_isReg(Op)) {
unsigned Reg = MCOperand_getReg(Op);
printRegName(MI->csh, O, Reg);
if (MI->csh->detail) {
if (MI->csh->doing_mem) {
if (MI->flat_insn->detail->arm.opera... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rdi, %rbx
callq 0x444e0
movq %rax, %r14
movq %rax, %rdi
callq 0x445c0
testb %al, %al
je 0x61d15
movq %r14, %rdi
callq 0x44310
movl %eax, %ebp
movq 0x320(%rbx), %rax
movl %ebp, %edi
callq *0x80(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x441c... | /bughoho[P]capstone/arch/ARM/ARMInstPrinter.c |
printPImmediate | static void printPImmediate(MCInst *MI, unsigned OpNum, SStream *O)
{
unsigned imm = (unsigned int)MCOperand_getImm(MCInst_getOperand(MI, OpNum));
SStream_concat(O, "p%u", imm);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail->arm.op_count].type = ARM_OP_PIMM;
MI->flat_insn->det... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rdi, %rbx
callq 0x444e0
movq %rax, %rdi
callq 0x443b0
movq %rax, %r14
leaq 0x723b6(%rip), %rsi # 0xd4436
movq %r15, %rdi
movl %r14d, %edx
xorl %eax, %eax
callq 0x44540
movq 0x320(%rbx), %rax
cmpl $0x0, 0x68(%rax)
je 0x620e4
movq 0x310(%rbx), %rax
movq 0xe8(%rax... | /bughoho[P]capstone/arch/ARM/ARMInstPrinter.c |
printAddrModeImm12Operand | static void printAddrModeImm12Operand(MCInst *MI, unsigned OpNum,
SStream *O, bool AlwaysPrintImm0)
{
MCOperand *MO1 = MCInst_getOperand(MI, OpNum);
MCOperand *MO2 = MCInst_getOperand(MI, OpNum+1);
int32_t OffImm;
bool isSub;
if (!MCOperand_isReg(MO1)) { // FIXME: This is for CP entries, but isn't right.
pr... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movl %esi, %r13d
movq %rdi, %rbx
callq 0x444e0
movq %rax, %r12
leal 0x1(%r13), %esi
movq %rbx, %rdi
callq 0x444e0
movq %rax, %r15
movq %r12, %rdi
callq 0x445c0
testb %al, %al
je 0x623e2
leaq 0x7c86d(%rip), %rsi ... | /bughoho[P]capstone/arch/ARM/ARMInstPrinter.c |
printAddrMode2Operand | static void printAddrMode2Operand(MCInst *MI, unsigned Op, SStream *O)
{
MCOperand *MO1 = MCInst_getOperand(MI, Op);
if (!MCOperand_isReg(MO1)) { // FIXME: This is for CP entries, but isn't right.
printOperand(MI, Op, O);
return;
}
printAM2PreOrOffsetIndexOp(MI, Op, O);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
callq 0x444e0
movq %rax, %rdi
callq 0x445c0
testb %al, %al
je 0x62691
movq %rbx, %rdi
movl %r15d, %esi
callq 0x444e0
movq %rax, %rbp
leal 0x1(%r15), %esi
movq %rbx, %rdi
callq 0x444e0
movq %rax,... | /bughoho[P]capstone/arch/ARM/ARMInstPrinter.c |
printFBits16 | static void printFBits16(MCInst *MI, unsigned OpNum, SStream *O)
{
unsigned tmp;
tmp = 16 - (unsigned int)MCOperand_getImm(MCInst_getOperand(MI, OpNum));
if (tmp > HEX_THRESHOLD)
SStream_concat(O, "#0x%x", tmp);
else
SStream_concat(O, "#%u", tmp);
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[M... | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movl $0x2, %esi
callq 0x444e0
movq %rax, %rdi
callq 0x443b0
movl $0x10, %ebp
subl %eax, %ebp
cmpl $0xa, %ebp
leaq 0x71d06(%rip), %rax # 0xd44c6
leaq 0x71d07(%rip), %rsi # 0xd44ce
cmovaeq %rax, %rsi
movq %r14, %rdi
movl %ebp, %edx
xorl %eax, %eax
c... | /bughoho[P]capstone/arch/ARM/ARMInstPrinter.c |
printGPRPairOperand | static void printGPRPairOperand(MCInst *MI, unsigned OpNum, SStream *O,
MCRegisterInfo *MRI)
{
unsigned Reg = MCOperand_getReg(MCInst_getOperand(MI, OpNum));
printRegName(MI->csh, O, MCRegisterInfo_getSubReg(MRI, Reg, ARM_gsub_0));
if (MI->csh->detail) {
MI->flat_insn->detail->arm.operands[MI->flat_insn->detail-... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
callq 0x444e0
movq %rax, %rdi
callq 0x44310
movl %eax, %ebp
movq 0x320(%rbx), %r12
movq %r14, %rdi
movl %eax, %esi
movl $0x9, %edx
callq 0x443a0
movl %eax, %edi
callq *0x80(%r12)
movq %r15, %rdi
movq %rax, %rsi
callq ... | /bughoho[P]capstone/arch/ARM/ARMInstPrinter.c |
printVectorListThreeSpacedAllLanes | static void printVectorListThreeSpacedAllLanes(MCInst *MI,
unsigned OpNum, SStream *O)
{
// Normally, it's not safe to use register enum values directly with
// addition to get the next register, but for VFP registers, the
// sort order is guaranteed because they're all of the form D<n>.
SStream_concat0(O, "{");
... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x6ffed(%rip), %rsi # 0xd4304
movq %rbx, %rdi
callq 0x441c0
movq 0x320(%r14), %r15
movq %r14, %rdi
xorl %esi, %esi
callq 0x444e0
movq %rax, %rdi
callq 0x44310
movl %eax, %edi
callq *0x80(%r15)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x441c0
movq 0x... | /bughoho[P]capstone/arch/ARM/ARMInstPrinter.c |
X86_insn_reg_intel2 | bool X86_insn_reg_intel2(unsigned int id, x86_reg *reg1, x86_reg *reg2)
{
unsigned int i;
for (i = 0; i < ARR_SIZE(insn_regs_intel2); i++) {
if (insn_regs_intel2[i].insn == id) {
*reg1 = insn_regs_intel2[i].reg1;
*reg2 = insn_regs_intel2[i].reg2;
return true;
}
}
// not found
return false;
} | cmpl $0x37f, %edi # imm = 0x37F
jne 0xa9485
leaq 0x9f1ff(%rip), %rcx # 0x148680
movb $0x1, %al
jmp 0xa94b1
movq $-0x1, %rax
leaq 0x9f1ed(%rip), %rcx # 0x148680
cmpq $0x4, %rax
je 0xa94bc
movzwl 0xc(%rcx), %r8d
addq $0xc, %rcx
incq %rax
cmpl %edi, %r8d
jne 0xa9493
cmpq $0x5, %rax
setb %al
movl 0x4(%rc... | /bughoho[P]capstone/arch/X86/X86Mapping.c |
DecodeL2OpInstructionFail | static DecodeStatus DecodeL2OpInstructionFail(MCInst *Inst, unsigned Insn, uint64_t Address,
void *Decoder)
{
// Try and decode as a L3R / L2RUS instruction.
unsigned Opcode = fieldFromInstruction_4(Insn, 16, 4) |
fieldFromInstruction_4(Insn, 27, 5) << 4;
switch (Opcode) {
case 0x0c:
MCInst_setOpcode(Inst, ... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %ecx
shrl $0x10, %ecx
andl $0xf, %ecx
movl %esi, %eax
shrl $0x17, %eax
andl $-0x10, %eax
orl %ecx, %eax
cmpl $0x10b, %eax # imm = 0x10B
jg 0xc8ac4
cmpl $0x5b, %eax
jg 0xc8b04
cmpl $0x2b, %eax
jle 0xc8b72
cmpl $0x2c, %... | /bughoho[P]capstone/arch/XCore/XCoreDisassembler.c |
DecodeL5RInstructionFail | static DecodeStatus DecodeL5RInstructionFail(MCInst *Inst, unsigned Insn, uint64_t Address,
void *Decoder)
{
unsigned Opcode;
// Try and decode as a L6R instruction.
MCInst_clear(Inst);
Opcode = fieldFromInstruction_4(Insn, 27, 5);
switch (Opcode) {
default:
break;
case 0x00:
MCInst_setOpcode(Inst, XC... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x44640
cmpl $0x7ffffff, %ebp # imm = 0x7FFFFFF
ja 0xc8cff
movq %r14, %rdi
movl $0xa3, %esi
callq 0x44180
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0xc84b1
xorl %eax, %eax
popq %rbx
popq... | /bughoho[P]capstone/arch/XCore/XCoreDisassembler.c |
bool sptk::ReadStream<long>(bool, int, int, int, std::vector<long, std::allocator<long>>*, std::istream*, int*) | bool ReadStream(bool zero_padding, int stream_skip, int read_point,
int read_size, std::vector<T>* sequence_to_read,
std::istream* input_stream, int* actual_read_size) {
if (stream_skip < 0 || read_point < 0 || read_size <= 0 ||
NULL == sequence_to_read || NULL == input_stream ||... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %r13d
movl %edx, %eax
orl %esi, %eax
sets %al
testl %ecx, %ecx
setle %cl
orb %al, %cl
testq %r8, %r8
sete %al
testq %r9, %r9
sete %dl
orb %al, %dl
orb %cl, %dl
jne 0x76ef
movq %r9, %rbx
movq (%r9), %rax
movq -0x18(%... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
bool sptk::ReadStream<unsigned char>(bool, int, int, int, std::vector<unsigned char, std::allocator<unsigned char>>*, std::istream*, int*) | bool ReadStream(bool zero_padding, int stream_skip, int read_point,
int read_size, std::vector<T>* sequence_to_read,
std::istream* input_stream, int* actual_read_size) {
if (stream_skip < 0 || read_point < 0 || read_size <= 0 ||
NULL == sequence_to_read || NULL == input_stream ||... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %r13d
movl %edx, %eax
orl %esi, %eax
sets %al
testl %ecx, %ecx
setle %cl
orb %al, %cl
testq %r8, %r8
sete %al
testq %r9, %r9
sete %dl
orb %al, %dl
orb %cl, %dl
jne 0x7827
movq %r9, %rbx
movq (%r9), %rax
movq -0x18(%... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
bool sptk::ReadStream<unsigned short>(bool, int, int, int, std::vector<unsigned short, std::allocator<unsigned short>>*, std::istream*, int*) | bool ReadStream(bool zero_padding, int stream_skip, int read_point,
int read_size, std::vector<T>* sequence_to_read,
std::istream* input_stream, int* actual_read_size) {
if (stream_skip < 0 || read_point < 0 || read_size <= 0 ||
NULL == sequence_to_read || NULL == input_stream ||... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %r13d
movl %edx, %eax
orl %esi, %eax
sets %al
testl %ecx, %ecx
setle %cl
orb %al, %cl
testq %r8, %r8
sete %al
testq %r9, %r9
sete %dl
orb %al, %dl
orb %cl, %dl
jne 0x798b
movq %r9, %rbx
movq (%r9), %rax
movq -0x18(%... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
bool sptk::ReadStream<sptk::uint24_t>(bool, int, int, int, std::vector<sptk::uint24_t, std::allocator<sptk::uint24_t>>*, std::istream*, int*) | bool ReadStream(bool zero_padding, int stream_skip, int read_point,
int read_size, std::vector<T>* sequence_to_read,
std::istream* input_stream, int* actual_read_size) {
if (stream_skip < 0 || read_point < 0 || read_size <= 0 ||
NULL == sequence_to_read || NULL == input_stream ||... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r12d
movl %edx, %r13d
movl %edx, %eax
orl %esi, %eax
sets %al
testl %ecx, %ecx
setle %cl
orb %al, %cl
testq %r8, %r8
sete %al
testq %r9, %r9
sete %dl
orb %al, %dl
orb %cl, %dl
jne 0x7b33
movq %r9, %rbx
movq (%r9), %rax
movq -0x18(%... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
bool sptk::ReadStream<unsigned long>(bool, int, int, int, std::vector<unsigned long, std::allocator<unsigned long>>*, std::istream*, int*) | bool ReadStream(bool zero_padding, int stream_skip, int read_point,
int read_size, std::vector<T>* sequence_to_read,
std::istream* input_stream, int* actual_read_size) {
if (stream_skip < 0 || read_point < 0 || read_size <= 0 ||
NULL == sequence_to_read || NULL == input_stream ||... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %r13d
movl %edx, %eax
orl %esi, %eax
sets %al
testl %ecx, %ecx
setle %cl
orb %al, %cl
testq %r8, %r8
sete %al
testq %r9, %r9
sete %dl
orb %al, %dl
orb %cl, %dl
jne 0x7e21
movq %r9, %rbx
movq (%r9), %rax
movq -0x18(%... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
bool sptk::ReadStream<float>(bool, int, int, int, std::vector<float, std::allocator<float>>*, std::istream*, int*) | bool ReadStream(bool zero_padding, int stream_skip, int read_point,
int read_size, std::vector<T>* sequence_to_read,
std::istream* input_stream, int* actual_read_size) {
if (stream_skip < 0 || read_point < 0 || read_size <= 0 ||
NULL == sequence_to_read || NULL == input_stream ||... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r15d
movl %edx, %r13d
movl %edx, %eax
orl %esi, %eax
sets %al
testl %ecx, %ecx
setle %cl
orb %al, %cl
testq %r8, %r8
sete %al
testq %r9, %r9
sete %dl
orb %al, %dl
orb %cl, %dl
jne 0x7f91
movq %r9, %rbx
movq (%r9), %rax
movq -0x18(%... | /sp-nitech[P]SPTK/src/utils/sptk_utils.cc |
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.