name string | code string | asm string | file string |
|---|---|---|---|
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 0x20ee60
movq (%r14), %r14
leaq 0x10(%r14), %r12
leaq 0x27e10b(%rip), %rsi # 0x4a7dbd
movl $0x6, %r13d
movl $0x6, %edx
movq %r12, %rdi
callq 0x6d7c0
testq %r15, %r15
je 0... | /google[P]bloaty/third_party/googletest/googletest/src/gtest-port.cc |
testing::internal::PrintTo(char16_t const*, std::ostream*) | void PrintTo(const char16_t* s, ostream* os) { PrintCStringTo(s, os); } | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
testq %rdi, %rdi
je 0x22a0b5
movq %rdi, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6d560
leaq 0x27ee00(%rip), %rsi # 0x4a8e82
movl $0xd, %edx
movq %rax, %rdi
callq 0x6d7c0
movq $-0x1, %rsi
cmpw $0x0, 0x2(%r14,%rsi,2)
leaq 0x1(%rsi), %rsi
jne 0x22a096
movq %r14, %rdi... | /google[P]bloaty/third_party/googletest/googletest/src/gtest-printers.cc |
testing::internal::HasGoogleTestFlagPrefix(char const*) | static bool HasGoogleTestFlagPrefix(const char* str) {
return (SkipPrefix("--", &str) ||
SkipPrefix("-", &str) ||
SkipPrefix("/", &str)) &&
!SkipPrefix(GTEST_FLAG_PREFIX_ "internal_", &str) &&
(SkipPrefix(GTEST_FLAG_PREFIX_, &str) ||
SkipPrefix(GTEST_FLAG_PREFIX_DASH_, ... | pushq %rax
movq %rsp, %rsi
movq %rdi, (%rsi)
leaq 0x27b25a(%rip), %rdi # 0x4a7a1e
callq 0x2217b8
testb %al, %al
jne 0x22c7f3
leaq 0x27b24b(%rip), %rdi # 0x4a7a1f
movq %rsp, %rsi
callq 0x2217b8
testb %al, %al
jne 0x22c7f3
leaq 0x27ad80(%rip), %rdi # 0x4a7567
movq %rsp, %rsi
callq 0x2217b8
testb %al, %al
je 0x22... | /google[P]bloaty/third_party/googletest/googletest/src/gtest.cc |
testing::internal::ParseFlag(char const*, char const*, bool*) | static bool ParseFlag(const char* str, const char* flag_name, bool* value) {
// Gets the value of the flag as a string.
const char* const value_str = ParseFlagValue(str, flag_name, true);
// Aborts if the parsing failed.
if (value_str == nullptr) return false;
// Converts the string value to a bool.
*valu... | pushq %rbx
movq %rdx, %rbx
movl $0x1, %edx
callq 0x2218b3
testq %rax, %rax
je 0x22c986
movzbl (%rax), %edx
xorl %ecx, %ecx
cmpl $0x30, %edx
je 0x22c984
cmpl $0x66, %edx
je 0x22c984
cmpb $0x46, %dl
setne %cl
movb %cl, (%rbx)
testq %rax, %rax
setne %al
popq %rbx
retq
| /google[P]bloaty/third_party/googletest/googletest/src/gtest.cc |
testing::AssertionResult& testing::AssertionResult::operator<<<char [106]>(char const (&) [106]) | 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 0x20ee60
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x6d2d0
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x6d7c0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x7ed9c
movq 0x8... | /google[P]bloaty/third_party/googletest/googletest/include/gtest/gtest.h |
testing::internal::UnitTestImpl::AddTestInfo(void (*)(), void (*)(), testing::TestInfo*) | void AddTestInfo(internal::SetUpTestSuiteFunc set_up_tc,
internal::TearDownTestSuiteFunc tear_down_tc,
TestInfo* test_info) {
#if GTEST_HAS_DEATH_TEST
// In order to support thread-safe death tests, we need to
// remember the original working directory when the test program... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
cmpq $0x0, 0x18(%rdi)
jne 0x22e3aa
leaq 0x10(%r12), %r13
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
callq 0x227fee
movq %r13, %rdi
movq %rbp, %rsi
callq 0x6d3a0
leaq 0x18(%rsp), %... | /google[P]bloaty/third_party/googletest/googletest/src/gtest-internal-inl.h |
testing::TestPartResult::TestPartResult(testing::TestPartResult::Type, char const*, int, char const*) | TestPartResult(Type a_type, const char* a_file_name, int a_line_number,
const char* a_message)
: type_(a_type),
file_name_(a_file_name == nullptr ? "" : a_file_name),
line_number_(a_line_number),
summary_(ExtractSummary(a_message)),
message_(a_message) {} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movl %ecx, %ebp
movq %rdi, %r14
movl %esi, (%rdi)
leaq 0x8(%rdi), %rbx
testq %rdx, %rdx
leaq 0x160074(%rip), %r12 # 0x38e631
cmovneq %rdx, %r12
leaq 0x18(%rdi), %r13
movq %r13, 0x8(%rdi)
movq %r12, %rdi
callq 0x6d2d0
leaq (%r... | /google[P]bloaty/third_party/googletest/googletest/include/gtest/gtest-test-part.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 f... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
leaq 0x15fc1e(%rip), %r15 # 0x38e631
cmovneq %rsi, %r15
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq %r15, %rdi
callq 0x6d2d0
leaq (%rax,%r15), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x7fe20
cmpq $0x0, 0x8(%r14)
je 0x22ea68
leaq 0x... | /google[P]bloaty/third_party/googletest/googletest/src/gtest.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 0x15e599(%rip), %rsi # 0x38e631
movq %rbx, %rdi
xorl %edx, %edx
callq 0x6d7c0
leaq 0xe43a(%rip), %rsi # 0x23e4e3
movl $0x1, %edx
movq %rbx, %rdi
callq 0x6d7c0
movzbl %bpl, %r14d
cmpl $0xd, %ebp
ja 0x230103
movl %eb... | /google[P]bloaty/third_party/googletest/googletest/src/gtest-printers.cc |
testing::internal::DeathTestImpl::~DeathTestImpl() | ~DeathTestImpl() override { GTEST_DEATH_TEST_CHECK_(read_fd_ == -1); } | pushq %rbx
subq $0xf0, %rsp
leaq 0x343d27(%rip), %rax # 0x574380
movq %rax, (%rdi)
cmpl $-0x1, 0x34(%rdi)
jne 0x230673
addq $0x10, %rdi
addq $0xf0, %rsp
popq %rbx
jmp 0x22fae2
leaq 0xe0(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x2774ff(%rip), %rsi # 0x4a7b85
leaq 0x27750b(%rip), %rdx # 0x4a7b98
leaq 0xd0(%rsp),... | /google[P]bloaty/third_party/googletest/googletest/src/gtest-death-test.cc |
testing::Matcher<std::basic_string_view<char, std::char_traits<char>> const&>::~Matcher() | class GTEST_API_ Matcher<const internal::StringView&>
: public internal::MatcherBase<const internal::StringView&> {
public:
Matcher() {}
explicit Matcher(const MatcherInterface<const internal::StringView&>* impl)
: internal::MatcherBase<const internal::StringView&>(impl) {}
template <typename M, type... | pushq %rbx
movq %rdi, %rbx
callq 0x233982
movl $0x18, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x6d6d0
nop
| /google[P]bloaty/third_party/googletest/googletest/include/gtest/gtest-matchers.h |
testing::internal::StreamingListener::SocketWriter::SocketWriter(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&) | SocketWriter(const std::string& host, const std::string& port)
: sockfd_(-1), host_name_(host), port_num_(port) {
MakeConnection();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rdi, %r14
leaq 0x34327a(%rip), %rax # 0x574a48
movq %rax, (%rdi)
movl $0xffffffff, 0x8(%rdi) # imm = 0xFFFFFFFF
leaq 0x10(%rdi), %rbx
leaq 0x20(%rdi), %r13
movq %r13, 0x10(%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
... | /google[P]bloaty/third_party/googletest/googletest/src/gtest-internal-inl.h |
testing::internal::CapturedStream::GetCapturedString[abi:cxx11]() | std::string GetCapturedString() {
if (uncaptured_fd_ != -1) {
// Restores the original stream.
fflush(nullptr);
dup2(uncaptured_fd_, fd_);
close(uncaptured_fd_);
uncaptured_fd_ = -1;
}
FILE* const file = posix::FOpen(filename_.c_str(), "r");
if (file == nullptr) {
GT... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
cmpl $-0x1, 0x4(%rsi)
je 0x23366f
xorl %edi, %edi
callq 0x6d810
movl (%r15), %esi
movl 0x4(%r15), %edi
callq 0x6d640
movl 0x4(%r15), %edi
callq 0x6dec0
movl $0xffffffff, 0x4(%r15) # imm = 0xFFFFFFFF
movq 0x8(%r15), %rdi
leaq 0x7e9a6(%rip... | /google[P]bloaty/third_party/googletest/googletest/src/gtest-port.cc |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> testing::internal::StreamableToString<wchar_t*>(wchar_t* const&) | std::string StreamableToString(const T& streamable) {
return (Message() << streamable).GetString();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x20ee60
movq (%r14), %rsi
movq %r15, %rdi
callq 0x20ef60
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x20f0c9
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x235e13
movq (%rdi), %rax
callq *0x8(%rax)
... | /google[P]bloaty/third_party/googletest/googletest/include/gtest/gtest-message.h |
bool testing::internal::AnyEq::operator()<std::basic_string_view<char, std::char_traits<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::basic_string_view<char, std::char_traits<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> cons... | bool operator()(const A& a, const B& b) const { return a == b; } | movq %rdx, %rax
movq (%rsi), %rdx
cmpq 0x8(%rax), %rdx
jne 0x23607b
testq %rdx, %rdx
je 0x23607e
pushq %rax
movq 0x8(%rsi), %rdi
movq (%rax), %rsi
callq 0x6d6f0
testl %eax, %eax
leaq 0x8(%rsp), %rsp
je 0x23607e
xorl %eax, %eax
retq
movb $0x1, %al
retq
nop
| /google[P]bloaty/third_party/googletest/googletest/include/gtest/gtest-matchers.h |
arangodb::velocypack::Builder::closeEmptyArrayOrObject(unsigned long, bool) | Builder& Builder::closeEmptyArrayOrObject(ValueLength pos, bool isArray) {
// empty Array or Object
_start[pos] = (isArray ? 0x01 : 0x0a);
VELOCYPACK_ASSERT(_pos == pos + 9);
rollback(8); // no bytelength and number subvalues needed
closeLevel();
return *this;
} | subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movb 0x17(%rsp), %dl
movl $0xa, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movb %al, %dl
movq 0x18(%rdi), %rax
movq 0x18(%rsp), %rcx
movb %dl, (%rax,%rcx... | /arangodb[P]velocypack/src/Builder.cpp |
arangodb::velocypack::Builder::closeCompactArrayOrObject(unsigned long, bool, __gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>, __gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>) | bool Builder::closeCompactArrayOrObject(
ValueLength pos, bool isArray,
std::vector<ValueLength>::iterator indexStart,
std::vector<ValueLength>::iterator indexEnd) {
std::size_t const n = std::distance(indexStart, indexEnd);
// use compact notation
ValueLength nLen = getVariableValueLength(static_cas... | subq $0x88, %rsp
movb %dl, %al
movq %rcx, 0x70(%rsp)
movq %r8, 0x68(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
andb $0x1, %al
movb %al, 0x57(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rs... | /arangodb[P]velocypack/src/Builder.cpp |
arangodb::velocypack::getVariableValueLength(unsigned long) | static inline ValueLength getVariableValueLength(ValueLength value) noexcept {
ValueLength len = 1;
while (value >= 0x80U) {
value >>= 7;
++len;
}
return len;
} | movq %rdi, -0x8(%rsp)
movq $0x1, -0x10(%rsp)
cmpq $0x80, -0x8(%rsp)
jb 0x79a7
movq -0x8(%rsp), %rax
shrq $0x7, %rax
movq %rax, -0x8(%rsp)
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0x797e
movq -0x10(%rsp), %rax
retq
nopl (%rax)
| /arangodb[P]velocypack/include/velocypack/velocypack-common.h |
void arangodb::velocypack::storeVariableValueLength<false>(unsigned char*, unsigned long) | static inline void storeVariableValueLength(uint8_t* dst,
ValueLength value) noexcept {
VELOCYPACK_ASSERT(value > 0);
if (reverse) {
while (value >= 0x80U) {
*dst-- = static_cast<uint8_t>(value | 0x80U);
value >>= 7;
}
*dst = static_cast<uint8_t>(... | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
cmpq $0x80, -0x10(%rsp)
jb 0x79f5
movq -0x10(%rsp), %rax
orq $0x80, %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rsp)
movb %cl, (%rax)
movq -0x10(%rsp), %rax
shrq $0x7, %rax
movq %rax, -0x10(%rsp)
jmp 0x79ba
movq -0x10(%rsp), %rax... | /arangodb[P]velocypack/include/velocypack/velocypack-common.h |
void arangodb::velocypack::storeVariableValueLength<true>(unsigned char*, unsigned long) | static inline void storeVariableValueLength(uint8_t* dst,
ValueLength value) noexcept {
VELOCYPACK_ASSERT(value > 0);
if (reverse) {
while (value >= 0x80U) {
*dst-- = static_cast<uint8_t>(value | 0x80U);
value >>= 7;
}
*dst = static_cast<uint8_t>(... | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
cmpq $0x80, -0x10(%rsp)
jb 0x7a55
movq -0x10(%rsp), %rax
orq $0x80, %rax
movb %al, %cl
movq -0x8(%rsp), %rax
movq %rax, %rdx
addq $-0x1, %rdx
movq %rdx, -0x8(%rsp)
movb %cl, (%rax)
movq -0x10(%rsp), %rax
shrq $0x7, %rax
movq %rax, -0x10(%rsp)
jmp 0x7a1a
movq -0x10(%rsp), %ra... | /arangodb[P]velocypack/include/velocypack/velocypack-common.h |
arangodb::velocypack::Builder::checkKeyHasValidType(bool) | inline void checkKeyHasValidType(bool isValid) {
if (!_stack.empty()) {
ValueLength const pos = _stack.back().startPos;
if (_start[pos] == 0x0b || _start[pos] == 0x14) {
if (VELOCYPACK_UNLIKELY(!_keyWritten && !isValid)) {
throw Exception(Exception::BuilderKeyMustBeString);
}
... | subq $0x38, %rsp
movb %sil, %al
movq %rdi, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x70, %rdi
callq 0x4460
testb $0x1, %al
jne 0xff5d
movq 0x18(%rsp), %rdi
addq $0x70, %rdi
callq 0x44b0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq (%rcx), %rcx
movq %rcx, 0x20(%rsp)... | /arangodb[P]velocypack/include/velocypack/Builder.h |
arangodb::velocypack::Builder::addUInt(unsigned long) | void addUInt(uint64_t v) {
if (v <= 9) {
// SmallInt
appendByte(static_cast<uint8_t>(0x30 + v));
} else {
// regular UInt
appendUInt(v, 0x27);
}
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x9, 0x8(%rsp)
ja 0x100b6
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
addq $0x30, %rax
movzbl %al, %esi
callq 0xfdb0
jmp 0x100c9
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movl $0x27, %edx
callq 0x10200
addq $0x18, %rsp
ret... | /arangodb[P]velocypack/include/velocypack/Builder.h |
arangodb::velocypack::Builder::intLength(long) | static inline uint8_t intLength(int64_t value) {
if (value >= -0x80 && value <= 0x7f) {
// shortcut for the common case
return 1;
}
uint64_t x = value >= 0 ? static_cast<uint64_t>(value)
: static_cast<uint64_t>(-(value + 1));
uint8_t xSize = 0;
do {
xSiz... | movq %rdi, -0x10(%rsp)
cmpq $-0x80, -0x10(%rsp)
jl 0x113dc
cmpq $0x7f, -0x10(%rsp)
jg 0x113dc
movb $0x1, -0x1(%rsp)
jmp 0x11441
cmpq $0x0, -0x10(%rsp)
jl 0x113f0
movq -0x10(%rsp), %rax
movq %rax, -0x28(%rsp)
jmp 0x11403
movq -0x10(%rsp), %rcx
addq $0x1, %rcx
xorl %eax, %eax
subq %rcx, %rax
movq %rax, -0x28(%rsp)
movq -... | /arangodb[P]velocypack/include/velocypack/Builder.h |
arangodb::velocypack::Buffer<unsigned char>::Buffer(arangodb::velocypack::Buffer<unsigned char> const&) | Buffer(Buffer const& that) : Buffer() {
if (that._size > 0) {
if (that._size > sizeof(that._local)) {
_buffer = static_cast<T*>(velocypack_malloc(checkOverflow(that._size)));
ensureValidPointer(_buffer);
_capacity = that._size;
} else {
VELOCYPACK_ASSERT(_buffer == &_loca... | subq $0x38, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x14500
movq 0x18(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jbe 0x15924
movq 0x18(%rsp), %rax
cmpq $0xc0, 0x10(%rax)
jbe 0x158e0
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
call... | /arangodb[P]velocypack/include/velocypack/Buffer.h |
arangodb::velocypack::Dumper::dumpString(char const*, unsigned long) | void Dumper::dumpString(char const* src, ValueLength len) {
static char const EscapeTable[256] = {
// 0 1 2 3 4 5 6 7 8 9 A B C D E
// F
'u', 'u', 'u', 'u', 'u', 'u', 'u', 'u', 'b', 't', 'n', 'u', 'f', 'r',
'u',
'u', // 00
'u', 'u', 'u',... | subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x8(%rax), %rdi
movq 0x70(%rsp), %rsi
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x78(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rax
addq 0x70(%rsp), %rax
movq %rax, 0x60(%rsp)
movq... | /arangodb[P]velocypack/src/Dumper.cpp |
arangodb::velocypack::SliceBase<arangodb::velocypack::Slice, arangodb::velocypack::Slice>::hash(unsigned long) const | inline uint64_t hash(uint64_t seed = defaultSeed64) const {
std::size_t const size = checkOverflow(byteSize());
if (size == 1 && seed == defaultSeed64) {
uint64_t h = SliceStaticData::PrecalculatedHashesForDefaultSeed[head()];
VELOCYPACK_ASSERT(h != 0);
return h;
}
return VELOCYPACK_HA... | subq $0x38, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x1c250
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x1, 0x10(%rsp)
jne 0x1c3f9
movl $0xdeadbeef, %eax # imm = 0xDEADBEEF
cmpq %rax, 0x18(%rsp)
jne 0x1c3f9
movq (%rsp), %rdi
callq... | /arangodb[P]velocypack/include/velocypack/SliceBase.h |
arangodb::velocypack::SliceBase<arangodb::velocypack::Slice, arangodb::velocypack::Slice>::extractPointer() const | char const* extractPointer() const {
union Converter {
char const* value;
char binary[sizeof(char const*)];
} converter;
std::memcpy(&converter.binary[0], start() + 1, sizeof(char const*));
return converter.value;
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x1c1c0
movq 0x1(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
| /arangodb[P]velocypack/include/velocypack/SliceBase.h |
arangodb::velocypack::SliceBase<arangodb::velocypack::Slice, arangodb::velocypack::Slice>::getString(unsigned long&) const | char const* getString(ValueLength& length) const {
uint8_t const h = head();
if (h >= 0x40 && h <= 0xbe) {
// short UTF-8 String
length = h - 0x40;
return reinterpret_cast<char const*>(start() + 1);
}
if (h == 0xbf) {
// long UTF-8 String
length = readIntegerFixed<ValueLen... | subq $0x38, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x1c1d0
movb %al, 0x17(%rsp)
movzbl 0x17(%rsp), %eax
cmpl $0x40, %eax
jl 0x1f8c2
movzbl 0x17(%rsp), %eax
cmpl $0xbe, %eax
jg 0x1f8c2
movq 0x8(%rsp), %rdi
movzbl 0x17(%rsp), %eax
subl $0x40, %eax
movslq %eax, %r... | /arangodb[P]velocypack/include/velocypack/SliceBase.h |
bsp_begin | void bsp_begin( bsp_pid_t maxprocs )
{
int mpi_init = 0;
MPI_Initialized(&mpi_init);
if (!mpi_init) {
MPI_Init(NULL, NULL);
atexit( bsp_check_exit );
}
int mpi_pid = 0;
MPI_Comm_rank( MPI_COMM_WORLD, &mpi_pid );
if (s_spmd)
bsp_abort( "bsp_begin: May be called only ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %edi, %ebx
leaq 0x64(%rsp), %r14
movl $0x0, (%r14)
movq %r14, %rdi
callq 0x5150
cmpl $0x0, (%r14)
jne 0x5d9a
xorl %edi, %edi
xorl %esi, %esi
callq 0x53f0
leaq -0xb0(%rip), %rdi # 0x5ce5
callq 0xf5d0
leaq 0x24(%rsp), %rsi
movl ... | /wijnand-suijlen[P]bsponmpi/src/bsp.cc |
bsplib::Rdma::get(int, unsigned long, unsigned long, void*, unsigned long) | void Rdma::get( int src_pid, Memslot src_slot, size_t src_offset,
void * dst, size_t size )
{
#ifdef PROFILE
TicToc t( TicToc::GET );
#endif
assert( !( slot( m_pid, src_slot ).status & Memblock::PUSHED) );
Memslot dst_slot = m_local_slots.size();
m_local_slots.push_back( dst );
Action acti... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r12
movl %esi, %ebp
movq %r8, 0x8(%rsp)
movslq 0x2f4(%rdi), %rax
imulq %rdx, %rax
leaq (%rax,%rax,2), %rsi
shlq $0x3, %rsi
addq 0x338(%rdi), %rsi
movslq 0x2f0(%rdi), %rax
leaq (%rax,%rax,2), %rdx
testb $0x1, 0x10(%rsi,%rdx,8)... | /wijnand-suijlen[P]bsponmpi/src/rdma.cc |
printf | int printf( const char * _PDCLIB_restrict format, ... )
{
int rc;
va_list ap;
va_start( ap, format );
rc = vfprintf( stdout, format, ap );
va_end( ap );
return rc;
} | subq $0xd8, %rsp
movq %rdi, %r10
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x23f2
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %... | /DevSolar[P]pdclib/functions/stdio/printf.c |
vfprintf | int vfprintf( struct _PDCLIB_file_t * _PDCLIB_restrict stream, const char * _PDCLIB_restrict format, va_list arg )
{
/* TODO: This function should interpret format as multibyte characters. */
struct _PDCLIB_status_t status;
status.base = 0;
status.flags = 0;
status.n = SIZE_MAX;
status.i = 0;
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq $0x0, 0x8(%rsp)
movq $-0x1, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rsp)
movups %xmm0, 0x28(%rsp)
movl $0xffffffff, 0x38(%rsp) # imm = 0xFFFFFFFF
movq %rdi, 0x40(%rsp)
leaq 0x48(%rdi), ... | /DevSolar[P]pdclib/functions/stdio/vfprintf.c |
PDCLIB_prepwrite | int _PDCLIB_prepwrite( struct _PDCLIB_file_t * stream )
{
if ( ( stream->bufidx < stream->bufend ) || ( stream->ungetidx > 0 ) ||
( stream->status & ( _PDCLIB_FREAD | _PDCLIB_ERRORFLAG | _PDCLIB_WIDESTREAM | _PDCLIB_EOFFLAG ) ) ||
!( stream->status & ( _PDCLIB_FWRITE | _PDCLIB_FAPPEND | _PDCLIB_FR... | pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rax
cmpq 0x20(%rdi), %rax
jb 0x26b1
cmpq $0x0, 0x38(%rbx)
jne 0x26b1
movl 0x44(%rbx), %eax
testl $0xe08, %eax # imm = 0xE08
sete %cl
testb $0x70, %al
setne %dl
testb %dl, %cl
jne 0x26c7
callq 0x3bd8
movl $0x9, (%rax)
orb $0x2, 0x45(%rbx)
movl $0xffffffff, %eax ... | /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_prepwrite.c |
PDCLIB_print_double | void _PDCLIB_print_double( double value, struct _PDCLIB_status_t * status )
{
unsigned char bytes[ sizeof( double ) ];
int exp;
memcpy( bytes, &value, sizeof( double ) );
exp = _PDCLIB_DBL_EXP( bytes ) - _PDCLIB_DBL_BIAS;
if ( exp == _PDCLIB_DBL_MAX_EXP )
{
/* ... | pushq %rax
movq %rdi, %r9
leaq 0x6(%rsp), %rcx
movq %xmm0, -0x6(%rcx)
movq %xmm0, %rax
movq %rax, %rdi
shrq $0x38, %rdi
movl %edi, %edx
andl $0x7f, %edx
shll $0x4, %edx
shrq $0x34, %rax
andl $0xf, %eax
leal (%rdx,%rax), %r8d
addl $0xfffffc01, %r8d # imm = 0xFFFFFC01
xorl %esi, %esi
ucomisd %xmm0, %xmm0
setp %sil
... | /DevSolar[P]pdclib/functions/_PDCLIB/_PDCLIB_print_fp.c |
mbedtls_net_connect | int mbedtls_net_connect( mbedtls_net_context *ctx, const char *host,
const char *port, int proto )
{
int ret;
struct addrinfo hints, *addr_list, *cur;
if( ( ret = net_prepare() ) != 0 )
return( ret );
/* Do name resolution with both IPv6 and IPv4 */
memset( &hints,... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x1, %esi
movl $0xd, %edi
callq 0xf1f0
xorl %eax, %eax
cmpl $0x1, %ebp
sete %al
movl $0x11, %ecx
movl $0x6, %esi
cmovel %ecx, %esi
incl %eax
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps ... | /Dragonchang[P]https_client/mbedtls/library/net_sockets.c |
mbedtls_net_usleep | void mbedtls_net_usleep( unsigned long usec )
{
#if defined(_WIN32)
Sleep( ( usec + 999 ) / 1000 );
#else
struct timeval tv;
tv.tv_sec = usec / 1000000;
#if defined(__unix__) || defined(__unix) || \
( defined(__APPLE__) && defined(__MACH__) )
tv.tv_usec = (suseconds_t) usec % 1000000;
#else
tv.... | subq $0x18, %rsp
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
movq %rdi, %rax
mulq %rcx
shrq $0x12, %rdx
leaq 0x8(%rsp), %r8
movq %rdx, (%r8)
movq %rdi, %rax
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x12, %rdx
addq %rax, %rdx
imulq $0xf4240, %rdx, %rax # imm = 0xF4240
subq %rax, %rdi
movq %r... | /Dragonchang[P]https_client/mbedtls/library/net_sockets.c |
ssl_calc_verify_tls | void ssl_calc_verify_tls( mbedtls_ssl_context *ssl, unsigned char hash[36] )
{
mbedtls_md5_context md5;
mbedtls_sha1_context sha1;
MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> calc verify tls" ) );
mbedtls_md5_init( &md5 );
mbedtls_sha1_init( &sha1 );
mbedtls_md5_clone( &md5, &ssl->handshake->fin_md5 );
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x3aaa1(%rip), %r14 # 0x4c5fc
leaq 0x3bce0(%rip), %r8 # 0x4d842
movl $0x2, %esi
movq %r14, %rdx
movl $0x3f9, %ecx # imm = 0x3F9
xorl %eax, %eax
callq 0xfb07
leaq 0xc(%rsp), %r12
movq %r12, %r... | /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
mbedtls_ssl_psk_derive_premaster | int mbedtls_ssl_psk_derive_premaster( mbedtls_ssl_context *ssl, mbedtls_key_exchange_type_t key_ex )
{
unsigned char *p = ssl->handshake->premaster;
unsigned char *end = p + sizeof( ssl->handshake->premaster );
const unsigned char *psk = ssl->conf->psk;
size_t psk_len = ssl->conf->psk_len;
/* If th... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x60(%rdi), %r13
movq 0x370(%r13), %r14
testq %r14, %r14
jne 0x122c0
leaq 0x130(%rax), %rcx
movq 0x128(%rax), %r14
jmp 0x122c7
leaq 0x378(%r13), %rcx
addl $-0x5, %esi
cmpl $0x3, %esi
ja 0x123d1
movq (%rcx... | /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
mbedtls_ssl_dtls_replay_check | int mbedtls_ssl_dtls_replay_check( mbedtls_ssl_context *ssl )
{
uint64_t rec_seqnum = ssl_load_six_bytes( ssl->in_ctr + 2 );
uint64_t bit;
if( ssl->conf->anti_replay == MBEDTLS_SSL_ANTI_REPLAY_DISABLED )
return( 0 );
if( rec_seqnum > ssl->in_window_top )
return( 0 );
bit = ssl->in... | movq (%rdi), %rcx
xorl %eax, %eax
testb $0x10, 0x175(%rcx)
je 0x1460b
movq 0xa8(%rdi), %rcx
movzbl 0x2(%rcx), %edx
shlq $0x28, %rdx
movzbl 0x3(%rcx), %esi
shlq $0x20, %rsi
orq %rdx, %rsi
movzbl 0x4(%rcx), %edx
shll $0x18, %edx
orq %rsi, %rdx
movzbl 0x5(%rcx), %esi
shll $0x10, %esi
orq %rdx, %rsi
movzbl 0x6(%rcx), %edx
... | /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
ssl_handshake_wrapup_free_hs_transform | static void ssl_handshake_wrapup_free_hs_transform( mbedtls_ssl_context *ssl )
{
MBEDTLS_SSL_DEBUG_MSG( 3, ( "=> handshake wrapup: final free" ) );
/*
* Free our handshake params
*/
mbedtls_ssl_handshake_free( ssl->handshake );
mbedtls_free( ssl->handshake );
ssl->handshake = NULL;
/... | pushq %rbx
movq %rdi, %rbx
leaq 0x36934(%rip), %rdx # 0x4c5fc
leaq 0x383d5(%rip), %r8 # 0x4e0a4
movl $0x3, %esi
movl $0x134e, %ecx # imm = 0x134E
xorl %eax, %eax
callq 0xfb07
movq 0x60(%rbx), %rdi
callq 0x18957
movq 0x60(%rbx), %rdi
callq 0xf030
movq $0x0, 0x60(%rbx)
movq 0x78(%rbx), %rdi
testq %rdi,... | /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
mbedtls_ssl_check_cert_usage | int mbedtls_ssl_check_cert_usage( const mbedtls_x509_crt *cert,
const mbedtls_ssl_ciphersuite_t *ciphersuite,
int cert_endpoint,
uint32_t *flags )
{
int ret = 0;
#if defined(MBEDTLS_X509_CHECK_KEY_USAGE)
int usage = 0;
#endif
#if defi... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %rax
movq %rdi, %r14
movl $0x80, %esi
cmpl $0x1, %edx
jne 0x16707
movl 0x18(%rax), %eax
decl %eax
xorl %esi, %esi
cmpl $0x9, %eax
ja 0x16707
movl %eax, %eax
leaq 0x35ec0(%rip), %rcx # 0x4c5c4
movl (%rcx,%rax,4), %esi
m... | /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
mbedtls_ssl_handshake_wrapup | void mbedtls_ssl_handshake_wrapup( mbedtls_ssl_context *ssl )
{
int resume = ssl->handshake->resume;
MBEDTLS_SSL_DEBUG_MSG( 3, ( "=> handshake wrapup" ) );
#if defined(MBEDTLS_SSL_RENEGOTIATION)
if( ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_IN_PROGRESS )
{
ssl->renego_status = MBEDTLS_S... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x60(%rdi), %rax
movl 0xa7c(%rax), %ebp
leaq 0x35b61(%rip), %rdx # 0x4c5fc
leaq 0x36683(%rip), %r8 # 0x4d125
movl $0x3, %esi
movl $0x1369, %ecx # imm = 0x1369
xorl %eax, %eax
callq 0xfb07
cmpl $0x1, 0xc(%rbx)
jne 0x16ac1
movq $0x2, 0xc(%rbx)
movq ... | /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
ssl_session_reset_int | static int ssl_session_reset_int( mbedtls_ssl_context *ssl, int partial )
{
int ret;
ssl->state = MBEDTLS_SSL_HELLO_REQUEST;
/* Cancel any possibly running timer */
ssl_set_timer( ssl, 0 );
#if defined(MBEDTLS_SSL_RENEGOTIATION)
ssl->renego_status = MBEDTLS_SSL_INITIAL_HANDSHAKE;
ssl->renego_... | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
xorl %r14d, %r14d
movl %r14d, 0x8(%rdi)
xorl %esi, %esi
callq 0x12a71
movq %r14, 0xc(%rbx)
movl %r14d, 0x190(%rbx)
movq %r14, 0xd0(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x198(%rbx)
movups %xmm0, 0x1a8(%rbx)
movq 0xa0(%rbx), %rax
addq $0xd, %rax
movq %rax... | /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
ssl_session_copy | static int ssl_session_copy( mbedtls_ssl_session *dst, const mbedtls_ssl_session *src )
{
mbedtls_ssl_session_free( dst );
memcpy( dst, src, sizeof( mbedtls_ssl_session ) );
#if defined(MBEDTLS_X509_CRT_PARSE_C)
if( src->peer_cert != NULL )
{
int ret;
dst->peer_cert = mbedtls_calloc( 1... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x16bb6
movl $0x98, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xf240
cmpq $0x0, 0x68(%r14)
je 0x1767d
movl $0x1, %edi
movl $0x228, %esi # imm = 0x228
callq 0xf1d0
movq %rax, 0x68(%rbx)
testq %rax, %rax
je 0x176b4
mo... | /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
mbedtls_ssl_get_session | int mbedtls_ssl_get_session( const mbedtls_ssl_context *ssl, mbedtls_ssl_session *dst )
{
if( ssl == NULL ||
dst == NULL ||
ssl->session == NULL ||
ssl->conf->endpoint != MBEDTLS_SSL_IS_CLIENT )
{
return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
}
return( ssl_session_copy( dst,... | testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0x17dfe
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0x17dfe
movq (%rdi), %rcx
testb $0x1, 0x174(%rcx)
jne 0x17dfe
movq %rsi, %rdi
movq %rax, %rsi
jmp 0x17606
movl $0xffff8f00, %eax # imm = 0xFFFF8F00
retq
| /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
ssl_start_renegotiation | static int ssl_start_renegotiation( mbedtls_ssl_context *ssl )
{
int ret;
MBEDTLS_SSL_DEBUG_MSG( 2, ( "=> renegotiate" ) );
if( ( ret = ssl_handshake_init( ssl ) ) != 0 )
return( ret );
/* RFC 6347 4.2.2: "[...] the HelloRequest will have message_seq = 0 and
* the ServerHello will have m... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x345bc(%rip), %rdx # 0x4c5fc
leaq 0x360ee(%rip), %r8 # 0x4e135
movl $0x2, %esi
movl $0x18f7, %ecx # imm = 0x18F7
xorl %eax, %eax
callq 0xfb07
movq %rbx, %rdi
callq 0x17136
movl %eax, %ebp
testl %eax, %eax
jne 0x18100
movq (%rbx), %rax
movl 0x174(... | /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
ssl_check_ctr_renegotiate | static int ssl_check_ctr_renegotiate( mbedtls_ssl_context *ssl )
{
size_t ep_len = ssl_ep_len( ssl );
int in_ctr_cmp;
int out_ctr_cmp;
if( ssl->state != MBEDTLS_SSL_HANDSHAKE_OVER ||
ssl->renego_status == MBEDTLS_SSL_RENEGOTIATION_PENDING ||
ssl->conf->disable_renegotiation == MBEDTLS_S... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl $0x10, 0x8(%rdi)
jne 0x186a7
movq %rdi, %rbx
movq (%rdi), %rax
movl 0x174(%rax), %r14d
cmpl $0x3, 0xc(%rdi)
sete %cl
btl $0xe, %r14d
setae %dl
orb %cl, %dl
jne 0x186a7
andl $0x2, %r14d
movq 0xa8(%rbx), %rdi
addq %r14, %rdi
leaq (%rax,%r14), %r15
addq $0x160, %... | /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
mbedtls_ssl_transform_free | void mbedtls_ssl_transform_free( mbedtls_ssl_transform *transform )
{
if( transform == NULL )
return;
#if defined(MBEDTLS_ZLIB_SUPPORT)
deflateEnd( &transform->ctx_deflate );
inflateEnd( &transform->ctx_inflate );
#endif
mbedtls_cipher_free( &transform->cipher_ctx_enc );
mbedtls_cipher_fre... | testq %rdi, %rdi
je 0x18956
pushq %rbx
movq %rdi, %rbx
addq $0x80, %rdi
callq 0x2a5d8
leaq 0xd8(%rbx), %rdi
callq 0x2a5d8
leaq 0x50(%rbx), %rdi
callq 0x391bf
leaq 0x68(%rbx), %rdi
callq 0x391bf
xorl %eax, %eax
movb $0x0, (%rbx,%rax)
incq %rax
cmpq $0x130, %rax # imm = 0x130
jne 0x18946
popq %rbx
retq
| /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
ssl_cookie_check_dummy | static int ssl_cookie_check_dummy( void *ctx,
const unsigned char *cookie, size_t cookie_len,
const unsigned char *cli_id, size_t cli_id_len )
{
((void) ctx);
((void) cookie);
((void) cookie_len);
((void) cli_id);
((void) cli_id_len);
return( MBEDTLS_... | movl $0xffff8f80, %eax # imm = 0xFFFF8F80
retq
| /Dragonchang[P]https_client/mbedtls/library/ssl_tls.c |
mbedtls_ssl_ciphersuite_from_string | const mbedtls_ssl_ciphersuite_t *mbedtls_ssl_ciphersuite_from_string(
const char *ciphersuite_name )
{
const mbedtls_ssl_ciphersuite_t *cur = ciphersuite_definitions;
if( NULL == ciphersuite_name )
return( NULL );
while( cur->id != 0 )
{
... | pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x19593
movq %rdi, %r14
leaq 0x54b97(%rip), %rbx # 0x6e110
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0xf1e0
testl %eax, %eax
je 0x19595
cmpl $0x0, 0x30(%rbx)
leaq 0x30(%rbx), %rbx
jne 0x19579
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
re... | /Dragonchang[P]https_client/mbedtls/library/ssl_ciphersuites.c |
mbedtls_ssl_set_client_transport_id | int mbedtls_ssl_set_client_transport_id( mbedtls_ssl_context *ssl,
const unsigned char *info,
size_t ilen )
{
if( ssl->conf->endpoint != MBEDTLS_SSL_IS_SERVER )
return( MBEDTLS_ERR_SSL_BAD_INPUT_DATA );
mbedtls_free( ssl->cli_id );
... | pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %rcx
movl $0xffff8f00, %eax # imm = 0xFFFF8F00
testb $0x1, 0x174(%rcx)
je 0x1d6f2
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x180(%rdi), %rdi
callq 0xf030
movl $0x1, %edi
movq %rbx, %rsi
callq 0xf1d0
movq %rax, 0x180(%r14)
testq %rax, %rax
je 0x1d6ed
movq %... | /Dragonchang[P]https_client/mbedtls/library/ssl_srv.c |
ssl_parse_certificate_verify | static int ssl_parse_certificate_verify( mbedtls_ssl_context *ssl )
{
int ret = MBEDTLS_ERR_SSL_FEATURE_UNAVAILABLE;
size_t i, sig_len;
unsigned char hash[48];
unsigned char *hash_start = hash;
size_t hashlen;
#if defined(MBEDTLS_SSL_PROTO_TLS1_2)
mbedtls_pk_type_t pk_alg;
#endif
mbedtls_md_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x80(%rdi), %rax
movq (%rax), %r14
leaq 0x302db(%rip), %rdx # 0x50a94
leaq 0x310fd(%rip), %r8 # 0x518bd
xorl %ebp, %ebp
movl $0x2, %esi
movl $0xdee, %ecx # imm = 0xDEE
xorl %eax, %eax
callq 0xfb07... | /Dragonchang[P]https_client/mbedtls/library/ssl_srv.c |
ssl_parse_extended_ms_ext | static int ssl_parse_extended_ms_ext( mbedtls_ssl_context *ssl,
const unsigned char *buf,
size_t len )
{
if( len != 0 )
{
MBEDTLS_SSL_DEBUG_MSG( 1, ( "bad client hello message" ) );
return( MBEDTLS_ERR_SSL_BAD_HS_CLIENT_... | testq %rsi, %rsi
je 0x2122b
pushq %rax
leaq 0x2f88b(%rip), %rdx # 0x50a94
leaq 0x2f939(%rip), %r8 # 0x50b49
movl $0x1, %esi
movl $0x1a6, %ecx # imm = 0x1A6
xorl %eax, %eax
callq 0xfb07
movl $0xffff8700, %eax # imm = 0xFFFF8700
addq $0x8, %rsp
retq
movq (%rdi), %rcx
xorl %eax, %eax
testb $0x8, ... | /Dragonchang[P]https_client/mbedtls/library/ssl_srv.c |
x509_get_hash_alg | static int x509_get_hash_alg( const mbedtls_x509_buf *alg, mbedtls_md_type_t *md_alg )
{
int ret;
unsigned char *p;
const unsigned char *end;
mbedtls_x509_buf md_oid;
size_t len;
/* Make sure we got a SEQUENCE and setup bounds */
if( alg->tag != ( MBEDTLS_ASN1_CONSTRUCTED | MBEDTLS_ASN1_SEQ... | movl $0xffffdc9e, %eax # imm = 0xFFFFDC9E
cmpl $0x30, (%rdi)
jne 0x24b24
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
jle 0x24b18
movq %rsi, %r14
addq %rax, %rbx
movzbl (%rax), %eax
leaq 0x18(%rsp), %rdx
movl %eax, -0x8(%rdx)
movq %rsp, %rdi
... | /Dragonchang[P]https_client/mbedtls/library/x509.c |
mbedtls_x509_get_name | int mbedtls_x509_get_name( unsigned char **p, const unsigned char *end,
mbedtls_x509_name *cur )
{
int ret;
size_t set_len;
const unsigned char *end_set;
/* don't use recursion, we'd risk stack overflow if not optimized */
while( 1 )
{
/*
* parse SET
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %rdx
leaq 0x10(%rsp), %r13
movq %r14, %rdi
movq %rbx, %rsi
movl $0x31, %ecx
callq 0x25859
testl %eax, %eax
jne 0x24ce8
movq (%r14), %rbp
addq 0x8(%rsp), %rbp
movq %r14, %rdi... | /Dragonchang[P]https_client/mbedtls/library/x509.c |
mbedtls_asn1_get_tag | int mbedtls_asn1_get_tag( unsigned char **p,
const unsigned char *end,
size_t *len, int tag )
{
if( ( end - *p ) < 1 )
return( MBEDTLS_ERR_ASN1_OUT_OF_DATA );
if( **p != tag )
return( MBEDTLS_ERR_ASN1_UNEXPECTED_TAG );
(*p)++;
return( mbedtls_asn1_g... | movq (%rdi), %r8
movq %rsi, %rax
subq %r8, %rax
testq %rax, %rax
jle 0x25880
movzbl (%r8), %r9d
movl $0xffffff9e, %eax # imm = 0xFFFFFF9E
cmpl %ecx, %r9d
jne 0x25885
incq %r8
movq %r8, (%rdi)
jmp 0x25784
movl $0xffffffa0, %eax # imm = 0xFFFFFFA0
retq
| /Dragonchang[P]https_client/mbedtls/library/asn1parse.c |
mbedtls_mpi_safe_cond_swap | int mbedtls_mpi_safe_cond_swap( mbedtls_mpi *X, mbedtls_mpi *Y, unsigned char swap )
{
int ret, s;
size_t i;
mbedtls_mpi_uint tmp;
if( X == Y )
return( 0 );
/* make sure swap is 0 or 1 in a time-constant manner */
swap = (swap | (unsigned char)-swap) >> 7;
MBEDTLS_MPI_CHK( mbedtls... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
cmpq %rsi, %rdi
je 0x260d3
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rsi), %rsi
callq 0x25e08
testl %eax, %eax
jne 0x260d1
movq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0x25e08
testl %eax, %eax
je 0x260e0
movl %eax, %ebx
movl %ebx, %eax... | /Dragonchang[P]https_client/mbedtls/library/bignum.c |
mbedtls_mpi_set_bit | int mbedtls_mpi_set_bit( mbedtls_mpi *X, size_t pos, unsigned char val )
{
int ret = 0;
size_t off = pos / biL;
size_t idx = pos % biL;
if( val != 0 && val != 1 )
return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
if( X->n * biL <= pos )
{
if( val == 0 )
return( 0 );
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl $0xfffffffc, %eax # imm = 0xFFFFFFFC
cmpb $0x1, %bpl
ja 0x2620f
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %r15
shrq $0x6, %r15
movq 0x8(%rdi), %rax
shlq $0x6, %rax
cmpq %rsi, %rax
jbe 0x261f6
andl $0x3f, %ebx
movq 0x10(%r14), %rax
movq (... | /Dragonchang[P]https_client/mbedtls/library/bignum.c |
mbedtls_mpi_bitlen | size_t mbedtls_mpi_bitlen( const mbedtls_mpi *X )
{
size_t i, j;
if( X->n == 0 )
return( 0 );
for( i = X->n - 1; i > 0; i-- )
if( X->p[i] != 0 )
break;
j = biL - mbedtls_clz( X->p[i] );
return( ( i * biL ) + j );
} | movq 0x8(%rdi), %rsi
testq %rsi, %rsi
je 0x26291
movq 0x10(%rdi), %rdx
movq %rsi, %rax
shlq $0x6, %rax
addq $0x40, %rax
decq %rsi
movq %rsi, %rdi
subq $0x1, %rdi
jb 0x26294
movq (%rdx,%rsi,8), %rcx
addq $-0x40, %rax
movq %rdi, %rsi
testq %rcx, %rcx
je 0x26279
jmp 0x2629c
xorl %eax, %eax
retq
movq (%rdx), %rcx
movl $0x4... | /Dragonchang[P]https_client/mbedtls/library/bignum.c |
mbedtls_mpi_read_string | int mbedtls_mpi_read_string( mbedtls_mpi *X, int radix, const char *s )
{
int ret;
size_t i, j, slen, n;
mbedtls_mpi_uint d;
mbedtls_mpi T;
if( radix < 2 || radix > 16 )
return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
mbedtls_mpi_init( &T );
slen = strlen( s );
if( radix == 16 )
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %esi, %r13d
leal -0x11(%r13), %eax
movl $0xfffffffc, %r12d # imm = 0xFFFFFFFC
cmpl $-0xf, %eax
jb 0x2642c
movq %rdx, %rbx
movq %rdi, %r14
movl $0x1, 0x40(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rsp)
movq %rdx, %rdi
callq 0... | /Dragonchang[P]https_client/mbedtls/library/bignum.c |
mbedtls_mpi_add_int | int mbedtls_mpi_add_int( mbedtls_mpi *X, const mbedtls_mpi *A, mbedtls_mpi_sint b )
{
mbedtls_mpi _B;
mbedtls_mpi_uint p[1];
p[0] = ( b < 0 ) ? -b : b;
_B.s = ( b < 0 ) ? -1 : 1;
_B.n = 1;
_B.p = p;
return( mbedtls_mpi_add_mpi( X, A, &_B ) );
} | subq $0x28, %rsp
movq %rdx, %rax
negq %rax
cmovsq %rdx, %rax
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
sarq $0x3f, %rdx
orl $0x1, %edx
leaq 0x10(%rsp), %rax
movl %edx, (%rax)
movq $0x1, 0x8(%rax)
movq %rcx, 0x10(%rax)
movq %rax, %rdx
callq 0x2720d
addq $0x28, %rsp
retq
| /Dragonchang[P]https_client/mbedtls/library/bignum.c |
mbedtls_mpi_write_file | int mbedtls_mpi_write_file( const char *p, const mbedtls_mpi *X, int radix, FILE *fout )
{
int ret;
size_t n, slen, plen;
/*
* Buffer should have space for (short) label and decimal formatted MPI,
* newline characters and '\0'
*/
char s[ MBEDTLS_MPI_RW_BUFFER_SIZE ];
memset( s, 0, si... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x9d0, %rsp # imm = 0x9D0
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10(%rsp), %r12
movl $0x9b4, %edx # imm = 0x9B4
movq %r12, %rdi
xorl %esi, %esi
callq 0xf150
leaq 0x8(%rsp), %r8
movl $0x9b2, %ecx ... | /Dragonchang[P]https_client/mbedtls/library/bignum.c |
mpi_miller_rabin | static int mpi_miller_rabin( const mbedtls_mpi *X,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
{
int ret, count;
size_t i, j, k, n, s;
mbedtls_mpi W, R, T, A, RR;
mbedtls_mpi_init( &W ); mbedtls_mpi_init( &R ); mbedtls_mpi_init(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4b8, %rsp # imm = 0x4B8
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %eax
leaq 0x30(%rsp), %rdi
movl %eax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movl %eax, 0x60(%rsp)
movups %xmm0, 0x68(%rsp)
movl %eax, 0x80(%... | /Dragonchang[P]https_client/mbedtls/library/bignum.c |
mbedtls_cipher_finish | int mbedtls_cipher_finish( mbedtls_cipher_context_t *ctx,
unsigned char *output, size_t *olen )
{
if( NULL == ctx || NULL == ctx->cipher_info || NULL == olen )
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
*olen = 0;
if( MBEDTLS_MODE_CFB == ctx->cipher_info->mode ||
MBEDT... | pushq %r15
pushq %r14
pushq %rbx
movl $0xffff9f00, %eax # imm = 0xFFFF9F00
testq %rdi, %rdi
je 0x2abc0
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rcx
testq %rcx, %rcx
sete %dl
testq %rbx, %rbx
sete %sil
orb %dl, %sil
jne 0x2abc0
movq $0x0, (%rbx)
movl 0x4(%rcx), %edx
decl %edx
cmpl $0x6, %edx
j... | /Dragonchang[P]https_client/mbedtls/library/cipher.c |
get_pkcs_padding | static int get_pkcs_padding( unsigned char *input, size_t input_len,
size_t *data_len )
{
size_t i, pad_idx;
unsigned char padding_len, bad = 0;
if( NULL == input || NULL == data_len )
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
padding_len = input[input_len - 1];
*data_len = inpu... | testq %rdi, %rdi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
movl $0xffff9f00, %eax # imm = 0xFFFF9F00
jne 0x2ac52
movzbl -0x1(%rdi,%rsi), %ecx
testq %rcx, %rcx
sete %r9b
movq %rsi, %r8
subq %rcx, %r8
setb %al
movq %r8, (%rdx)
orb %r9b, %al
testq %rsi, %rsi
je 0x2ac46
xorl %edx, %edx
xorl %r9d, %r9d
movb (%rd... | /Dragonchang[P]https_client/mbedtls/library/cipher.c |
get_one_and_zeros_padding | static int get_one_and_zeros_padding( unsigned char *input, size_t input_len,
size_t *data_len )
{
size_t i;
unsigned char done = 0, prev_done, bad;
if( NULL == input || NULL == data_len )
return( MBEDTLS_ERR_CIPHER_BAD_INPUT_DATA );
bad = 0xFF;
*data_... | testq %rdi, %rdi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
movl $0xffff9f00, %eax # imm = 0xFFFF9F00
jne 0x2aceb
movq $0x0, (%rdx)
testq %rsi, %rsi
je 0x2acec
decq %rsi
xorl %ecx, %ecx
movb $-0x1, %al
xorl %r8d, %r8d
xorl %r9d, %r9d
cmpb $0x0, (%rdi,%rsi)
setne %r9b
orl %r8d, %r9d
cmpl %r8d, %r9d
sete %r8b
... | /Dragonchang[P]https_client/mbedtls/library/cipher.c |
mbedtls_cipher_crypt | int mbedtls_cipher_crypt( mbedtls_cipher_context_t *ctx,
const unsigned char *iv, size_t iv_len,
const unsigned char *input, size_t ilen,
unsigned char *output, size_t *olen )
{
int ret;
size_t finish_olen;
if( ( ret = mbedtls_cipher_set_iv( ctx, iv, iv... | movl $0xffff9f00, %eax # imm = 0xFFFF9F00
testq %rdi, %rdi
je 0x2af80
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r13
movq %rdi, %r14
movq (%rdi), %rcx
testq %rcx, %rcx
sete %dl
testq %rsi, %rsi
sete %dil
orb %dl, %dil
jne 0x2af72
movl $0xffff9f80, %eax... | /Dragonchang[P]https_client/mbedtls/library/cipher.c |
mbedtls_ctr_drbg_update | void mbedtls_ctr_drbg_update( mbedtls_ctr_drbg_context *ctx,
const unsigned char *additional, size_t add_len )
{
unsigned char add_input[MBEDTLS_CTR_DRBG_SEEDLEN];
if( add_len > 0 )
{
/* MAX_INPUT would be more logical here, but we have to match
* block_cipher_df()'s ... | testq %rdx, %rdx
je 0x2b528
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movl $0x180, %eax # imm = 0x180
cmpq %rax, %rdx
cmovbq %rdx, %rax
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rdx
callq 0x2b529
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2b6b0
addq $0x38, %rsp
popq %rbx
popq %r14
retq
| /Dragonchang[P]https_client/mbedtls/library/ctr_drbg.c |
ctr_drbg_update_internal | static int ctr_drbg_update_internal( mbedtls_ctr_drbg_context *ctx,
const unsigned char data[MBEDTLS_CTR_DRBG_SEEDLEN] )
{
unsigned char tmp[MBEDTLS_CTR_DRBG_SEEDLEN];
unsigned char *p = tmp;
int i, j;
memset( tmp, 0, MBEDTLS_CTR_DRBG_SEEDLEN );
for( j = 0; j < MBEDTL... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r12
movaps %xmm0, 0x20(%r12)
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
leaq 0x28(%rdi), %r15
xorl %r13d, %r13d
movl $0xf, %eax
cmpq $-0x1, %rax
je 0x2b6f5
incb (%rbx,%rax)
leaq -0x1... | /Dragonchang[P]https_client/mbedtls/library/ctr_drbg.c |
mbedtls_ctr_drbg_update_seed_file | int mbedtls_ctr_drbg_update_seed_file( mbedtls_ctr_drbg_context *ctx, const char *path )
{
FILE *f;
size_t n;
unsigned char buf[ MBEDTLS_CTR_DRBG_MAX_INPUT ];
if( ( f = fopen( path, "rb" ) ) == NULL )
return( MBEDTLS_ERR_CTR_DRBG_FILE_IO_ERROR );
fseek( f, 0, SEEK_END );
n = (size_t) f... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2ac9b(%rip), %rsi # 0x565b3
movq %rbx, %rdi
callq 0xf2f0
movl $0xffffffc6, %ebp # imm = 0xFFFFFFC6
testq %rax, %rax
je 0x2b9bc
movq %rax, %r15
movq %rax, %rdi
xor... | /Dragonchang[P]https_client/mbedtls/library/ctr_drbg.c |
mbedtls_des3_crypt_cbc | int mbedtls_des3_crypt_cbc( mbedtls_des3_context *ctx,
int mode,
size_t length,
unsigned char iv[8],
const unsigned char *input,
unsigned char *output )
{
int i;
unsigned char temp[8];
if( length % 8 )
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movl $0xffffffce, %eax # imm = 0xFFFFFFCE
testb $0x7, %r12b
jne 0x2cc9a
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %r13
cmpl $0x1, %esi
jne 0x2cc5f
testq %r12, %r12
je 0x2cc98
xorl %eax, %eax
movb (%r15,%rax... | /Dragonchang[P]https_client/mbedtls/library/des.c |
ecp_modp | static int ecp_modp( mbedtls_mpi *N, const mbedtls_ecp_group *grp )
{
int ret;
if( grp->modp == NULL )
return( mbedtls_mpi_mod_mpi( N, N, &grp->P ) );
/* N->s < 0 is a much faster test, which fails only if N is 0 */
if( ( N->s < 0 && mbedtls_mpi_cmp_int( N, 0 ) != 0 ) ||
mbedtls_mpi_bi... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0xc8(%rsi)
je 0x30b63
cmpl $0x0, (%r14)
js 0x30b7c
movq %r14, %rdi
callq 0x2625b
movq %rax, %rcx
movq 0xb0(%rbx), %rdx
addq %rdx, %rdx
movl $0xffffb080, %eax # imm = 0xFFFFB080
cmpq %rdx, %rcx
ja 0x30b95
movq %r14, %rdi
callq *0xc8(%rbx)
... | /Dragonchang[P]https_client/mbedtls/library/ecp.c |
mbedtls_entropy_update_manual | int mbedtls_entropy_update_manual( mbedtls_entropy_context *ctx,
const unsigned char *data, size_t len )
{
int ret;
#if defined(MBEDTLS_THREADING_C)
if( ( ret = mbedtls_mutex_lock( &ctx->mutex ) ) != 0 )
return( ret );
#endif
ret = entropy_update( ctx, MBEDTLS_ENTROPY_SO... | pushq %rax
movq %rdx, %rcx
movq %rsi, %rdx
movl $0x14, %esi
callq 0x331f1
xorl %eax, %eax
popq %rcx
retq
| /Dragonchang[P]https_client/mbedtls/library/entropy.c |
entropy_gather_internal | static int entropy_gather_internal( mbedtls_entropy_context *ctx )
{
int ret, i, have_one_strong = 0;
unsigned char buf[MBEDTLS_ENTROPY_MAX_GATHER];
size_t olen;
if( ctx->source_count == 0 )
return( MBEDTLS_ERR_ENTROPY_NO_SOURCES_DEFINED );
/*
* Run through our entropy sources
*/... | cmpl $0x0, 0xd8(%rdi)
je 0x3331f
jle 0x33325
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x100(%rdi), %r12
xorl %r13d, %r13d
leaq 0x10(%rsp), %r14
leaq 0x8(%rsp), %r15
xorl %ebp, %ebp
movl (%r12), %eax
cmpl $0x1, %eax
cmovel %eax, %ebp
movq $0x0, 0x8(%rsp)
mov... | /Dragonchang[P]https_client/mbedtls/library/entropy.c |
mbedtls_entropy_write_seed_file | int mbedtls_entropy_write_seed_file( mbedtls_entropy_context *ctx, const char *path )
{
int ret = MBEDTLS_ERR_ENTROPY_FILE_IO_ERROR;
FILE *f;
unsigned char buf[MBEDTLS_ENTROPY_BLOCK_SIZE];
if( ( f = fopen( path, "wb" ) ) == NULL )
return( MBEDTLS_ERR_ENTROPY_FILE_IO_ERROR );
if( ( ret = mb... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rax
movq %rdi, %r14
leaq 0x230ab(%rip), %rsi # 0x565b0
movq %rax, %rdi
callq 0xf2f0
testq %rax, %rax
je 0x33558
movq %rax, %rbx
movq %rsp, %rsi
movl $0x40, %edx
movq %r14, %rdi
callq 0x3332b
movl %eax, %ebp
testl %eax, %eax
jne 0x3354e
movq %rsp, %rdi
mo... | /Dragonchang[P]https_client/mbedtls/library/entropy.c |
mbedtls_gcm_finish | int mbedtls_gcm_finish( mbedtls_gcm_context *ctx,
unsigned char *tag,
size_t tag_len )
{
unsigned char work_buf[16];
size_t i;
uint64_t orig_len = ctx->len * 8;
uint64_t orig_add_len = ctx->add_len * 8;
if( tag_len > 16 || tag_len < 4 )
return( MBEDTLS_ERR_GC... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq -0x11(%rdx), %rax
movl $0xffffffec, %r15d # imm = 0xFFFFFFEC
cmpq $-0xd, %rax
jb 0x38955
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq 0x158(%rdi), %rbp
movq 0x160(%rdi), %r13
shlq $0x3, %rbp
shlq $0x3, %r13
leaq 0x168(%rdi), ... | /Dragonchang[P]https_client/mbedtls/library/gcm.c |
mbedtls_rsa_check_pubkey | int mbedtls_rsa_check_pubkey( const mbedtls_rsa_context *ctx )
{
if( !ctx->N.p || !ctx->E.p )
return( MBEDTLS_ERR_RSA_KEY_CHECK_FAILED );
if( ( ctx->N.p[0] & 1 ) == 0 ||
( ctx->E.p[0] & 1 ) == 0 )
return( MBEDTLS_ERR_RSA_KEY_CHECK_FAILED );
if( mbedtls_mpi_bitlen( &ctx->N ) < 128 |... | pushq %r15
pushq %r14
pushq %rbx
movq 0x20(%rdi), %rax
movl $0xffffbe00, %ebx # imm = 0xFFFFBE00
testq %rax, %rax
je 0x3efb5
movq %rdi, %r14
movq 0x38(%rdi), %rcx
testq %rcx, %rcx
je 0x3efb5
testb $0x1, (%rax)
je 0x3efb5
testb $0x1, (%rcx)
je 0x3efb5
leaq 0x10(%r14), %r15
movq %r15, %rdi
callq 0x2625b
cmpq $0x80,... | /Dragonchang[P]https_client/mbedtls/library/rsa.c |
mbedtls_rsa_private | int mbedtls_rsa_private( mbedtls_rsa_context *ctx,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng,
const unsigned char *input,
unsigned char *output )
{
int ret;
size_t olen;
mbedtls_mpi T, T1, T2;
/* Make sure we have priv... | movl $0xffffbf80, %eax # imm = 0xFFFFBF80
cmpq $0x0, 0x68(%rdi)
je 0x3f545
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %r14
cmpq $0x0, 0x80(%rdi)
je 0x3f537
cmpq $0x0, 0x50(%r14)
je 0x3f537
movq %r8, %rbx
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %r15
leaq 0x10(%... | /Dragonchang[P]https_client/mbedtls/library/rsa.c |
mbedtls_rsa_rsassa_pkcs1_v15_verify | int mbedtls_rsa_rsassa_pkcs1_v15_verify( mbedtls_rsa_context *ctx,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng,
int mode,
mbedtls_md_type_t md_alg,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x438, %rsp # imm = 0x438
movl %r9d, %r12d
movl %r8d, %ebp
movl %ecx, %eax
movq 0x478(%rsp), %rcx
cmpl $0x1, %eax
jne 0x40951
movl $0xffffbf80, %ebx # imm = 0xFFFFBF80
cmpl $0x0, 0x148(%rdi)
jne 0x40b55
movq 0x8(%rdi), %r15
leaq -0... | /Dragonchang[P]https_client/mbedtls/library/rsa.c |
mbedtls_sha256_finish | void mbedtls_sha256_finish( mbedtls_sha256_context *ctx, unsigned char output[32] )
{
uint32_t last, padn;
uint32_t high, low;
unsigned char msglen[8];
high = ( ctx->total[0] >> 29 )
| ( ctx->total[1] << 3 );
low = ( ctx->total[0] << 3 );
PUT_UINT32_BE( high, msglen, 0 );
PUT_U... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl (%rdi), %eax
movl 0x4(%rdi), %ecx
shldl $0x3, %eax, %ecx
movq %rsi, %r14
leal (,%rax,8), %edx
movl %ecx, %esi
shrl $0x18, %esi
leaq 0x8(%rsp), %r15
movb %sil, (%r15)
movl %ecx, %esi
shrl $0x10, %esi
movb %sil, 0x1(%r15)
movb %ch, 0xa(%rsp)
movb %cl,... | /Dragonchang[P]https_client/mbedtls/library/sha256.c |
mbedtls_sha256_self_test | int mbedtls_sha256_self_test( int verbose )
{
int i, j, k, buflen, ret = 0;
unsigned char *buf;
unsigned char sha256sum[32];
mbedtls_sha256_context ctx;
buf = mbedtls_calloc( 1024, sizeof(unsigned char) );
if( NULL == buf )
{
if( verbose != 0 )
mbedtls_printf( "Buffer al... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %edi, %ebp
movl $0x400, %edi # imm = 0x400
movl $0x1, %esi
callq 0xf1d0
testq %rax, %rax
je 0x43526
movq %rax, %rbx
movl %ebp, (%rsp)
xorps %xmm0, %xmm0
leaq 0x4(%rsp), %r14
movups %xmm0, 0x58(%r14)
movups %xmm0, 0x48(%r1... | /Dragonchang[P]https_client/mbedtls/library/sha256.c |
mbedtls_timing_get_timer | unsigned long mbedtls_timing_get_timer( struct mbedtls_timing_hr_time *val, int reset )
{
unsigned long delta;
struct timeval offset;
struct _hr_time *t = (struct _hr_time *) val;
gettimeofday( &offset, NULL );
if( reset )
{
t->start.tv_sec = offset.tv_sec;
t->start.tv_usec = ... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0xf140
movq (%r14), %rax
testl %ebp, %ebp
je 0x441b3
movq %rax, (%rbx)
movq 0x8(%rsp), %rax
movq %rax, 0x8(%rbx)
xorl %eax, %eax
jmp 0x441e4
subq (%rbx), %rax
imulq $0x3e8, %rax, %rcx ... | /Dragonchang[P]https_client/mbedtls/library/timing.c |
mbedtls_aes_setkey_enc | int mbedtls_aes_setkey_enc( mbedtls_aes_context *ctx, const unsigned char *key,
unsigned int keybits )
{
unsigned int i;
uint32_t *RK;
#if !defined(MBEDTLS_AES_ROM_TABLES)
if( aes_init_done == 0 )
{
aes_gen_tables();
aes_init_done = 1;
}
#endif
switch( keyb... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x818, %rsp # imm = 0x818
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x0, 0x2df54(%rip) # 0x72650
jne 0x44a48
movl $0x1, %edx
xorl %eax, %eax
xorl %ecx, %ecx
movl %edx, 0x410(%rsp,%rcx,4)
movl %edx, %esi
movl %ecx, 0x10(%... | /Dragonchang[P]https_client/mbedtls/library/aes.c |
mbedtls_aes_crypt_cfb8 | int mbedtls_aes_crypt_cfb8( mbedtls_aes_context *ctx,
int mode,
size_t length,
unsigned char iv[16],
const unsigned char *input,
unsigned char *output )
{
unsigned char c;
unsigned char ov[17];
... | testq %rdx, %rdx
je 0x45adb
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbx
movq %r8, %r12
movq %rcx, %r15
movq %rdi, %rbp
xorl %r14d, %r14d
movq %rdx, 0x20(%rsp)
movl %esi, 0xc(%rsp)
movq (%r15), %rax
movq %rax, 0x10(%rsp)
movl 0x8(%r15), %eax
movl %eax, 0x18(%rsp)
mov... | /Dragonchang[P]https_client/mbedtls/library/aes.c |
mbedtls_aes_self_test | int mbedtls_aes_self_test( int verbose )
{
int ret = 0, i, j, u, v;
unsigned char key[32];
unsigned char buf[64];
#if defined(MBEDTLS_CIPHER_MODE_CBC) || defined(MBEDTLS_CIPHER_MODE_CFB)
unsigned char iv[16];
#endif
#if defined(MBEDTLS_CIPHER_MODE_CBC)
unsigned char prv[16];
#endif
#if defined(MBEDT... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movl %edi, 0xc(%rsp)
pxor %xmm0, %xmm0
leaq 0x80(%rsp), %rax
movdqa %xmm0, (%rax)
movdqa %xmm0, 0x10(%rax)
leaq 0xc0(%rsp), %r15
movl $0x120, %edx # imm = 0x120
movq %r15, %rdi
xorl %esi, %esi
callq 0... | /Dragonchang[P]https_client/mbedtls/library/aes.c |
mbedtls_ecdsa_sign | int mbedtls_ecdsa_sign( mbedtls_ecp_group *grp, mbedtls_mpi *r, mbedtls_mpi *s,
const mbedtls_mpi *d, const unsigned char *buf, size_t blen,
int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
{
int ret, key_tries, sign_tries, blind_tries;
mbedtls_ecp_point R;
mbedtl... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
cmpq $0x0, 0xa8(%rdi)
je 0x490ab
movq %rcx, %rbx
movq %rsi, %r13
movq %rdi, %rbp
movq %r9, 0x30(%rsp)
movq %rdx, 0x10(%rsp)
movq %r8, 0x28(%rsp)
leaq 0x98(%rdi), %rax
movq %rax, 0x8(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x2e171
leaq 0x68(%rs... | /Dragonchang[P]https_client/mbedtls/library/ecdsa.c |
derive_mpi | static int derive_mpi( const mbedtls_ecp_group *grp, mbedtls_mpi *x,
const unsigned char *buf, size_t blen )
{
int ret;
size_t n_size = ( grp->nbits + 7 ) / 8;
size_t use_size = blen > n_size ? n_size : blen;
MBEDTLS_MPI_CHK( mbedtls_mpi_read_binary( x, buf, use_size ) );
if(... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0xb8(%rdi), %r15
addq $0x7, %r15
shrq $0x3, %r15
cmpq %rcx, %r15
cmovaeq %rcx, %r15
movq %rsi, %rdi
movq %rdx, %rsi
movq %r15, %rdx
callq 0x26b13
testl %eax, %eax
je 0x4913a
popq %rbx
popq %r14
popq %r15
retq
shlq $0x3, %r15
subq 0xb8(%rbx), %r15
jbe... | /Dragonchang[P]https_client/mbedtls/library/ecdsa.c |
mbedtls_aes_crypt_cfb8 | int mbedtls_aes_crypt_cfb8( mbedtls_aes_context *ctx,
int mode,
size_t length,
unsigned char iv[16],
const unsigned char *input,
unsigned char *output )
{
unsigned char c;
... | testq %rdx, %rdx
je 0x10e14
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbx
movq %r8, %r12
movq %rcx, %r15
movq %rdi, %rbp
xorl %r14d, %r14d
movq %rdx, 0x20(%rsp)
movl %esi, 0xc(%rsp)
movq (%r15), %rax
movq %rax, 0x10(%rsp)
movl 0x8(%r15), %eax
movl %eax, 0x18(%rsp)
mov... | /ARMmbed[P]mbed-crypto/library/aes.c |
mbedtls_mpi_free | void mbedtls_mpi_free( mbedtls_mpi *X )
{
if( X == NULL )
return;
if( X->p != NULL )
{
mbedtls_mpi_zeroize( X->p, X->n );
mbedtls_free( X->p );
}
X->s = 1;
X->n = 0;
X->p = NULL;
} | testq %rdi, %rdi
je 0x12068
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x1205a
movq 0x8(%rbx), %rsi
shlq $0x3, %rsi
callq 0x27260
movq 0x10(%rbx), %rdi
callq 0xb030
movl $0x1, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
popq %rbx
retq
| /ARMmbed[P]mbed-crypto/library/bignum.c |
mbedtls_mpi_shrink | int mbedtls_mpi_shrink( mbedtls_mpi *X, size_t nblimbs )
{
mbedtls_mpi_uint *p;
size_t i;
MPI_VALIDATE_RET( X != NULL );
if( nblimbs > MBEDTLS_MPI_MAX_LIMBS )
return( MBEDTLS_ERR_MPI_ALLOC_FAILED );
/* Actually resize up if there are currently fewer than nblimbs limbs. */
if( X->n <= n... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl $0xfffffff0, %ebp # imm = 0xFFFFFFF0
cmpq $0x2710, %rsi # imm = 0x2710
ja 0x12196
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
cmpq %rsi, %r15
jbe 0x121a7
movq %r15, %rcx
movq %rcx, %rax
cmpq $0x1, %rcx
je 0x1213c
... | /ARMmbed[P]mbed-crypto/library/bignum.c |
mbedtls_mpi_set_bit | int mbedtls_mpi_set_bit( mbedtls_mpi *X, size_t pos, unsigned char val )
{
int ret = 0;
size_t off = pos / biL;
size_t idx = pos % biL;
MPI_VALIDATE_RET( X != NULL );
if( val != 0 && val != 1 )
return( MBEDTLS_ERR_MPI_BAD_INPUT_DATA );
if( X->n * biL <= pos )
{
if( val == 0... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl $0xfffffffc, %eax # imm = 0xFFFFFFFC
cmpb $0x1, %bpl
ja 0x1248b
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %r15
shrq $0x6, %r15
movq 0x8(%rdi), %rax
shlq $0x6, %rax
cmpq %rsi, %rax
jbe 0x12472
andl $0x3f, %ebx
movq 0x10(%r14), %rax
movq (... | /ARMmbed[P]mbed-crypto/library/bignum.c |
mbedtls_mpi_add_int | int mbedtls_mpi_add_int( mbedtls_mpi *X, const mbedtls_mpi *A, mbedtls_mpi_sint b )
{
mbedtls_mpi _B;
mbedtls_mpi_uint p[1];
MPI_VALIDATE_RET( X != NULL );
MPI_VALIDATE_RET( A != NULL );
p[0] = ( b < 0 ) ? -b : b;
_B.s = ( b < 0 ) ? -1 : 1;
_B.n = 1;
_B.p = p;
return( mbedtls_mpi_a... | subq $0x28, %rsp
movq %rdx, %rax
negq %rax
cmovsq %rdx, %rax
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
sarq $0x3f, %rdx
orl $0x1, %edx
leaq 0x10(%rsp), %rax
movl %edx, (%rax)
movq $0x1, 0x8(%rax)
movq %rcx, 0x10(%rax)
movq %rax, %rdx
callq 0x1370f
addq $0x28, %rsp
retq
| /ARMmbed[P]mbed-crypto/library/bignum.c |
mbedtls_mpi_shift_r | int mbedtls_mpi_shift_r( mbedtls_mpi *X, size_t count )
{
size_t i, v0, v1;
mbedtls_mpi_uint r0 = 0, r1;
MPI_VALIDATE_RET( X != NULL );
v0 = count / biL;
v1 = count & (biL - 1);
if( v0 > X->n || ( v0 == X->n && v1 > 0 ) )
return mbedtls_mpi_lset( X, 0 );
/*
* shift by count ... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, %rcx
shrq $0x6, %rcx
movl %esi, %eax
andl $0x3f, %eax
movq 0x8(%rdi), %rdi
cmpq %rdi, %rcx
ja 0x131cd
setne %dl
testq %rax, %rax
sete %r8b
orb %dl, %r8b
jne 0x13211
movl $0x1, %esi
movq %rbx, %rdi
callq 0x12069
movl %eax, %r14d
testl %eax, %eax
jne 0x132b2
mov... | /ARMmbed[P]mbed-crypto/library/bignum.c |
mbedtls_mpi_cmp_mpi | int mbedtls_mpi_cmp_mpi( const mbedtls_mpi *X, const mbedtls_mpi *Y )
{
size_t i, j;
MPI_VALIDATE_RET( X != NULL );
MPI_VALIDATE_RET( Y != NULL );
for( i = X->n; i > 0; i-- )
if( X->p[i - 1] != 0 )
break;
for( j = Y->n; j > 0; j-- )
if( Y->p[j - 1] != 0 )
br... | movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x13346
movq 0x10(%rdi), %rax
cmpq $0x0, -0x8(%rax,%rcx,8)
jne 0x13348
decq %rcx
jne 0x13339
xorl %ecx, %ecx
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x13362
movq 0x10(%rsi), %rdx
cmpq $0x0, -0x8(%rdx,%rax,8)
jne 0x13364
decq %rax
jne 0x13355
xorl %eax, %eax
movq %rax, %rdx
orq ... | /ARMmbed[P]mbed-crypto/library/bignum.c |
mbedtls_mpi_div_mpi | int mbedtls_mpi_div_mpi( mbedtls_mpi *Q, mbedtls_mpi *R, const mbedtls_mpi *A,
const mbedtls_mpi *B )
{
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
size_t i, n, t, k;
mbedtls_mpi X, Y, Z, T1, T2;
mbedtls_mpi_uint TP2[3];
MPI_VALIDATE_RET( A != NULL );
MPI_VALIDATE_R... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x58(%rsp), %rax
movq $0x0, (%rax)
leaq 0x70(%rsp), %rsi
movl $0x1, (%rsi)
movq $0x1, 0x8(%rsi)
movq %rax, 0x10(%rsi)
movq %rcx, %rdi
callq 0x1332c
testl %eax, %eax
je ... | /ARMmbed[P]mbed-crypto/library/bignum.c |
mbedtls_mpi_gcd | int mbedtls_mpi_gcd( mbedtls_mpi *G, const mbedtls_mpi *A, const mbedtls_mpi *B )
{
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
size_t lz, lzt;
mbedtls_mpi TA, TB;
MPI_VALIDATE_RET( G != NULL );
MPI_VALIDATE_RET( A != NULL );
MPI_VALIDATE_RET( B != NULL );
mbedtls_mpi_init( &TA ); mbe... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movl $0x1, %eax
leaq 0x20(%rsp), %rdi
movl %eax, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movl %eax, 0x8(%rsp)
movups %xmm0, 0x10(%rsp)
callq 0x121c0
testl %eax, %eax
jne 0x14e15
leaq 0x8(%rsp), %... | /ARMmbed[P]mbed-crypto/library/bignum.c |
mbedtls_mpi_inv_mod | int mbedtls_mpi_inv_mod( mbedtls_mpi *X, const mbedtls_mpi *A, const mbedtls_mpi *N )
{
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
mbedtls_mpi G, TA, TU, U1, U2, TB, TV, V1, V2;
MPI_VALIDATE_RET( X != NULL );
MPI_VALIDATE_RET( A != NULL );
MPI_VALIDATE_RET( N != NULL );
if( mbedtls_mpi_cm... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x1, %eax
leaq 0xe0(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x18(%rsp), %rsi
movl $0x1, (%rsi)
movq %rax, 0x8(%rsi)
movq %rcx, 0x10(%rsi)
movq %rdx, %rdi
callq 0x1332c
testl %eax, %eax
jle... | /ARMmbed[P]mbed-crypto/library/bignum.c |
mbedtls_mpi_is_prime_ext | int mbedtls_mpi_is_prime_ext( const mbedtls_mpi *X, int rounds,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
{
int ret = MBEDTLS_ERR_ERROR_CORRUPTION_DETECTED;
mbedtls_mpi XX;
MPI_VALIDATE_RET( X != NULL );
MPI_VALIDATE_RET(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movl $0x1, %ecx
leaq 0x10(%rsp), %rax
movl %ecx, (%rax)
movq 0x8(%rdi), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rdi), %rdx
movq %rdx, 0x10(%rax)
leaq 0x8(%rsp), %r12
movq $0x0, (%r12)
leaq 0x28(%rsp), %r... | /ARMmbed[P]mbed-crypto/library/bignum.c |
mbedtls_mpi_is_prime | int mbedtls_mpi_is_prime( const mbedtls_mpi *X,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng )
{
MPI_VALIDATE_RET( X != NULL );
MPI_VALIDATE_RET( f_rng != NULL );
/*
* In the past our key generation aimed for an error rate of at most
* 2^-80. ... | movq %rdx, %rcx
movq %rsi, %rdx
movl $0x28, %esi
jmp 0x155dc
| /ARMmbed[P]mbed-crypto/library/bignum.c |
mbedtls_blowfish_crypt_cfb64 | int mbedtls_blowfish_crypt_cfb64( mbedtls_blowfish_context *ctx,
int mode,
size_t length,
size_t *iv_off,
unsigned char iv[MBEDTLS_BLOWFISH_BLOCKSIZE],
const unsigned char *input,
un... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq (%rcx), %rbp
movl $0xffffffea, %eax # imm = 0xFFFFFFEA
cmpq $0x7, %rbp
ja 0x167b0
movq %r9, %r14
movq %r8, %r15
movq %rdx, %r12
movq %rcx, 0x10(%rsp)
movq 0x50(%rsp), %rbx
testl %esi, %esi
je 0x16765
testq... | /ARMmbed[P]mbed-crypto/library/blowfish.c |
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.