name string | code string | asm string | file string |
|---|---|---|---|
llvm::SmallPtrSetIterator<llvm::cl::OptionCategory*>::operator*() const | const PtrTy operator*() const {
assert(isHandleInSync() && "invalid iterator access!");
if (shouldReverseIterate()) {
assert(Bucket > End);
return PtrTraits::getFromVoidPointer(const_cast<void *>(Bucket[-1]));
}
assert(Bucket < End);
return PtrTraits::getFromVoidPointer(const_cast<void*>... | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
callq 0x240d0
testb $0x1, %al
jne 0x2b1ed
jmp 0x2b204
movq (%rsp), %rax
movq (%rax), %rax
movq -0x8(%rax), %rdi
callq 0x2bb20
movq %rax, 0x10(%rsp)
jmp 0x2b218
movq (%rsp), %rax
movq (%rax), %rax
movq (%rax), %rdi
callq 0x2bb20
movq %rax, 0x10... | /llvm/ADT/SmallPtrSet.h |
llvm::NextPowerOf2(unsigned long) | constexpr uint64_t NextPowerOf2(uint64_t A) {
A |= (A >> 1);
A |= (A >> 2);
A |= (A >> 4);
A |= (A >> 8);
A |= (A >> 16);
A |= (A >> 32);
return A + 1;
} | movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x2, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x4, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x8, %rax
orq -0x8(%rsp), %rax
mo... | /llvm/Support/MathExtras.h |
llvm::cl::ExpansionContext::expandResponseFiles(llvm::SmallVectorImpl<char const*>&)::ResponseFileRecord const* llvm::SmallVectorTemplateCommon<llvm::cl::ExpansionContext::expandResponseFiles(llvm::SmallVectorImpl<char const*>&)::ResponseFileRecord, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<... | static const T *reserveForParamAndGetAddressImpl(U *This, const T &Elt,
size_t N) {
size_t NewSize = This->size() + N;
if (LLVM_LIKELY(NewSize <= This->capacity()))
return &Elt;
bool ReferencesStorage = false;
int64_t Index = -1;
if (!U::Take... | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rdi
callq 0x4d300
addq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
callq 0x4d110
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
ja 0x34b57
movq 0x40(%r... | /llvm/ADT/SmallVector.h |
llvm::DenseMap<unsigned int, llvm::DebugCounter::CounterInfo, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::DebugCounter::CounterInfo>>::allocateBuckets(unsigned int) | bool allocateBuckets(unsigned Num) {
NumBuckets = Num;
if (NumBuckets == 0) {
Buckets = nullptr;
return false;
}
Buckets = static_cast<BucketT *>(
allocate_buffer(sizeof(BucketT) * NumBuckets, alignof(BucketT)));
return true;
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %ecx
movl %ecx, 0x10(%rax)
cmpl $0x0, 0x10(%rax)
jne 0x3b2b7
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movb $0x0, 0x27(%rsp)
jmp 0x3b2df
movq 0x8(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, %edi
shlq $... | /llvm/ADT/DenseMap.h |
void llvm::cl::list_storage<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, llvm::DebugCounter>::addValue<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool) | void addValue(const T &V, bool initial = false) {
assert(Location != nullptr &&
"cl::location(...) not specified for a command "
"line option with external storage!");
Location->push_back(V);
if (initial)
Default.push_back(V);
} | subq $0x58, %rsp
movb %dl, %al
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
andb $0x1, %al
movb %al, 0x47(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rax), %rdi
movq 0x48(%rsp), %rsi
callq 0x3a530
testb $0x1, 0x47(%rsp)
je 0x3c6e8
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rsi
l... | /llvm/Support/CommandLine.h |
llvm::report_bad_alloc_error(char const*, bool) | void llvm::report_bad_alloc_error(const char *Reason, bool GenCrashDiag) {
fatal_error_handler_t Handler = nullptr;
void *HandlerData = nullptr;
{
// Only acquire the mutex while reading the handler, so as not to invoke a
// user-supplied callback under a lock.
#if LLVM_ENABLE_THREADS == 1
std::lock_g... | subq $0x58, %rsp
movb %sil, %al
movq %rdi, 0x50(%rsp)
andb $0x1, %al
movb %al, 0x4f(%rsp)
movq $0x0, 0x40(%rsp)
movq $0x0, 0x38(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x7b5d8(%rip), %rsi # 0xc0cb8
callq 0x45350
movq 0x7b594(%rip), %rax # 0xc0c80
movq %rax, 0x40(%rsp)
movq 0x7b590(%rip), %rax # 0xc0c88
movq %rax, ... | /Support/ErrorHandling.cpp |
llvm::cl::opt<unsigned long, false, llvm::cl::parser<unsigned long>>::printOptionValue(unsigned long, bool) const | void printOptionValue(size_t GlobalWidth, bool Force) const override {
if (Force || !this->getDefault().compare(this->getValue())) {
cl::printOptionDiff<ParserClass>(*this, Parser, this->getValue(),
this->getDefault(), GlobalWidth);
}
} | subq $0x48, %rsp
movb %dl, %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
andb $0x1, %al
movb %al, 0x37(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movb $0x1, %al
testb $0x1, 0x37(%rsp)
movb %al, 0x1f(%rsp)
jne 0x4bb8e
movq 0x10(%rsp), %rdi
addq $0x80, %rdi
callq 0x4c370
movq 0x10(%rsp), %rdi
movq %rax, 0x8(%rsp... | /llvm/Support/CommandLine.h |
llvm::cl::opt<bool, true, llvm::cl::parser<bool>>::opt<char [6], llvm::cl::desc, llvm::cl::LocationClass<bool>, llvm::cl::OptionHidden>(char const (&) [6], llvm::cl::desc const&, llvm::cl::LocationClass<bool> const&, llvm::cl::OptionHidden const&) | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
xorl %edx, %edx
movl %edx, %esi
callq 0x140a0
movq (%rsp), %rdi
addq $0x80, %rdi
callq 0x3e250
movq (%rsp), %rsi
leaq 0x71376(%rip), %rax # 0xbf170
ad... | /llvm/Support/CommandLine.h |
llvm::StringMapImpl::LookupBucketFor(llvm::StringRef, unsigned int) | unsigned StringMapImpl::LookupBucketFor(StringRef Name,
uint32_t FullHashValue) {
#ifdef EXPENSIVE_CHECKS
assert(FullHashValue == hash(Name));
#endif
// Hash table unallocated so far?
if (NumBuckets == 0)
init(16);
if (shouldReverseIterate())
FullHashValue = ~Full... | subq $0x88, %rsp
movq %rsi, 0x70(%rsp)
movq %rdx, 0x78(%rsp)
movq %rdi, 0x68(%rsp)
movl %ecx, 0x64(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpl $0x0, 0x8(%rax)
jne 0x4e619
movq 0x18(%rsp), %rdi
movl $0x10, %esi
callq 0x4e530
callq 0x240d0
testb $0x1, %al
jne 0x4e624
jmp 0x4e62f
movl 0x64(%rsp), %eax
xorl $-0x... | /Support/StringMap.cpp |
std::pair<llvm::DenseMapIterator<llvm::StringRef, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseSetPair<llvm::StringRef>, false>, bool> llvm::DenseMapBase<llvm::DenseMap<llvm::StringRef, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::De... | std::pair<iterator, bool> try_emplace(const KeyT &Key, Ts &&... Args) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return std::make_pair(makeIterator(TheBucket,
shouldReverseIterate<KeyT>()
? getBuckets()
... | subq $0x88, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, 0x28(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movq %rcx, 0x70(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x30(%rsp)
movq 0x78(%rsp), %rsi
leaq 0x68(%rsp), %rdx
callq 0x4f8b0
testb $0x1, %al
jne 0x4f755
jmp 0x4f7cf
movq 0x68(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::StringRef, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseSetPair<llvm::StringRef>>::allocateBuckets(unsigned int) | bool allocateBuckets(unsigned Num) {
NumBuckets = Num;
if (NumBuckets == 0) {
Buckets = nullptr;
return false;
}
Buckets = static_cast<BucketT *>(
allocate_buffer(sizeof(BucketT) * NumBuckets, alignof(BucketT)));
return true;
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %ecx
movl %ecx, 0x10(%rax)
cmpl $0x0, 0x10(%rax)
jne 0x50677
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movb $0x0, 0x27(%rsp)
jmp 0x5069f
movq 0x8(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, %edi
shlq $... | /llvm/ADT/DenseMap.h |
unsigned int llvm::ComputeMappedEditDistance<char, unsigned int llvm::ComputeEditDistance<char>(llvm::ArrayRef<char>, llvm::ArrayRef<char>, bool, unsigned int)::'lambda'(char const&)>(llvm::ArrayRef<char>, llvm::ArrayRef<char>, unsigned int llvm::ComputeEditDistance<char>(llvm::ArrayRef<char>, llvm::ArrayRef<char>, boo... | unsigned ComputeMappedEditDistance(ArrayRef<T> FromArray, ArrayRef<T> ToArray,
Functor Map, bool AllowReplacements = true,
unsigned MaxEditDistance = 0) {
// The algorithm implemented below is the "classic"
// dynamic-programming algorithm for co... | subq $0x1e8, %rsp # imm = 0x1E8
movb %r8b, %al
movq %rdi, 0x1d0(%rsp)
movq %rsi, 0x1d8(%rsp)
movq %rdx, 0x1c0(%rsp)
movq %rcx, 0x1c8(%rsp)
andb $0x1, %al
movb %al, 0x1be(%rsp)
movl %r9d, 0x1b8(%rsp)
leaq 0x1d0(%rsp), %rdi
callq 0x1c170
movq %rax, 0x1b0(%rsp)
leaq 0x1c0(%rsp), %rdi
callq 0x1c170
movq %rax, 0x... | /llvm/ADT/edit_distance.h |
llvm::hashing::detail::hash_state::mix(char const*) | void mix(const char *s) {
h0 = llvm::rotr<uint64_t>(h0 + h1 + h3 + fetch64(s + 8), 37) * k1;
h1 = llvm::rotr<uint64_t>(h1 + h4 + fetch64(s + 48), 42) * k1;
h0 ^= h6;
h1 += h3 + fetch64(s + 40);
h2 = llvm::rotr<uint64_t>(h2 + h5, 33) * k1;
h3 = h4 * k1;
h4 = h0 + h5;
mix_32_bytes(s, h3, h... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rcx
movq %rcx, 0x20(%rsp)
movq (%rcx), %rax
addq 0x8(%rcx), %rax
addq 0x18(%rcx), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
addq $0x8, %rdi
callq 0x53bd0
movq (%rsp), %rdi
addq %rax, %rdi
movl $0x25, %esi
callq 0x53c40
movq 0x20(%rsp), %r... | /llvm/ADT/Hashing.h |
llvm::hashing::detail::hash_33to64_bytes(char const*, unsigned long, unsigned long) | inline uint64_t hash_33to64_bytes(const char *s, size_t len, uint64_t seed) {
uint64_t z = fetch64(s + 24);
uint64_t a = fetch64(s) + (len + fetch64(s + len - 16)) * k0;
uint64_t b = llvm::rotr<uint64_t>(a + z, 52);
uint64_t c = llvm::rotr<uint64_t>(a, 37);
a += fetch64(s + 8);
c += llvm::rotr<uint64_t>(a, ... | subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x80(%rsp), %rdi
addq $0x18, %rdi
callq 0x53bd0
movq %rax, 0x68(%rsp)
movq 0x80(%rsp), %rdi
callq 0x53bd0
movq %rax, 0x8(%rsp)
movq 0x78(%rsp), %rax
movq %rax, (%rsp)
movq 0x80(%rsp), %rdi
addq 0x78(%rsp), %rdi
addq $-0x10, %rdi
cal... | /llvm/ADT/Hashing.h |
llvm::hashing::detail::hash_16_bytes(unsigned long, unsigned long) | inline uint64_t hash_16_bytes(uint64_t low, uint64_t high) {
// Murmur-inspired hashing.
const uint64_t kMul = 0x9ddfea08eb382d69ULL;
uint64_t a = (low ^ high) * kMul;
a ^= (a >> 47);
uint64_t b = (high ^ a) * kMul;
b ^= (b >> 47);
b *= kMul;
return b;
} | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movabsq $-0x622015f714c7d297, %rax # imm = 0x9DDFEA08EB382D69
movq %rax, -0x18(%rsp)
movq -0x8(%rsp), %rax
xorq -0x10(%rsp), %rax
movabsq $-0x622015f714c7d297, %rcx # imm = 0x9DDFEA08EB382D69
imulq %rcx, %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
shrq $0x2f, %rax
xor... | /llvm/ADT/Hashing.h |
llvm::cl::opt<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, true, llvm::cl::parser<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::handleOccurrence(unsigned int, llvm::StringRef, llvm::StringRef) | bool handleOccurrence(unsigned pos, StringRef ArgName,
StringRef Arg) override {
typename ParserClass::parser_data_type Val =
typename ParserClass::parser_data_type();
if (Parser.parse(*this, ArgName, Arg, Val))
return true; // Parse error!
this->setValue(Val);
this... | subq $0x98, %rsp
movq %rdx, 0x80(%rsp)
movq %rcx, 0x88(%rsp)
movq %r8, 0x70(%rsp)
movq %r9, 0x78(%rsp)
movq %rdi, 0x68(%rsp)
movl %esi, 0x64(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x7590
movq 0x10(%rsp), %rsi
movq %rsi, %rdi
addq $0xb8, %rdi
movq 0x80(%rsp), %rax
movq %rax, 0x30(%... | /llvm/Support/CommandLine.h |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<unsigned long>(unsigned long&, char*, char*, unsigned long) | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
if (!store_and_advance(buffer_ptr, buffer_end, data)) {
// Check for skew which prevents the buffer from being packed, and do
// a partial store into the buffer to fill it. This is only a concern
// with the variadic ... | subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rsi
leaq 0x60(%rsp), %rdi
leaq 0x50(%rsp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x5b5d0
testb $0x1, %al
jne 0x5b5ba
movq 0x58(%... | /llvm/ADT/Hashing.h |
llvm::raw_ostream::SetBufferAndMode(char*, unsigned long, llvm::raw_ostream::BufferKind) | void raw_ostream::SetBufferAndMode(char *BufferStart, size_t Size,
BufferKind Mode) {
assert(((Mode == BufferKind::Unbuffered && !BufferStart && Size == 0) ||
(Mode != BufferKind::Unbuffered && BufferStart && Size != 0)) &&
"stream must be unbuffered or have at le... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpl $0x1, 0x2c(%rax)
jne 0x5dbf7
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x5dbf5
movq 0x8(%rsp), %rdi
callq 0x7520
jmp 0x5dbf7... | /Support/raw_ostream.cpp |
XXH3_len_9to16_64b(unsigned char const*, unsigned long, unsigned char const*, unsigned long) | static uint64_t XXH3_len_9to16_64b(const uint8_t *input, size_t len,
const uint8_t *secret, uint64_t const seed) {
uint64_t input_lo =
(endian::read64le(secret + 24) ^ endian::read64le(secret + 32)) + seed;
uint64_t input_hi =
(endian::read64le(secret + 40) ^ endian::r... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq 0x40(%rsp), %rdi
addq $0x18, %rdi
callq 0x5fcb0
movq %rax, (%rsp)
movq 0x40(%rsp), %rdi
addq $0x20, %rdi
callq 0x5fcb0
movq %rax, %rcx
movq (%rsp), %rax
xorq %rcx, %rax
addq 0x38(%rsp), %rax
movq %rax, 0x30(%rs... | /Support/xxhash.cpp |
XXH3_len_4to8_64b(unsigned char const*, unsigned long, unsigned char const*, unsigned long) | static uint64_t XXH3_len_4to8_64b(const uint8_t *input, size_t len,
const uint8_t *secret, uint64_t seed) {
seed ^= (uint64_t)byteswap(uint32_t(seed)) << 32;
const uint32_t input1 = endian::read32le(input);
const uint32_t input2 = endian::read32le(input + len - 4);
uint64_t acc... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x28(%rsp), %rax
movl %eax, %edi
callq 0x37850
movl %eax, %eax
shlq $0x20, %rax
xorq 0x28(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
callq 0x5fcf0
movl %eax, 0x24(%rsp)
movq 0x40(%rsp), %rdi
addq 0... | /Support/xxhash.cpp |
XXH3_mul128_fold64(unsigned long, unsigned long) | static uint64_t XXH3_mul128_fold64(uint64_t lhs, uint64_t rhs) {
#if defined(__SIZEOF_INT128__) || \
(defined(_INTEGRAL_MAX_BITS) && _INTEGRAL_MAX_BITS >= 128)
__uint128_t product = (__uint128_t)lhs * (__uint128_t)rhs;
return uint64_t(product) ^ uint64_t(product >> 6... | movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq -0x10(%rsp), %rcx
mulq %rcx
movq %rdx, -0x20(%rsp)
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movq -0x20(%rsp), %rcx
xorq %rcx, %rax
retq
nop
| /Support/xxhash.cpp |
(anonymous namespace)::root_dir_start(llvm::StringRef, llvm::sys::path::Style) | size_t root_dir_start(StringRef str, Style style) {
// case "c:/"
if (is_style_windows(style)) {
if (str.size() > 2 && str[1] == ':' && is_separator(str[2], style))
return 2;
}
// case "//net"
if (str.size() > 3 && is_separator(str[0], style) && str[0] == str[1] &&
!is_separat... | subq $0x38, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x1c(%rsp)
movl 0x1c(%rsp), %edi
callq 0x617a0
testb $0x1, %al
jne 0x61b31
jmp 0x61b89
leaq 0x20(%rsp), %rdi
callq 0x11670
cmpq $0x2, %rax
jbe 0x61b87
leaq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x1b290
movsbl %al, %eax
cmpl $0x3a, %eax
jne 0x61b87... | /Support/Path.cpp |
llvm::sys::path::root_directory(llvm::StringRef, llvm::sys::path::Style) | StringRef root_directory(StringRef path, Style style) {
const_iterator b = begin(path, style), pos = b, e = end(path);
if (b != e) {
bool has_net =
b->size() > 2 && is_separator((*b)[0], style) && (*b)[1] == (*b)[0];
bool has_drive = is_style_windows(style) && b->ends_with(":");
if ((has_net ||... | subq $0x128, %rsp # imm = 0x128
movq %rdi, 0x108(%rsp)
movq %rsi, 0x110(%rsp)
movl %edx, 0x104(%rsp)
movq 0x108(%rsp), %rax
movq %rax, 0xc0(%rsp)
movq 0x110(%rsp), %rax
movq %rax, 0xc8(%rsp)
movl 0x104(%rsp), %ecx
movq 0xc0(%rsp), %rsi
movq 0xc8(%rsp), %rdx
leaq 0xd0(%rsp), %rdi
callq 0x61000
leaq 0x90(%rsp)... | /Support/Path.cpp |
clang::pseudo::(anonymous namespace)::GrammarBuilder::build(llvm::StringRef) | Grammar build(llvm::StringRef BNF) {
auto Specs = eliminateOptional(parse(BNF));
assert(llvm::all_of(Specs,
[](const RuleSpec &R) {
if (R.Target.ends_with(OptSuffix))
return false;
return llvm::all_of(
... | subq $0x458, %rsp # imm = 0x458
movq %rdi, 0x58(%rsp)
movq %rdi, %rax
movq %rax, 0x60(%rsp)
movq %rdi, 0x450(%rsp)
movq %rdx, 0x440(%rsp)
movq %rcx, 0x448(%rsp)
movq %rsi, 0x438(%rsp)
movq 0x438(%rsp), %rsi
movq %rsi, 0x68(%rsp)
movq 0x440(%rsp), %rax
movq %rax, 0x3e8(%rsp)
movq 0x448(%rsp), %rax
movq %rax, ... | /lib/grammar/GrammarBNF.cpp |
void llvm::sort<__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>(__gn... | inline void sort(IteratorTy Start, IteratorTy End) {
if constexpr (detail::sort_trivially_copyable<IteratorTy>::value) {
// Forward trivially copyable types to array_pod_sort. This avoids a large
// amount of code bloat for a minor performance hit.
array_pod_sort(Start, End);
} else {
#ifdef EXPENSIVE_C... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x81810
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
| /llvm/ADT/STLExtras.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::write_int<fmt::v5::basic_format_specs<char>, fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<int, fmt::v5::basic_format_specs<char>>::bin_writer<1>>(int, fmt::v5::basic_str... | void write_int(int num_digits, string_view prefix,
const Spec &spec, F f) {
std::size_t size = prefix.size() + internal::to_unsigned(num_digits);
char_type fill = static_cast<char_type>(spec.fill());
std::size_t padding = 0;
if (spec.align() == ALIGN_NUMERIC) {
if (spec.width() > ... | pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %esi, %r10d
addq %rcx, %r10
movb 0x4(%r8), %r11b
movl 0x8(%r8), %eax
cmpl $0x4, %eax
jne 0x77bf
movl (%r8), %esi
cmpq %rsi, %r10
movq %rsi, %r14
cmovaq %r10, %r14
xorl %ebx, %ebx
subq %r10, %rsi
cmovaeq %rsi, %rbx
movq %r14, %r10
jmp 0x77d6
movl 0xc(%r8), %ebx
cmpl %esi, %ebx... | /twanas[P]spdlog-cmake/external/spdlog/include/spdlog/fmt/bundled/format.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::write_padded<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<int... | void write_padded(const align_spec &spec, F &&f) {
unsigned width = spec.width(); // User-perceived width (in code points).
size_t size = f.size(); // The number of code units.
size_t num_code_points = width != 0 ? f.width() : size;
if (width <= num_code_points)
return f(reserve(size));
auto &... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movl (%rsi), %eax
movq (%rdx), %r15
movq %rax, %r14
subq %r15, %r14
jbe 0x7ef6
movq %rsi, %r13
movq %r12, 0x10(%rsp)
movq (%rdi), %rbp
movq 0x10(%rbp), %r12
movq %rax, 0x8(%rsp)
leaq (%r12,%rax), %rbx
cmpq %rbx, 0x18(%rbp... | /twanas[P]spdlog-cmake/external/spdlog/include/spdlog/fmt/bundled/format.h |
fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<unsigned int, fmt::v5::basic_format_specs<char>>::on_num() | void on_num() {
int num_digits = internal::count_digits(abs_value);
char_type sep = internal::thousands_sep<char_type>(writer.locale_);
int size = num_digits + SEP_SIZE * ((num_digits - 1) / 3);
writer.write_int(size, get_prefix(), spec,
num_writer{abs_value, size, sep});
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl 0x10(%rdi), %r12d
movl %r12d, %eax
orl $0x1, %eax
bsrl %eax, %eax
xorl $-0x20, %eax
imull $0x4d1, %eax, %r15d # imm = 0x4D1
addl $0x9ef1, %r15d # imm = 0x9EF1
shrl $0xc, %r15d
leaq 0x12524(%rip), %rax ... | /twanas[P]spdlog-cmake/external/spdlog/include/spdlog/fmt/bundled/format.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<long long, fmt::v5::basic_format_specs<char>>::hex_writer>::operator()<char*>(char*&&) const | void operator()(It &&it) const {
if (prefix.size() != 0)
it = internal::copy_str<char_type>(prefix.begin(), prefix.end(), it);
it = std::fill_n(it, padding, fill);
f(it);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r15
testq %r15, %r15
je 0xa24e
movq (%rbx), %r12
movq 0x8(%r14), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x53b0
addq %r15, %r12
movq %r12, (%rbx)
movq (%rbx), %r15
movq 0x20(%r14), %r12
movq %r15, %r13
testq %r12... | /twanas[P]spdlog-cmake/external/spdlog/include/spdlog/fmt/bundled/format.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<long long, fmt::v5::basic_format_specs<char>>::bin_writer<1>>::operator()<char*&>(char*&) const | void operator()(It &&it) const {
if (prefix.size() != 0)
it = internal::copy_str<char_type>(prefix.begin(), prefix.end(), it);
it = std::fill_n(it, padding, fill);
f(it);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r15
testq %r15, %r15
je 0xa642
movq (%rbx), %r12
movq 0x8(%r14), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x53b0
addq %r15, %r12
movq %r12, (%rbx)
movq (%rbx), %r15
movq 0x20(%r14), %r12
movq %r15, %r13
testq %r12... | /twanas[P]spdlog-cmake/external/spdlog/include/spdlog/fmt/bundled/format.h |
void fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::padded_int_writer<fmt::v5::basic_writer<fmt::v5::back_insert_range<fmt::v5::internal::basic_buffer<char>>>::int_writer<char, fmt::v5::basic_format_specs<char>>::bin_writer<1>>::operator()<char*&>(char*&) const | void operator()(It &&it) const {
if (prefix.size() != 0)
it = internal::copy_str<char_type>(prefix.begin(), prefix.end(), it);
it = std::fill_n(it, padding, fill);
f(it);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r15
testq %r15, %r15
je 0xd74c
movq (%rbx), %r12
movq 0x8(%r14), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x53b0
addq %r15, %r12
movq %r12, (%rbx)
movq (%rbx), %r15
movq 0x20(%r14), %r12
movq %r15, %r13
testq %r12... | /twanas[P]spdlog-cmake/external/spdlog/include/spdlog/fmt/bundled/format.h |
char const* fmt::v5::internal::parse_format_specs<char, fmt::v5::internal::specs_checker<fmt::v5::internal::specs_handler<fmt::v5::basic_format_context<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>>&>(char const*, char const*, fmt::v5::internal::specs_checker<fmt::v5::internal::specs_handler<... | FMT_CONSTEXPR const Char *parse_format_specs(
const Char *begin, const Char *end, SpecHandler &&handler) {
if (begin == end || *begin == '}')
return begin;
begin = parse_align(begin, end, handler);
if (begin == end) return begin;
// Parse sign.
switch (static_cast<char>(*begin)) {
case '+':
ha... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rax
movq %rdi, (%rsp)
cmpq %rsi, %rdi
je 0x10703
cmpb $0x7d, (%rax)
je 0x10703
movq %rdx, %rbx
movq %rsi, %r14
movq %rax, %rdi
callq 0x1071a
movq %rax, (%rsp)
cmpq %r14, %rax
je 0x10703
movzbl (%rax), %eax
cmpl $0x20, %eax
je 0x10578
cmpl $0x2d, %eax
je 0x10... | /twanas[P]spdlog-cmake/external/spdlog/include/spdlog/fmt/bundled/format.h |
fmt::v5::internal::specs_checker<fmt::v5::internal::specs_handler<fmt::v5::basic_format_context<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>>::on_hash() | FMT_CONSTEXPR void on_hash() {
require_numeric_argument();
Handler::on_hash();
} | pushq %rbx
movq %rdi, %rbx
movl 0x10(%rdi), %eax
decl %eax
cmpl $0x9, %eax
jb 0x10828
movq 0x8(%rbx), %rdi
leaq 0x9d26(%rip), %rsi # 0x1a549
callq 0x6928
movq (%rbx), %rax
orb $0x8, 0x10(%rax)
popq %rbx
retq
| /twanas[P]spdlog-cmake/external/spdlog/include/spdlog/fmt/bundled/format.h |
char const* fmt::v5::internal::parse_arg_id<char, fmt::v5::internal::precision_adapter<fmt::v5::internal::specs_checker<fmt::v5::internal::specs_handler<fmt::v5::basic_format_context<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>>&, char>>(char const*, char const*, fmt::v5::internal::precision... | FMT_CONSTEXPR const Char *parse_arg_id(
const Char *begin, const Char *end, IDHandler &&handler) {
assert(begin != end);
Char c = *begin;
if (c == '}' || c == ':')
return handler(), begin;
if (c >= '0' && c <= '9') {
unsigned index = parse_nonnegative_int(begin, end, handler);
if (begin == end |... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %rbx
movq %rdi, 0x28(%rsp)
movzbl (%rdi), %eax
cmpl $0x7d, %eax
je 0x10944
cmpl $0x3a, %eax
jne 0x10951
movq %rbx, %rdi
callq 0x1110a
jmp 0x109e0
movq %rsi, %r14
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
ja 0x109be
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movq %r14,... | /twanas[P]spdlog-cmake/external/spdlog/include/spdlog/fmt/bundled/format.h |
spdlog::pattern_formatter::get_time_(spdlog::details::log_msg const&) | std::tm get_time_(const details::log_msg &msg)
{
if (pattern_time_type_ == pattern_time_type::local)
{
return details::os::localtime(log_clock::to_time_t(msg.time));
}
return details::os::gmtime(log_clock::to_time_t(msg.time));
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x48(%rsi)
je 0x12c22
movabsq $0x112e0be826d694b3, %rax # imm = 0x112E0BE826D694B3
imulq 0x10(%rdx)
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x1a, %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %rdi
movq %rdx, (%rdi)
movq %rbx, %rsi
callq 0x5480
jmp 0x12c4e
movabsq $0x112e0be8... | /twanas[P]spdlog-cmake/external/spdlog/include/spdlog/details/pattern_formatter.h |
spdlog::pattern_formatter::handle_flag_(char, spdlog::details::padding_info) | void handle_flag_(char flag, details::padding_info padding)
{
switch (flag)
{
case ('+'): // default formatter
formatters_.push_back(details::make_unique<details::full_formatter>(padding));
break;
case 'n': // logger name
formatters_.push_back(de... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %r15d
movq %rdi, %rbx
leal -0x21(%r15), %eax
cmpl $0x59, %eax
ja 0x13a65
movl %ecx, %ebp
movq %rdx, %r14
leaq 0x6f35(%rip), %rcx # 0x1a114
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addq $0x90, %rbx
movl $0x18, %edi
callq 0x5280
mov... | /twanas[P]spdlog-cmake/external/spdlog/include/spdlog/details/pattern_formatter.h |
spdlog::details::level_formatter::format(spdlog::details::log_msg const&, tm const&, fmt::v5::basic_memory_buffer<char, 500ul, std::allocator<char>>&) | void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
{
string_view_t &level_name = level::to_string_view(msg.level);
if (padinfo_.enabled())
{
scoped_pad p(level_name, padinfo_, dest);
fmt_helper::append_string_view(level_name, ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movl 0x8(%rsi), %ecx
shlq $0x4, %rcx
leaq 0x10f78(%rip), %rax # 0x24cd0
addq %rcx, %rax
cmpq $0x0, 0x8(%rdi)
je 0x13dc1
movq %rdi, %rdx
addq $0x8, %rdx
movq (%rax), %r15
movq 0x8(%rax), %r14
movq %rsp, %rdi
movq %r14, %rsi
movq %rbx, %rcx
... | /twanas[P]spdlog-cmake/external/spdlog/include/spdlog/details/pattern_formatter.h |
spdlog::details::t_formatter::format(spdlog::details::log_msg const&, tm const&, fmt::v5::basic_memory_buffer<char, 500ul, std::allocator<char>>&) | void format(const details::log_msg &msg, const std::tm &, fmt::memory_buffer &dest) override
{
if (padinfo_.enabled())
{
const auto field_size = fmt_helper::count_digits(msg.thread_id);
scoped_pad p(field_size, padinfo_, dest);
fmt_helper::append_int(msg.thread_id... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rcx, %rbx
movq %rsi, %r14
cmpq $0x0, 0x8(%rdi)
movq 0x18(%rsi), %rsi
je 0x13f94
movq %rdi, %rdx
addq $0x8, %rdx
movq %rsi, %rax
orq $0x1, %rax
bsrq %rax, %rax
xorl $-0x40, %eax
imull $0x4d1, %eax, %eax # imm = 0x4D1
addl $0x13911, %eax ... | /twanas[P]spdlog-cmake/external/spdlog/include/spdlog/details/pattern_formatter.h |
spdlog::details::a_formatter::format(spdlog::details::log_msg const&, tm const&, fmt::v5::basic_memory_buffer<char, 500ul, std::allocator<char>>&) | void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
{
string_view_t field_value{days[tm_time.tm_wday]};
scoped_pad p(field_value, padinfo_, dest);
fmt_helper::append_string_view(field_value, dest);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdi, %r12
movslq 0x18(%rdx), %rax
leaq 0x10bfa(%rip), %rcx # 0x24d80
movq (%rcx,%rax,8), %r14
movq %r14, %rdi
callq 0x5120
movq %rax, %r15
addq $0x8, %r12
movq %rsp, %rdi
movq %rax, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1400a
... | /twanas[P]spdlog-cmake/external/spdlog/include/spdlog/details/pattern_formatter.h |
spdlog::details::b_formatter::format(spdlog::details::log_msg const&, tm const&, fmt::v5::basic_memory_buffer<char, 500ul, std::allocator<char>>&) | void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
{
string_view_t field_value{months[tm_time.tm_mon]};
scoped_pad p(field_value, padinfo_, dest);
fmt_helper::append_string_view(field_value, dest);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdi, %r12
movslq 0x10(%rdx), %rax
leaq 0x10b2e(%rip), %rcx # 0x24e00
movq (%rcx,%rax,8), %r14
movq %r14, %rdi
callq 0x5120
movq %rax, %r15
addq $0x8, %r12
movq %rsp, %rdi
movq %rax, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1400a
... | /twanas[P]spdlog-cmake/external/spdlog/include/spdlog/details/pattern_formatter.h |
spdlog::details::B_formatter::format(spdlog::details::log_msg const&, tm const&, fmt::v5::basic_memory_buffer<char, 500ul, std::allocator<char>>&) | void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
{
string_view_t field_value{full_months[tm_time.tm_mon]};
scoped_pad p(field_value, padinfo_, dest);
fmt_helper::append_string_view(field_value, dest);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdi, %r12
movslq 0x10(%rdx), %rax
leaq 0x10ae8(%rip), %rcx # 0x24e60
movq (%rcx,%rax,8), %r14
movq %r14, %rdi
callq 0x5120
movq %rax, %r15
addq $0x8, %r12
movq %rsp, %rdi
movq %rax, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1400a
... | /twanas[P]spdlog-cmake/external/spdlog/include/spdlog/details/pattern_formatter.h |
void spdlog::details::fmt_helper::pad2<500ul>(int, fmt::v5::basic_memory_buffer<char, 500ul, std::allocator<char>>&) | inline void pad2(int n, fmt::basic_memory_buffer<char, Buffer_Size> &dest)
{
if (n > 99)
{
append_int(n, dest);
}
else if (n > 9) // 10-99
{
dest.push_back(static_cast<char>('0' + n / 10));
dest.push_back(static_cast<char>('0' + n % 10));
}
else if (n >= 0) // 0-9
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movl %edi, %ebp
cmpl $0x64, %edi
jl 0x1476d
movl %ebp, %esi
movq %rsp, %r15
movq %r15, %rdi
callq 0x12b1e
movq %rax, %r14
movq %rax, 0x18(%r15)
leaq 0x15(%rsp), %r13
movq %r13, %r12
subq %rax, %r12
movq 0x10(%rbx), %r15
a... | /twanas[P]spdlog-cmake/external/spdlog/include/spdlog/details/fmt_helper.h |
spdlog::details::Y_formatter::format(spdlog::details::log_msg const&, tm const&, fmt::v5::basic_memory_buffer<char, 500ul, std::allocator<char>>&) | void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
{
const size_t field_size = 4;
scoped_pad p(field_size, padinfo_, dest);
fmt_helper::append_int(tm_time.tm_year + 1900, dest);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rcx, %rbx
movq %rdx, %r14
leaq 0x8(%rdi), %rdx
leaq 0x28(%rsp), %rdi
movl $0x4, %esi
callq 0x1400a
movl 0x14(%r14), %r15d
leal 0x76c(%r15), %eax
movl %eax, %esi
negl %esi
cmovsl %eax, %esi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x12b1e
mo... | /twanas[P]spdlog-cmake/external/spdlog/include/spdlog/details/pattern_formatter.h |
spdlog::details::T_formatter::format(spdlog::details::log_msg const&, tm const&, fmt::v5::basic_memory_buffer<char, 500ul, std::allocator<char>>&) | void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
{
const size_t field_size = 8;
scoped_pad p(field_size, padinfo_, dest);
fmt_helper::pad2(tm_time.tm_hour, dest);
dest.push_back(':');
fmt_helper::pad2(tm_time.tm_min, dest);
... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r14
leaq 0x8(%rdi), %rdx
movq %rsp, %rdi
movl $0x8, %esi
callq 0x1400a
movl 0x8(%r14), %edi
movq %rbx, %rsi
callq 0x146fd
movq 0x10(%rbx), %rsi
incq %rsi
cmpq %rsi, 0x18(%rbx)
jae 0x1575d
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq 0x8(%rbx), %... | /twanas[P]spdlog-cmake/external/spdlog/include/spdlog/details/pattern_formatter.h |
spdlog::details::z_formatter::format(spdlog::details::log_msg const&, tm const&, fmt::v5::basic_memory_buffer<char, 500ul, std::allocator<char>>&) | void format(const details::log_msg &msg, const std::tm &tm_time, fmt::memory_buffer &dest) override
{
const size_t field_size = 6;
scoped_pad p(field_size, padinfo_, dest);
#ifdef _WIN32
int total_minutes = get_cached_offset(msg, tm_time);
#else
// No need to chache under gcc,
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rcx, %rbx
movq %rdx, %r14
leaq 0x8(%rdi), %rdx
leaq 0x8(%rsp), %rdi
movl $0x6, %esi
callq 0x1400a
movq 0x28(%r14), %rcx
movabsq $-0x7777777777777777, %rdx # imm = 0x8888888888888889
movq %rcx, %rax
imulq %rdx
movq %rdx, %r14
addq %rcx, %r14
movq %r14, %rcx
shrq $0... | /twanas[P]spdlog-cmake/external/spdlog/include/spdlog/details/pattern_formatter.h |
spdlog::details::pid_formatter::format(spdlog::details::log_msg const&, tm const&, fmt::v5::basic_memory_buffer<char, 500ul, std::allocator<char>>&) | void format(const details::log_msg &, const std::tm &, fmt::memory_buffer &dest) override
{
const auto pid = static_cast<uint32_t>(details::os::pid());
if (padinfo_.enabled())
{
auto field_size = fmt_helper::count_digits(pid);
scoped_pad p(field_size, padinfo_, dest);... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %rbx
movq %rdi, %r14
callq 0x5370
movl %eax, %ebp
cmpq $0x0, 0x8(%r14)
je 0x159d0
addq $0x8, %r14
movl %ebp, %eax
orl $0x1, %eax
bsrl %eax, %eax
xorl $-0x20, %eax
imull $0x4d1, %eax, %esi # imm = 0x4D1
addl $0x9ef1, %esi ... | /twanas[P]spdlog-cmake/external/spdlog/include/spdlog/details/pattern_formatter.h |
spdlog::details::source_location_formatter::format(spdlog::details::log_msg const&, tm const&, fmt::v5::basic_memory_buffer<char, 500ul, std::allocator<char>>&) | void format(const details::log_msg &, const std::tm &tm_time, fmt::memory_buffer &dest) override
{
string_view_t field_value{full_days[tm_time.tm_wday]};
scoped_pad p(field_value, padinfo_, dest);
fmt_helper::append_string_view(field_value, dest);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
cmpl $0x0, 0x40(%rsi)
je 0x15c85
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq 0x8(%rdi), %rbp
movq 0x38(%rsi), %r13
movq %r13, %rdi
callq 0x5120
movq %rax, %r15
testq %rbp, %rbp
je 0x15bce
addq $0x8, %r12
movl 0x40(%r14), %eax
mo... | /twanas[P]spdlog-cmake/external/spdlog/include/spdlog/details/pattern_formatter.h |
spdlog::sinks::ansicolor_sink<spdlog::details::console_stdout, spdlog::details::console_mutex>::set_color_mode_(spdlog::color_mode) | void set_color_mode_(color_mode mode)
{
switch (mode)
{
case color_mode::always:
should_do_colors_ = true;
break;
case color_mode::automatic:
should_do_colors_ = details::os::in_terminal(target_file_) && details::os::is_color_terminal();
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
je 0x16e8f
cmpl $0x2, %esi
je 0x16e8b
cmpl $0x1, %esi
jne 0x16e97
movq 0x318(%rbx), %rdi
callq 0x52b0
movl %eax, %edi
callq 0x53f0
testl %eax, %eax
je 0x16e8b
leaq 0x3a55(%rip), %rdi # 0x1a8c0
callq 0x5300
movq %rax, (%rsp)
testq %rax, %rax
je 0x16e... | /twanas[P]spdlog-cmake/external/spdlog/include/spdlog/sinks/ansicolor_sink.h |
spdlog::sinks::ansicolor_sink<spdlog::details::console_stdout, spdlog::details::console_mutex>::log(spdlog::details::log_msg const&) | void log(const details::log_msg &msg) override
{
// Wrap the originally formatted message in color codes.
// If color is not supported in the terminal, log as is instead.
std::lock_guard<mutex_t> lock(mutex_);
fmt::memory_buffer formatted;
formatter_->format(msg, formatted);... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x220, %rsp # imm = 0x220
movq %rsi, %r15
movq %rdi, %r14
movq 0x320(%rdi), %rbx
movq %rbx, %rdi
callq 0x5380
testl %eax, %eax
jne 0x173b5
xorps %xmm0, %xmm0
leaq 0x28(%rsp), %r12
movups %xmm0, -0x18(%r12)
leaq 0xdd3e(%rip), %r13 # 0x24fc8
mov... | /twanas[P]spdlog-cmake/external/spdlog/include/spdlog/sinks/ansicolor_sink.h |
spdlog::sinks::ansicolor_sink<spdlog::details::console_stdout, spdlog::details::console_mutex>::set_pattern(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void set_pattern(const std::string &pattern) final
{
std::lock_guard<mutex_t> lock(mutex_);
formatter_ = std::unique_ptr<spdlog::formatter>(new pattern_formatter(pattern));
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r12
movq %rdi, %r15
movq 0x320(%rdi), %rbx
movq %rbx, %rdi
callq 0x5380
testl %eax, %eax
jne 0x17502
movl $0xa8, %edi
callq 0x5280
movq %rax, %r14
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq ... | /twanas[P]spdlog-cmake/external/spdlog/include/spdlog/sinks/ansicolor_sink.h |
spdlog::details::registry::initialize_logger(std::shared_ptr<spdlog::logger>) | void initialize_logger(std::shared_ptr<logger> new_logger)
{
std::lock_guard<std::mutex> lock(logger_map_mutex_);
new_logger->set_formatter(formatter_->clone());
if (err_handler_)
{
new_logger->set_error_handler(err_handler_);
}
new_logger->set_level(lev... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x5380
testl %eax, %eax
jne 0x186f8
movq (%r14), %r15
movq 0xb0(%rbx), %rsi
movq (%rsi), %rax
movq %rsp, %rdi
callq *0x18(%rax)
movq 0x28(%r15), %r13
movq 0x30(%r15), %rbp
cmpq %rbp, %r13
je 0x1862e
... | /twanas[P]spdlog-cmake/external/spdlog/include/spdlog/details/registry.h |
spdlog::sinks::base_sink<std::mutex>::set_formatter(std::unique_ptr<spdlog::formatter, std::default_delete<spdlog::formatter>>) | void set_formatter(std::unique_ptr<spdlog::formatter> sink_formatter) final
{
std::lock_guard<Mutex> lock(mutex_);
set_formatter_(std::move(sink_formatter));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x5380
testl %eax, %eax
jne 0x18d91
movq (%r15), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq $0x0, (%r15)
movq (%r14), %rax
movq %r14, %rdi
callq *0x48(%rax)
movq 0x8(%rsp), %rdi
testq %rdi... | /twanas[P]spdlog-cmake/external/spdlog/include/spdlog/sinks/base_sink.h |
spdlog::spdlog_ex::spdlog_ex(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) | spdlog_ex(const std::string &msg, int last_errno)
{
fmt::memory_buffer outbuf;
fmt::format_system_error(outbuf, last_errno, msg);
msg_ = fmt::to_string(outbuf);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp # imm = 0x238
movq %rdi, %rbx
leaq 0xcda7(%rip), %rax # 0x25d88
movq %rax, (%rdi)
leaq 0x8(%rdi), %r14
leaq 0x18(%rdi), %r13
movq %r13, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
xorps %xmm0, %xmm0
leaq 0x40(%... | /twanas[P]spdlog-cmake/external/spdlog/include/spdlog/common.h |
fmt::v5::format_system_error(fmt::v5::internal::basic_buffer<char>&, int, fmt::v5::basic_string_view<char>) | FMT_FUNC void format_system_error(
internal::buffer &out, int error_code, string_view message) FMT_NOEXCEPT {
FMT_TRY {
memory_buffer buf;
buf.resize(inline_buffer_size);
for (;;) {
char *system_message = &buf[0];
int result = safe_strerror(error_code, system_message, buf.size());
if... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %rcx, (%rsp)
movq %rdx, 0x8(%rsp)
movl %esi, %ebx
movq %rdi, %r12
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rcx
movups %xmm0, -0x18(%rcx)
leaq 0xbe71(%rip), %rax # 0x24fc8
movq %rax, -0x20(%rcx)
movq %rcx, ... | /twanas[P]spdlog-cmake/external/spdlog/include/spdlog/fmt/bundled/format-inl.h |
spdlog::details::registry::register_logger_(std::shared_ptr<spdlog::logger>) | void register_logger_(std::shared_ptr<logger> new_logger)
{
auto logger_name = new_logger->name();
throw_if_exists_(logger_name);
loggers_[logger_name] = std::move(new_logger);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x12e7e
movq %r14, %rdi
movq %r15, %rsi
callq 0x198ee
addq $0x... | /twanas[P]spdlog-cmake/external/spdlog/include/spdlog/details/registry.h |
iutest::JunitXmlGeneratorListener::SetUp() | static bool SetUp()
{
::std::string xmlpath = TestEnv::get_report_junit_xml_filepath();
if( !xmlpath.empty() )
{
TestEnv::event_listeners().set_default_xml_generator(new JunitXmlGeneratorListener(xmlpath));
return true;
}
return false;
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq -0x28(%rbp), %rdi
callq 0x45610
leaq -0x28(%rbp), %rdi
callq 0x376d0
testb $0x1, %al
jne 0x4467e
callq 0x3e8d0
movq %rax, -0x40(%rbp)
jmp 0x44619
movl $0x50, %edi
callq 0x37400
movq %rax, -0x48(%rbp)
jmp 0x44629
movq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x45760... | /srz-zumix[P]iutest/include/listener/iutest_junit_xml_generator.hpp |
iutest::detail::TypeParamTestInstance<floatingpoint_test::iu_FloatingpointTest_x_iutest_x_NINF_Test, iutest::detail::VariadicTypeList<float, double, long double>>::EachTest<iutest::detail::VariadicTypeList<float, double, long double>, void>::EachTest(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocat... | EachTest(const ::std::string& testsuite, const char* name, size_t index, const char* file, int line)
: m_mediator(AddTestSuite(testsuite, index, file, line))
, m_info(&m_mediator, name, &m_factory)
, m_next(testsuite, name, index+1, file, line)
{
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
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, -0x88(%rbp)
movq %rax, %rcx
movq %rcx, -0x98(%rbp)
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20... | /srz-zumix[P]iutest/include/iutest_typed_tests.hpp |
iutest::detail::TypeParamTestInstance<floatingpoint_test::iu_FloatingpointTest_x_iutest_x_NINF_Test, iutest::detail::VariadicTypeList<float, double, long double>>::EachTest<iutest::detail::VariadicTypeList<double, long double>, void>::EachTest(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char... | EachTest(const ::std::string& testsuite, const char* name, size_t index, const char* file, int line)
: m_mediator(AddTestSuite(testsuite, index, file, line))
, m_info(&m_mediator, name, &m_factory)
, m_next(testsuite, name, index+1, file, line)
{
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
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, -0x88(%rbp)
movq %rax, %rcx
movq %rcx, -0x98(%rbp)
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20... | /srz-zumix[P]iutest/include/iutest_typed_tests.hpp |
iutest::detail::TypeParamTestInstance<floatingpoint_test::iu_FloatingpointTest_x_iutest_x_NINF_Test, iutest::detail::VariadicTypeList<float, double, long double>>::EachTest<iutest::detail::VariadicTypeList<float, double, long double>, void>::AddTestSuite(char const*, unsigned long, char const*, int) | static TestSuite* AddTestSuite(const char* testsuite, size_t index, const char* file, int line)
{
#if !defined(IUTEST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS)
return UnitTest::instance().AddTestSuite<_MyTestSuite>(
#else
return UnitTest::instance().AddTestSuite(
#endif
#if IUTEST_HAS_TYP... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
callq 0x3d7a0
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x53610
callq 0x53710
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
movl -... | /srz-zumix[P]iutest/include/iutest_typed_tests.hpp |
iutest::legacy::SuiteApiResolver<floatingpoint_test::iu_FloatingpointTest_x_iutest_x_NINF_Test<float>>::GetSetUpCaseOrSuite(char const*, int) | static SetUpTearDownTestSuiteFuncType GetSetUpCaseOrSuite(const char* file, int line)
{
SetUpTearDownTestSuiteFuncType testcase = GetNotDefaultOrNull(&T::SetUpTestCase, &Tester::SetUpTestCase);
SetUpTearDownTestSuiteFuncType testsuite = GetNotDefaultOrNull(&T::SetUpTestSuite, &Tester::SetUpTestSuite... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x6d59(%rip), %rsi # 0x54ab0
movq %rsi, %rdi
callq 0x54a80
movq %rax, -0x18(%rbp)
leaq -0x6d5c(%rip), %rsi # 0x54ac0
movq %rsi, %rdi
callq 0x54a80
movq %rax, -0x20(%rbp)
callq 0x54ad0
testl %e... | /srz-zumix[P]iutest/include/iutest_legacy.hpp |
iutest::legacy::SuiteApiResolver<floatingpoint_test::iu_FloatingpointTest_x_iutest_x_NINF_Test<float>>::GetTearDownCaseOrSuite(char const*, int) | static SetUpTearDownTestSuiteFuncType GetTearDownCaseOrSuite(const char* file, int line)
{
SetUpTearDownTestSuiteFuncType testcase = GetNotDefaultOrNull(&T::TearDownTestCase, &Tester::TearDownTestCase);
SetUpTearDownTestSuiteFuncType testsuite = GetNotDefaultOrNull(&T::TearDownTestSuite, &Tester::Te... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x6eb9(%rip), %rsi # 0x54b00
movq %rsi, %rdi
callq 0x54a80
movq %rax, -0x18(%rbp)
leaq -0x6ebc(%rip), %rsi # 0x54b10
movq %rsi, %rdi
callq 0x54a80
movq %rax, -0x20(%rbp)
callq 0x54ad0
testl %e... | /srz-zumix[P]iutest/include/iutest_legacy.hpp |
floatingpoint_test::iu_FloatingpointTest_x_iutest_x_NINF_Test<float>::Body() | IUTEST_TYPED_TEST(FloatingpointTest, NINF)
{
typedef typename TestFixture::ftype FloatType;
TypeParam a= - TestFixture::ONE;
TypeParam b=TestFixture::ZERO;
IUTEST_EXPECT_EQ(FloatType(a/b), FloatType::NINF());
} | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x8(%rbp)
movaps 0x537a(%rip), %xmm1 # 0x61040
movss 0x1e742(%rip), %xmm0 # 0x7a410
pxor %xmm1, %xmm0
movss %xmm0, -0xc(%rbp)
movss 0x1f5ad(%rip), %xmm0 # 0x7b28c
movss %xmm0, -0x10(%rbp)
callq 0x54ad0
testl %eax, %eax
jne 0x5bc... | /srz-zumix[P]iutest/test/floatingpoint_tests.cpp |
iutest::detail::TypeParamTestInstance<floatingpoint_test::iu_FloatingpointTest_x_iutest_x_NINF_Test, iutest::detail::VariadicTypeList<float, double, long double>>::EachTest<iutest::detail::VariadicTypeList<long double>, void>::EachTest(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const... | EachTest(const ::std::string& testsuite, const char* name, size_t index, const char* file, int line)
: m_mediator(AddTestSuite(testsuite, index, file, line))
, m_info(&m_mediator, name, &m_factory)
, m_next(testsuite, name, index+1, file, line)
{
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
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, -0x88(%rbp)
movq %rax, %rcx
movq %rcx, -0x98(%rbp)
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20... | /srz-zumix[P]iutest/include/iutest_typed_tests.hpp |
iutest::detail::TypeParamTestInstance<floatingpoint_test::iu_FloatingpointTest_x_iutest_x_NINF_Test, iutest::detail::VariadicTypeList<float, double, long double>>::EachTest<iutest::detail::VariadicTypeList<double, long double>, void>::AddTestSuite(char const*, unsigned long, char const*, int) | static TestSuite* AddTestSuite(const char* testsuite, size_t index, const char* file, int line)
{
#if !defined(IUTEST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS)
return UnitTest::instance().AddTestSuite<_MyTestSuite>(
#else
return UnitTest::instance().AddTestSuite(
#endif
#if IUTEST_HAS_TYP... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
callq 0x3d7a0
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x53610
callq 0x53710
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
movl -... | /srz-zumix[P]iutest/include/iutest_typed_tests.hpp |
iutest::legacy::SuiteApiResolver<floatingpoint_test::iu_FloatingpointTest_x_iutest_x_NINF_Test<double>>::GetSetUpCaseOrSuite(char const*, int) | static SetUpTearDownTestSuiteFuncType GetSetUpCaseOrSuite(const char* file, int line)
{
SetUpTearDownTestSuiteFuncType testcase = GetNotDefaultOrNull(&T::SetUpTestCase, &Tester::SetUpTestCase);
SetUpTearDownTestSuiteFuncType testsuite = GetNotDefaultOrNull(&T::SetUpTestSuite, &Tester::SetUpTestSuite... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x76b9(%rip), %rsi # 0x54ab0
movq %rsi, %rdi
callq 0x54a80
movq %rax, -0x18(%rbp)
leaq -0x76bc(%rip), %rsi # 0x54ac0
movq %rsi, %rdi
callq 0x54a80
movq %rax, -0x20(%rbp)
callq 0x54ad0
testl %e... | /srz-zumix[P]iutest/include/iutest_legacy.hpp |
iutest::legacy::SuiteApiResolver<floatingpoint_test::iu_FloatingpointTest_x_iutest_x_NINF_Test<double>>::GetTearDownCaseOrSuite(char const*, int) | static SetUpTearDownTestSuiteFuncType GetTearDownCaseOrSuite(const char* file, int line)
{
SetUpTearDownTestSuiteFuncType testcase = GetNotDefaultOrNull(&T::TearDownTestCase, &Tester::TearDownTestCase);
SetUpTearDownTestSuiteFuncType testsuite = GetNotDefaultOrNull(&T::TearDownTestSuite, &Tester::Te... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x7819(%rip), %rsi # 0x54b00
movq %rsi, %rdi
callq 0x54a80
movq %rax, -0x18(%rbp)
leaq -0x781c(%rip), %rsi # 0x54b10
movq %rsi, %rdi
callq 0x54a80
movq %rax, -0x20(%rbp)
callq 0x54ad0
testl %e... | /srz-zumix[P]iutest/include/iutest_legacy.hpp |
floatingpoint_test::iu_FloatingpointTest_x_iutest_x_NINF_Test<double>::Body() | IUTEST_TYPED_TEST(FloatingpointTest, NINF)
{
typedef typename TestFixture::ftype FloatType;
TypeParam a= - TestFixture::ONE;
TypeParam b=TestFixture::ZERO;
IUTEST_EXPECT_EQ(FloatType(a/b), FloatType::NINF());
} | pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp # imm = 0x220
movq %rdi, -0x8(%rbp)
movaps 0x4a2a(%rip), %xmm1 # 0x61050
movsd 0x1ddea(%rip), %xmm0 # 0x7a418
pxor %xmm1, %xmm0
movlpd %xmm0, -0x10(%rbp)
movsd 0x1ec51(%rip), %xmm0 # 0x7b290
movsd %xmm0, -0x18(%rbp)
callq 0x54ad0
testl %eax, %eax
jne 0x5... | /srz-zumix[P]iutest/test/floatingpoint_tests.cpp |
iutest::detail::TypeParamTestInstance<floatingpoint_test::iu_FloatingpointTest_x_iutest_x_NINF_Test, iutest::detail::VariadicTypeList<float, double, long double>>::EachTest<iutest::detail::VariadicTypeList<long double>, void>::AddTestSuite(char const*, unsigned long, char const*, int) | static TestSuite* AddTestSuite(const char* testsuite, size_t index, const char* file, int line)
{
#if !defined(IUTEST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS)
return UnitTest::instance().AddTestSuite<_MyTestSuite>(
#else
return UnitTest::instance().AddTestSuite(
#endif
#if IUTEST_HAS_TYP... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
callq 0x3d7a0
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x53610
callq 0x53710
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
movl -... | /srz-zumix[P]iutest/include/iutest_typed_tests.hpp |
iutest::legacy::SuiteApiResolver<floatingpoint_test::iu_FloatingpointTest_x_iutest_x_NINF_Test<long double>>::GetSetUpCaseOrSuite(char const*, int) | static SetUpTearDownTestSuiteFuncType GetSetUpCaseOrSuite(const char* file, int line)
{
SetUpTearDownTestSuiteFuncType testcase = GetNotDefaultOrNull(&T::SetUpTestCase, &Tester::SetUpTestCase);
SetUpTearDownTestSuiteFuncType testsuite = GetNotDefaultOrNull(&T::SetUpTestSuite, &Tester::SetUpTestSuite... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x7ea9(%rip), %rsi # 0x54ab0
movq %rsi, %rdi
callq 0x54a80
movq %rax, -0x18(%rbp)
leaq -0x7eac(%rip), %rsi # 0x54ac0
movq %rsi, %rdi
callq 0x54a80
movq %rax, -0x20(%rbp)
callq 0x54ad0
testl %e... | /srz-zumix[P]iutest/include/iutest_legacy.hpp |
iutest::legacy::SuiteApiResolver<floatingpoint_test::iu_FloatingpointTest_x_iutest_x_NINF_Test<long double>>::GetTearDownCaseOrSuite(char const*, int) | static SetUpTearDownTestSuiteFuncType GetTearDownCaseOrSuite(const char* file, int line)
{
SetUpTearDownTestSuiteFuncType testcase = GetNotDefaultOrNull(&T::TearDownTestCase, &Tester::TearDownTestCase);
SetUpTearDownTestSuiteFuncType testsuite = GetNotDefaultOrNull(&T::TearDownTestSuite, &Tester::Te... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x8009(%rip), %rsi # 0x54b00
movq %rsi, %rdi
callq 0x54a80
movq %rax, -0x18(%rbp)
leaq -0x800c(%rip), %rsi # 0x54b10
movq %rsi, %rdi
callq 0x54a80
movq %rax, -0x20(%rbp)
callq 0x54ad0
testl %e... | /srz-zumix[P]iutest/include/iutest_legacy.hpp |
floatingpoint_test::iu_FloatingpointTest_x_iutest_x_NINF_Test<long double>::Body() | IUTEST_TYPED_TEST(FloatingpointTest, NINF)
{
typedef typename TestFixture::ftype FloatType;
TypeParam a= - TestFixture::ONE;
TypeParam b=TestFixture::ZERO;
IUTEST_EXPECT_EQ(FloatType(a/b), FloatType::NINF());
} | pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp # imm = 0x260
movq %rdi, -0x8(%rbp)
fldt 0x1d60b(%rip) # 0x7a420
fchs
fstpt -0x20(%rbp)
fldt 0x1e480(%rip) # 0x7b2a0
fstpt -0x30(%rbp)
callq 0x54ad0
testl %eax, %eax
jne 0x5ce30
jmp 0x5ce2e
jmp 0x5ce30
fldt -0x20(%rbp)
fldt -0x30(%rbp)
fdivrp %... | /srz-zumix[P]iutest/test/floatingpoint_tests.cpp |
iutest::detail::TypeParamTestInstance<floatingpoint_test::iu_FloatingpointTest_x_iutest_x_IsNAN_Test, iutest::detail::VariadicTypeList<float, double, long double>>::EachTest<iutest::detail::VariadicTypeList<float, double, long double>, void>::EachTest(std::__cxx11::basic_string<char, std::char_traits<char>, std::alloca... | EachTest(const ::std::string& testsuite, const char* name, size_t index, const char* file, int line)
: m_mediator(AddTestSuite(testsuite, index, file, line))
, m_info(&m_mediator, name, &m_factory)
, m_next(testsuite, name, index+1, file, line)
{
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
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, -0x88(%rbp)
movq %rax, %rcx
movq %rcx, -0x98(%rbp)
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20... | /srz-zumix[P]iutest/include/iutest_typed_tests.hpp |
iutest::detail::TypeParamTestInstance<floatingpoint_test::iu_FloatingpointTest_x_iutest_x_IsNAN_Test, iutest::detail::VariadicTypeList<float, double, long double>>::EachTest<iutest::detail::VariadicTypeList<double, long double>, void>::EachTest(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<cha... | EachTest(const ::std::string& testsuite, const char* name, size_t index, const char* file, int line)
: m_mediator(AddTestSuite(testsuite, index, file, line))
, m_info(&m_mediator, name, &m_factory)
, m_next(testsuite, name, index+1, file, line)
{
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
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, -0x88(%rbp)
movq %rax, %rcx
movq %rcx, -0x98(%rbp)
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20... | /srz-zumix[P]iutest/include/iutest_typed_tests.hpp |
iutest::legacy::SuiteApiResolver<floatingpoint_test::iu_FloatingpointTest_x_iutest_x_IsNAN_Test<float>>::GetSetUpCaseOrSuite(char const*, int) | static SetUpTearDownTestSuiteFuncType GetSetUpCaseOrSuite(const char* file, int line)
{
SetUpTearDownTestSuiteFuncType testcase = GetNotDefaultOrNull(&T::SetUpTestCase, &Tester::SetUpTestCase);
SetUpTearDownTestSuiteFuncType testsuite = GetNotDefaultOrNull(&T::SetUpTestSuite, &Tester::SetUpTestSuite... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x8a89(%rip), %rsi # 0x54ab0
movq %rsi, %rdi
callq 0x54a80
movq %rax, -0x18(%rbp)
leaq -0x8a8c(%rip), %rsi # 0x54ac0
movq %rsi, %rdi
callq 0x54a80
movq %rax, -0x20(%rbp)
callq 0x54ad0
testl %e... | /srz-zumix[P]iutest/include/iutest_legacy.hpp |
iutest::legacy::SuiteApiResolver<floatingpoint_test::iu_FloatingpointTest_x_iutest_x_IsNAN_Test<float>>::GetTearDownCaseOrSuite(char const*, int) | static SetUpTearDownTestSuiteFuncType GetTearDownCaseOrSuite(const char* file, int line)
{
SetUpTearDownTestSuiteFuncType testcase = GetNotDefaultOrNull(&T::TearDownTestCase, &Tester::TearDownTestCase);
SetUpTearDownTestSuiteFuncType testsuite = GetNotDefaultOrNull(&T::TearDownTestSuite, &Tester::Te... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0x8be9(%rip), %rsi # 0x54b00
movq %rsi, %rdi
callq 0x54a80
movq %rax, -0x18(%rbp)
leaq -0x8bec(%rip), %rsi # 0x54b10
movq %rsi, %rdi
callq 0x54a80
movq %rax, -0x20(%rbp)
callq 0x54ad0
testl %e... | /srz-zumix[P]iutest/include/iutest_legacy.hpp |
floatingpoint_test::iu_FloatingpointTest_x_iutest_x_IsNAN_Test<float>::Body() | IUTEST_TYPED_TEST(FloatingpointTest, IsNAN)
{
IUTEST_ASSUME_TRUE(::std::numeric_limits<TypeParam>::is_iec559);
TypeParam a=TestFixture::ONE;
TypeParam b=TestFixture::ZERO;
const TypeParam nan=(a/b)*b;
IUTEST_EXPECT_NAN(nan);
} | pushq %rbp
movq %rsp, %rbp
subq $0x420, %rsp # imm = 0x420
movq %rdi, -0x8(%rbp)
callq 0x54ad0
testl %eax, %eax
jne 0x5d9fc
jmp 0x5d9fa
jmp 0x5d9fc
leaq -0x30(%rbp), %rdi
leaq 0x6b25(%rip), %rsi # 0x6452c
callq 0x5dd20
leaq -0x30(%rbp), %rdi
callq 0x553e0
testb $0x1, %al
jne 0x5da1b
jmp 0x5da20
jmp 0x5d... | /srz-zumix[P]iutest/test/floatingpoint_tests.cpp |
iutest::internal::GetBooleanAssertionFailureMessage[abi:cxx11](iutest::AssertionResult const&, char const*, char const*, char const*) | inline ::std::string GetBooleanAssertionFailureMessage(const AssertionResult& ar
, const char* expr, const char* actual, const char* expected)
{
::std::string str = "error: Value of: ";
str += expr;
str += "\n Actual: ";
str += actual;
if( !detail::IsEmpty(ar.message()) )
{
str += "... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movb $0x0, -0x29(%rbp)
leaq -0x2a(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x37720
movq -0x50(%rbp), ... | /srz-zumix[P]iutest/include/internal/../iutest_assertion.hpp |
iutest::AssertionResult iuutil::CmpHelperIsNan<float>(char const*, float const&) | inline ::iutest::AssertionResult IUTEST_ATTRIBUTE_UNUSED_ CmpHelperIsNan(const char* actual_str, const T& actual)
{
if( floationg_point_helper::CastToFloatingPoint(actual).is_nan() )
{
return ::iutest::AssertionSuccess();
}
return ::iutest::AssertionFailure() << "error: Value of: " << actual_str... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x1c(%rbp), %rdi
callq 0x5e010
leaq -0x1c(%rbp), %rdi
callq 0x5e050
testb $0x1, %al
jne 0x5defe
jmp 0x5df0c
movq -0x6... | /srz-zumix[P]iutest/include/util/iutest_util_assertion.hpp |
iutest::detail::iuStreamMessage& iutest::detail::iuStreamMessage::operator<<<float>(float const&) | iuStreamMessage& operator << (const T& value)
{
#if !defined(IUTEST_NO_ARGUMENT_DEPENDENT_LOOKUP)
m_stream << PrintToString(value);
#else
m_stream << value;
#endif
return *this;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
addq $0x10, %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x5e8b0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x373a0
jmp... | /srz-zumix[P]iutest/include/internal/../internal/iutest_message.hpp |
iutest::detail::TypeParamTestInstance<floatingpoint_test::iu_FloatingpointTest_x_iutest_x_IsNAN_Test, iutest::detail::VariadicTypeList<float, double, long double>>::EachTest<iutest::detail::VariadicTypeList<long double>, void>::EachTest(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> cons... | EachTest(const ::std::string& testsuite, const char* name, size_t index, const char* file, int line)
: m_mediator(AddTestSuite(testsuite, index, file, line))
, m_info(&m_mediator, name, &m_factory)
, m_next(testsuite, name, index+1, file, line)
{
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
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, -0x88(%rbp)
movq %rax, %rcx
movq %rcx, -0x98(%rbp)
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20... | /srz-zumix[P]iutest/include/iutest_typed_tests.hpp |
iutest::detail::TypeParamTestInstance<floatingpoint_test::iu_FloatingpointTest_x_iutest_x_IsNAN_Test, iutest::detail::VariadicTypeList<float, double, long double>>::EachTest<iutest::detail::VariadicTypeList<double, long double>, void>::AddTestSuite(char const*, unsigned long, char const*, int) | static TestSuite* AddTestSuite(const char* testsuite, size_t index, const char* file, int line)
{
#if !defined(IUTEST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS)
return UnitTest::instance().AddTestSuite<_MyTestSuite>(
#else
return UnitTest::instance().AddTestSuite(
#endif
#if IUTEST_HAS_TYP... | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
callq 0x3d7a0
movq %rax, -0x68(%rbp)
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x53610
callq 0x53710
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
movl -... | /srz-zumix[P]iutest/include/iutest_typed_tests.hpp |
iutest::legacy::SuiteApiResolver<floatingpoint_test::iu_FloatingpointTest_x_iutest_x_IsNAN_Test<double>>::GetTearDownCaseOrSuite(char const*, int) | static SetUpTearDownTestSuiteFuncType GetTearDownCaseOrSuite(const char* file, int line)
{
SetUpTearDownTestSuiteFuncType testcase = GetNotDefaultOrNull(&T::TearDownTestCase, &Tester::TearDownTestCase);
SetUpTearDownTestSuiteFuncType testsuite = GetNotDefaultOrNull(&T::TearDownTestSuite, &Tester::Te... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0xa4b9(%rip), %rsi # 0x54b00
movq %rsi, %rdi
callq 0x54a80
movq %rax, -0x18(%rbp)
leaq -0xa4bc(%rip), %rsi # 0x54b10
movq %rsi, %rdi
callq 0x54a80
movq %rax, -0x20(%rbp)
callq 0x54ad0
testl %e... | /srz-zumix[P]iutest/include/iutest_legacy.hpp |
iutest::AssertionResult iuutil::CmpHelperIsNan<double>(char const*, double const&) | inline ::iutest::AssertionResult IUTEST_ATTRIBUTE_UNUSED_ CmpHelperIsNan(const char* actual_str, const T& actual)
{
if( floationg_point_helper::CastToFloatingPoint(actual).is_nan() )
{
return ::iutest::AssertionSuccess();
}
return ::iutest::AssertionFailure() << "error: Value of: " << actual_str... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x5f710
leaq -0x20(%rbp), %rdi
callq 0x5f740
testb $0x1, %al
jne 0x5f62e
jmp 0x5f63c
movq -0x6... | /srz-zumix[P]iutest/include/util/iutest_util_assertion.hpp |
iutest::legacy::SuiteApiResolver<floatingpoint_test::iu_FloatingpointTest_x_iutest_x_IsNAN_Test<long double>>::GetSetUpCaseOrSuite(char const*, int) | static SetUpTearDownTestSuiteFuncType GetSetUpCaseOrSuite(const char* file, int line)
{
SetUpTearDownTestSuiteFuncType testcase = GetNotDefaultOrNull(&T::SetUpTestCase, &Tester::SetUpTestCase);
SetUpTearDownTestSuiteFuncType testsuite = GetNotDefaultOrNull(&T::SetUpTestSuite, &Tester::SetUpTestSuite... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0xb139(%rip), %rsi # 0x54ab0
movq %rsi, %rdi
callq 0x54a80
movq %rax, -0x18(%rbp)
leaq -0xb13c(%rip), %rsi # 0x54ac0
movq %rsi, %rdi
callq 0x54a80
movq %rax, -0x20(%rbp)
callq 0x54ad0
testl %e... | /srz-zumix[P]iutest/include/iutest_legacy.hpp |
iutest::legacy::SuiteApiResolver<floatingpoint_test::iu_FloatingpointTest_x_iutest_x_IsNAN_Test<long double>>::GetTearDownCaseOrSuite(char const*, int) | static SetUpTearDownTestSuiteFuncType GetTearDownCaseOrSuite(const char* file, int line)
{
SetUpTearDownTestSuiteFuncType testcase = GetNotDefaultOrNull(&T::TearDownTestCase, &Tester::TearDownTestCase);
SetUpTearDownTestSuiteFuncType testsuite = GetNotDefaultOrNull(&T::TearDownTestSuite, &Tester::Te... | pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp # imm = 0x210
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq -0xb299(%rip), %rsi # 0x54b00
movq %rsi, %rdi
callq 0x54a80
movq %rax, -0x18(%rbp)
leaq -0xb29c(%rip), %rsi # 0x54b10
movq %rsi, %rdi
callq 0x54a80
movq %rax, -0x20(%rbp)
callq 0x54ad0
testl %e... | /srz-zumix[P]iutest/include/iutest_legacy.hpp |
iutest::AssertionResult iuutil::CmpHelperIsNan<long double>(char const*, long double const&) | inline ::iutest::AssertionResult IUTEST_ATTRIBUTE_UNUSED_ CmpHelperIsNan(const char* actual_str, const T& actual)
{
if( floationg_point_helper::CastToFloatingPoint(actual).is_nan() )
{
return ::iutest::AssertionSuccess();
}
return ::iutest::AssertionFailure() << "error: Value of: " << actual_str... | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x1c(%rbp), %rdi
callq 0x604e0
leaq -0x1c(%rbp), %rdi
callq 0x5e050
testb $0x1, %al
jne 0x603fe
jmp 0x6040c
movq -0x6... | /srz-zumix[P]iutest/include/util/iutest_util_assertion.hpp |
iutest::detail::iuStreamMessage& iutest::detail::iuStreamMessage::operator<<<long double>(long double const&) | iuStreamMessage& operator << (const T& value)
{
#if !defined(IUTEST_NO_ARGUMENT_DEPENDENT_LOOKUP)
m_stream << PrintToString(value);
#else
m_stream << value;
#endif
return *this;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
addq $0x10, %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x60680
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x373a0
jmp... | /srz-zumix[P]iutest/include/internal/../internal/iutest_message.hpp |
rsa_sign_wrap | static int rsa_sign_wrap( void *ctx, mbedtls_md_type_t md_alg,
const unsigned char *hash, size_t hash_len,
unsigned char *sig, size_t *sig_len,
int (*f_rng)(void *, unsigned char *, size_t), void *p_rng )
{
mbedtls_rsa_context * rsa = (mbedtls_rsa_context *) ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
testl %esi, %esi
sete %al
shrq $0x20, %rcx
setne %cl
testb %cl, %al
je 0xd4a9
movl $0xffffc180, %eax # imm = 0xFFFFC180
addq $0x8, %rsp
jmp 0xd4e2
movq %r9, %r12
movq %r8, %r14
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %... | /project-everest[P]mbedtls/library/pk_wrap.c |
ecdsa_verify_wrap | static int ecdsa_verify_wrap( void *ctx, mbedtls_md_type_t md_alg,
const unsigned char *hash, size_t hash_len,
const unsigned char *sig, size_t sig_len )
{
int ret;
((void) md_alg);
ret = mbedtls_ecdsa_read_signature( (mbedtls_ecdsa_context *) ctx,
... | pushq %rax
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
movq %r9, %r8
callq 0x1d43b
cmpl $0xffffb400, %eax # imm = 0xFFFFB400
movl $0xffffc700, %ecx # imm = 0xFFFFC700
cmovel %ecx, %eax
popq %rcx
retq
| /project-everest[P]mbedtls/library/pk_wrap.c |
mbedtls_rsa_rsaes_oaep_decrypt | int mbedtls_rsa_rsaes_oaep_decrypt( mbedtls_rsa_context *ctx,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng,
int mode,
const unsigned char *label, size_t label_len,
si... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x488, %rsp # imm = 0x488
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
cmpl $0x1, %ecx
jne 0x12204
movl $0xffffbf80, %ebp # imm = 0xFFFFBF80
cmpl $0x1, 0x148(%r15)
jne 0x1234a
movq 0x8(%r15), %rcx
leaq -0x401(%rc... | /project-everest[P]mbedtls/library/rsa.c |
mbedtls_rsa_rsaes_pkcs1_v15_decrypt | int mbedtls_rsa_rsaes_pkcs1_v15_decrypt( mbedtls_rsa_context *ctx,
int (*f_rng)(void *, unsigned char *, size_t),
void *p_rng,
int mode, size_t *olen,
const unsigned char *input,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x408, %rsp # imm = 0x408
movq %r8, %rbx
movl %ecx, %ebp
cmpl $0x1, %ecx
jne 0x124aa
movl $0xffffbf80, %r14d # imm = 0xFFFFBF80
cmpl $0x0, 0x148(%rdi)
jne 0x125c3
movq 0x8(%rdi), %r15
leaq -0x401(%r15), %rax
movl $0xffffbf80, %r14d # imm = 0xFFFFBF8... | /project-everest[P]mbedtls/library/rsa.c |
mbedtls_ecp_point_read_binary | int mbedtls_ecp_point_read_binary( const mbedtls_ecp_group *grp, mbedtls_ecp_point *pt,
const unsigned char *buf, size_t ilen )
{
int ret;
size_t plen;
if( ilen < 1 )
return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
if( buf[0] == 0x00 )
{
if( ilen == 1 )
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl $0xffffb080, %eax # imm = 0xFFFFB080
testq %rcx, %rcx
je 0x1dab3
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %rbx
cmpb $0x0, (%rdx)
je 0x1da9a
addq $0x8, %rdi
callq 0x19ab0
movq %rax, %r15
movl $0xffffb180, %eax # imm = 0xFFFFB180
cmpb $0x4, (%r14)
... | /project-everest[P]mbedtls/library/ecp.c |
wabt::(anonymous namespace)::BinaryReaderIR::OnAtomicNotifyExpr(wabt::Opcode, unsigned int, unsigned long, unsigned long) | Result BinaryReaderIR::OnAtomicNotifyExpr(Opcode opcode,
Index memidx,
Address alignment_log2,
Address offset) {
return AppendExpr(std::make_unique<AtomicNotifyExpr>(
opcode, Var(memidx,... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %r8, (%rsp)
movq %rcx, %r15
movl %edx, %r12d
movl %esi, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r13
movups %xmm0, 0xc(%r13)
movaps %xmm0, (%r13)
movq 0x40(%rdi), %r14
movq %r14, %rdi
callq 0x15100
movq %rax, (%r13)... | /WebAssembly[P]wabt/src/binary-reader-ir.cc |
wabt::(anonymous namespace)::BinaryReaderIR::OnBlockExpr(wabt::Type) | Result BinaryReaderIR::OnBlockExpr(Type sig_type) {
auto expr = std::make_unique<BlockExpr>();
SetBlockDeclaration(&expr->block.decl, sig_type);
ExprList* expr_list = &expr->block.exprs;
CHECK_RESULT(AppendExpr(std::move(expr)));
return PushLabel(LabelType::Block, expr_list);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movl $0x118, %edi # imm = 0x118
callq 0x151f0
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x24(%rax)
movl $0x8, 0x38(%rax)
leaq 0x6763a(%rip), %rax ... | /WebAssembly[P]wabt/src/binary-reader-ir.cc |
wabt::(anonymous namespace)::BinaryReaderIR::OnBrExpr(unsigned int) | Result BinaryReaderIR::OnBrExpr(Index depth) {
return AppendExpr(std::make_unique<BrExpr>(Var(depth, GetLocation())));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movl %esi, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
movups %xmm0, 0xc(%r14)
movaps %xmm0, (%r14)
movq 0x40(%rdi), %r15
movq %r15, %rdi
callq 0x15100
movq %rax, (%r14)
movq %r15, 0x8(%r14)
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rax
movq %r... | /WebAssembly[P]wabt/src/binary-reader-ir.cc |
wabt::(anonymous namespace)::BinaryReaderIR::OnBrIfExpr(unsigned int) | Result BinaryReaderIR::OnBrIfExpr(Index depth) {
return AppendExpr(std::make_unique<BrIfExpr>(Var(depth, GetLocation())));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movl %esi, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
movups %xmm0, 0xc(%r14)
movaps %xmm0, (%r14)
movq 0x40(%rdi), %r15
movq %r15, %rdi
callq 0x15100
movq %rax, (%r14)
movq %r15, 0x8(%r14)
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rax
movq %r... | /WebAssembly[P]wabt/src/binary-reader-ir.cc |
wabt::(anonymous namespace)::BinaryReaderIR::OnCallExpr(unsigned int) | Result BinaryReaderIR::OnCallExpr(Index func_index) {
return AppendExpr(std::make_unique<CallExpr>(Var(func_index, GetLocation())));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movl %esi, %ebp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
movups %xmm0, 0xc(%r14)
movaps %xmm0, (%r14)
movq 0x40(%rdi), %r15
movq %r15, %rdi
callq 0x15100
movq %rax, (%r14)
movq %r15, 0x8(%r14)
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rax
movq %r... | /WebAssembly[P]wabt/src/binary-reader-ir.cc |
wabt::(anonymous namespace)::BinaryReaderIR::OnCatchAllExpr() | Result BinaryReaderIR::OnCatchAllExpr() {
return AppendCatch(Catch(GetLocation()));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %r14
movq 0x40(%rdi), %r15
movq %r15, %rdi
callq 0x15100
movq 0x8(%r14), %rcx
movq 0x10(%rcx), %rcx
leaq 0x28(%rsp), %rbx
movq %rax, -0x20(%rbx)
movq %r15, -0x18(%rbx)
movq %rcx, -0x10(%rbx)
xorl %r15d, %r15d
movq %r15, -0x8(%rbx)
movq %rbx, %rdi
c... | /WebAssembly[P]wabt/src/binary-reader-ir.cc |
wabt::(anonymous namespace)::BinaryReaderIR::OnCompareExpr(wabt::Opcode) | Result BinaryReaderIR::OnCompareExpr(Opcode opcode) {
return AppendExpr(std::make_unique<CompareExpr>(opcode));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x40, %edi
callq 0x151f0
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x24(%rax)
movl $0x10, 0x38(%rax)
leaq 0x66fc1(%rip), %rcx # 0x81a00
movq %rcx, (%rax)
movl %ebx, 0x3c(%rax)
leaq 0x8(%rs... | /WebAssembly[P]wabt/src/binary-reader-ir.cc |
wabt::(anonymous namespace)::BinaryReaderIR::OnConvertExpr(wabt::Opcode) | Result BinaryReaderIR::OnConvertExpr(Opcode opcode) {
return AppendExpr(std::make_unique<ConvertExpr>(opcode));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r14
movl $0x40, %edi
callq 0x151f0
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x24(%rax)
movl $0x12, 0x38(%rax)
leaq 0x66f9d(%rip), %rcx # 0x81a50
movq %rcx, (%rax)
movl %ebx, 0x3c(%rax)
leaq 0x8(%rs... | /WebAssembly[P]wabt/src/binary-reader-ir.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.