name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
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*>(*Bucket));
} | 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(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /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
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x10, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
shrq $0x20, %rax
orq -0x8(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
addq $0x1, %rax
retq
| /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<llvm::cl::ExpansionContext::expandResponseFiles(llvm::SmallVectorImpl<char const*>&)::ResponseFileRecord, false>>(llvm::SmallVectorTemplateBase<llvm::cl::ExpansionContext::expandResponseFiles(llvm::SmallVectorImpl<char const*>&)::ResponseFileRecord, false>*, llvm::cl::ExpansionContext::expandResponseFiles(llvm::SmallVectorImpl<char const*>&)::ResponseFileRecord const&, unsigned long) | 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::TakesParamByValue) {
if (LLVM_UNLIKELY(This->isReferenceToStorage(&Elt))) {
ReferencesStorage = true;
Index = &Elt - This->begin();
}
}
This->grow(NewSize);
return ReferencesStorage ? This->begin() + Index : &Elt;
} | 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(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x34bf1
movb $0x0, 0x2f(%rsp)
movq $-0x1, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x34c00
testb $0x1, %al
jne 0x34b7a
jmp 0x34bad
movb $0x1, 0x2f(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
callq 0x1ded0
movq %rax, %rcx
movq 0x10(%rsp), %rax
subq %rcx, %rax
movl $0x28, %ecx
cqto
idivq %rcx
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x34c60
testb $0x1, 0x2f(%rsp)
je 0x34bdd
movq 0x48(%rsp), %rdi
callq 0x1ded0
imulq $0x28, 0x20(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
jmp 0x34be7
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
| /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 $0x7, %rdi
movl $0x8, %esi
callq 0x479e0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw (%rax,%rax)
| /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
leaq 0x10(%rsp), %rdi
callq 0x3c840
movq (%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3c810
leaq 0x10(%rsp), %rdi
callq 0x10720
addq $0x58, %rsp
retq
nopl (%rax)
| /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_guard<std::mutex> Lock(BadAllocErrorHandlerMutex);
#endif
Handler = BadAllocErrorHandler;
HandlerData = BadAllocErrorHandlerUserData;
}
if (Handler) {
Handler(HandlerData, Reason, GenCrashDiag);
llvm_unreachable("bad alloc handler should not return");
}
#ifdef LLVM_ENABLE_EXCEPTIONS
// If exceptions are enabled, make OOM in malloc look like OOM in new.
throw std::bad_alloc();
#else
// Don't call the normal error handler. It may allocate memory. Directly write
// an OOM to stderr and abort.
const char *OOMMessage = "LLVM ERROR: out of memory\n";
const char *Newline = "\n";
(void)!::write(2, OOMMessage, strlen(OOMMessage));
(void)!::write(2, Reason, strlen(Reason));
(void)!::write(2, Newline, strlen(Newline));
abort();
#endif
} | 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, 0x38(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x45380
cmpq $0x0, 0x40(%rsp)
je 0x4572a
movq 0x40(%rsp), %rax
movq 0x38(%rsp), %rdi
movq 0x50(%rsp), %rsi
movb 0x4f(%rsp), %cl
andb $0x1, %cl
movzbl %cl, %edx
callq *%rax
leaq 0x4b09f(%rip), %rax # 0x907d0
movq %rax, 0x28(%rsp)
leaq 0x4acef(%rip), %rax # 0x9042c
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x7170
movq 0x8(%rsp), %rsi
movq %rax, %rdx
movl $0x2, %edi
callq 0x7100
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rdi
callq 0x7170
movq 0x10(%rsp), %rsi
movq %rax, %rdx
movl $0x2, %edi
callq 0x7100
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x7170
movq 0x18(%rsp), %rsi
movq %rax, %rdx
movl $0x2, %edi
callq 0x7100
callq 0x7220
nopl (%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)
addq $0x80, %rdi
callq 0x4c380
movq 0x8(%rsp), %rdi
movq %rax, 0x28(%rsp)
leaq 0x28(%rsp), %rsi
callq 0x4bd30
xorb $-0x1, %al
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x4bb98
jmp 0x4bbe7
movq 0x10(%rsp), %rdi
movq %rdi, %rax
addq $0xa0, %rax
movq %rax, (%rsp)
addq $0x80, %rdi
callq 0x4c380
movq 0x10(%rsp), %rdi
movq %rax, 0x20(%rsp)
addq $0x80, %rdi
callq 0x4c370
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
movq %rax, %rcx
movq 0x38(%rsp), %r8
leaq 0x20(%rsp), %rdx
callq 0x4c390
addq $0x48, %rsp
retq
nopl (%rax)
| /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
addq $0x10, %rax
movq %rax, (%rsi)
movq %rsi, %rdi
addq $0x98, %rdi
callq 0x2d7b0
movq (%rsp), %rdi
addq $0xa0, %rdi
leaq 0xf(%rsp), %rsi
callq 0x3e270
movq (%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
callq 0x4e1a0
movq (%rsp), %rdi
callq 0x3e370
addq $0x38, %rsp
retq
| /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 = ~FullHashValue;
unsigned BucketNo = FullHashValue & (NumBuckets - 1);
unsigned *HashTable = getHashTable(TheTable, NumBuckets);
unsigned ProbeAmt = 1;
int FirstTombstone = -1;
while (true) {
StringMapEntryBase *BucketItem = TheTable[BucketNo];
// If we found an empty bucket, this key isn't in the table yet, return it.
if (LLVM_LIKELY(!BucketItem)) {
// If we found a tombstone, we want to reuse the tombstone instead of an
// empty bucket. This reduces probing.
if (FirstTombstone != -1) {
HashTable[FirstTombstone] = FullHashValue;
return FirstTombstone;
}
HashTable[BucketNo] = FullHashValue;
return BucketNo;
}
if (BucketItem == getTombstoneVal()) {
// Skip over tombstones. However, remember the first one we see.
if (FirstTombstone == -1)
FirstTombstone = BucketNo;
} else if (LLVM_LIKELY(HashTable[BucketNo] == FullHashValue)) {
// If the full hash value matches, check deeply for a match. The common
// case here is that we are only looking at the buckets (for item info
// being non-null and for the full hash value) not at the items. This
// is important for cache locality.
// Do the comparison like this because Name isn't necessarily
// null-terminated!
char *ItemStr = (char *)BucketItem + ItemSize;
if (Name == StringRef(ItemStr, BucketItem->getKeyLength())) {
// We found a match!
return BucketNo;
}
}
// Okay, we didn't find the item. Probe to the next bucket.
BucketNo = (BucketNo + ProbeAmt) & (NumBuckets - 1);
// Use quadratic probing, it has fewer clumping artifacts than linear
// probing and has good cache behavior in the common case.
++ProbeAmt;
}
} | 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 $-0x1, %eax
movl %eax, 0x64(%rsp)
movq 0x18(%rsp), %rax
movl 0x64(%rsp), %ecx
movl 0x8(%rax), %edx
subl $0x1, %edx
andl %edx, %ecx
movl %ecx, 0x60(%rsp)
movq (%rax), %rdi
movl 0x8(%rax), %esi
callq 0x4e7d0
movq %rax, 0x58(%rsp)
movl $0x1, 0x54(%rsp)
movl $0xffffffff, 0x50(%rsp) # imm = 0xFFFFFFFF
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl 0x60(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x48(%rsp)
cmpq $0x0, 0x48(%rsp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x4e68a
jmp 0x4e6d2
cmpl $-0x1, 0x50(%rsp)
je 0x4e6b2
movl 0x64(%rsp), %edx
movq 0x58(%rsp), %rax
movslq 0x50(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x50(%rsp), %eax
movl %eax, 0x84(%rsp)
jmp 0x4e7bc
movl 0x64(%rsp), %edx
movq 0x58(%rsp), %rax
movl 0x60(%rsp), %ecx
movl %edx, (%rax,%rcx,4)
movl 0x60(%rsp), %eax
movl %eax, 0x84(%rsp)
jmp 0x4e7bc
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x24910
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jne 0x4e702
cmpl $-0x1, 0x50(%rsp)
jne 0x4e6fd
movl 0x60(%rsp), %eax
movl %eax, 0x50(%rsp)
jmp 0x4e793
movq 0x58(%rsp), %rax
movl 0x60(%rsp), %ecx
movl (%rax,%rcx,4), %eax
cmpl 0x64(%rsp), %eax
jne 0x4e791
movq 0x18(%rsp), %rcx
movq 0x48(%rsp), %rax
movl 0x14(%rcx), %ecx
addq %rcx, %rax
movq %rax, 0x40(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
callq 0x25960
movq 0x8(%rsp), %rsi
movq %rax, %rdx
leaq 0x20(%rsp), %rdi
callq 0x123d0
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rcx
callq 0x114b0
testb $0x1, %al
jne 0x4e782
jmp 0x4e78f
movl 0x60(%rsp), %eax
movl %eax, 0x84(%rsp)
jmp 0x4e7bc
jmp 0x4e791
jmp 0x4e793
movq 0x18(%rsp), %rcx
movl 0x60(%rsp), %eax
addl 0x54(%rsp), %eax
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
andl %ecx, %eax
movl %eax, 0x60(%rsp)
movl 0x54(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x4e664
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
nopl (%rax,%rax)
| /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::DenseSetPair<llvm::StringRef>>, llvm::StringRef, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::StringRef, void>, llvm::detail::DenseSetPair<llvm::StringRef>>::try_emplace<llvm::detail::DenseSetEmpty&>(llvm::StringRef const&, llvm::detail::DenseSetEmpty&) | 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()
: getBucketsEnd(),
*this, true),
false); // Already in map.
// Otherwise, insert the new element.
TheBucket = InsertIntoBucket(TheBucket, Key, std::forward<Ts>(Args)...);
return std::make_pair(makeIterator(TheBucket,
shouldReverseIterate<KeyT>()
? getBuckets()
: getBucketsEnd(),
*this, true),
true);
} | 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 0x4fa10
testb $0x1, %al
jne 0x4f76a
jmp 0x4f77b
movq 0x30(%rsp), %rdi
callq 0x4fa20
movq %rax, 0x10(%rsp)
jmp 0x4f78a
movq 0x30(%rsp), %rdi
callq 0x4fa30
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rcx
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movl $0x1, %r8d
movq %rcx, %rdi
callq 0x4f930
movq 0x20(%rsp), %rdi
movq %rax, 0x58(%rsp)
movq %rdx, 0x60(%rsp)
movb $0x0, 0x57(%rsp)
leaq 0x58(%rsp), %rsi
leaq 0x57(%rsp), %rdx
callq 0x4f900
jmp 0x4f85f
movq 0x30(%rsp), %rdi
movq 0x68(%rsp), %rsi
movq 0x78(%rsp), %rdx
movq 0x70(%rsp), %rcx
callq 0x4fa70
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x4fa10
testb $0x1, %al
jne 0x4f802
jmp 0x4f812
movq 0x30(%rsp), %rdi
callq 0x4fa20
movq %rax, (%rsp)
jmp 0x4f820
movq 0x30(%rsp), %rdi
callq 0x4fa30
movq %rax, (%rsp)
movq 0x30(%rsp), %rcx
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
movl $0x1, %r8d
movq %rcx, %rdi
callq 0x4f930
movq 0x20(%rsp), %rdi
movq %rax, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movb $0x1, 0x3f(%rsp)
leaq 0x40(%rsp), %rsi
leaq 0x3f(%rsp), %rdx
callq 0x4f900
movq 0x28(%rsp), %rax
addq $0x88, %rsp
retq
nopl (%rax)
| /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 $0x4, %rdi
movl $0x8, %esi
callq 0x479e0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw (%rax,%rax)
| /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>, bool, unsigned int)::'lambda'(char const&), bool, unsigned int) | 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 computing the Levenshtein
// distance, which is described here:
//
// http://en.wikipedia.org/wiki/Levenshtein_distance
//
// Although the algorithm is typically described using an m x n
// array, only one row plus one element are used at a time, so this
// implementation just keeps one vector for the row. To update one entry,
// only the entries to the left, top, and top-left are needed. The left
// entry is in Row[x-1], the top entry is what's in Row[x] from the last
// iteration, and the top-left entry is stored in Previous.
typename ArrayRef<T>::size_type m = FromArray.size();
typename ArrayRef<T>::size_type n = ToArray.size();
if (MaxEditDistance) {
// If the difference in size between the 2 arrays is larger than the max
// distance allowed, we can bail out as we will always need at least
// MaxEditDistance insertions or removals.
typename ArrayRef<T>::size_type AbsDiff = m > n ? m - n : n - m;
if (AbsDiff > MaxEditDistance)
return MaxEditDistance + 1;
}
SmallVector<unsigned, 64> Row(n + 1);
for (unsigned i = 1; i < Row.size(); ++i)
Row[i] = i;
for (typename ArrayRef<T>::size_type y = 1; y <= m; ++y) {
Row[0] = y;
unsigned BestThisRow = Row[0];
unsigned Previous = y - 1;
const auto &CurItem = Map(FromArray[y - 1]);
for (typename ArrayRef<T>::size_type x = 1; x <= n; ++x) {
int OldRow = Row[x];
if (AllowReplacements) {
Row[x] = std::min(Previous + (CurItem == Map(ToArray[x - 1]) ? 0u : 1u),
std::min(Row[x - 1], Row[x]) + 1);
}
else {
if (CurItem == Map(ToArray[x - 1]))
Row[x] = Previous;
else Row[x] = std::min(Row[x-1], Row[x]) + 1;
}
Previous = OldRow;
BestThisRow = std::min(BestThisRow, Row[x]);
}
if (MaxEditDistance && BestThisRow > MaxEditDistance)
return MaxEditDistance + 1;
}
unsigned Result = Row[n];
return Result;
} | 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, 0x1a8(%rsp)
cmpl $0x0, 0x1b8(%rsp)
je 0x52096
movq 0x1b0(%rsp), %rax
cmpq 0x1a8(%rsp), %rax
jbe 0x52048
movq 0x1b0(%rsp), %rax
subq 0x1a8(%rsp), %rax
movq %rax, 0x48(%rsp)
jmp 0x5205d
movq 0x1a8(%rsp), %rax
subq 0x1b0(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x1a0(%rsp)
movq 0x1a0(%rsp), %rax
movl 0x1b8(%rsp), %ecx
cmpq %rcx, %rax
jbe 0x52094
movl 0x1b8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1e4(%rsp)
jmp 0x5244c
jmp 0x52096
movq 0x1a8(%rsp), %rsi
addq $0x1, %rsi
leaq 0x90(%rsp), %rdi
callq 0x52460
movl $0x1, 0x8c(%rsp)
movl 0x8c(%rsp), %eax
movq %rax, 0x40(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x4d300
movq %rax, %rcx
movq 0x40(%rsp), %rax
cmpq %rcx, %rax
jae 0x5211a
movl 0x8c(%rsp), %eax
movl %eax, 0x3c(%rsp)
movl 0x8c(%rsp), %eax
movl %eax, %esi
leaq 0x90(%rsp), %rdi
callq 0x524a0
movl 0x3c(%rsp), %ecx
movl %ecx, (%rax)
movl 0x8c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8c(%rsp)
jmp 0x520ba
movq $0x1, 0x80(%rsp)
movq 0x80(%rsp), %rax
cmpq 0x1b0(%rsp), %rax
ja 0x52411
movq 0x80(%rsp), %rax
movl %eax, 0x38(%rsp)
leaq 0x90(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x524a0
movl 0x38(%rsp), %ecx
movl %ecx, (%rax)
leaq 0x90(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x524a0
movl (%rax), %eax
movl %eax, 0x7c(%rsp)
movq 0x80(%rsp), %rax
subq $0x1, %rax
movl %eax, 0x78(%rsp)
movq 0x80(%rsp), %rsi
subq $0x1, %rsi
leaq 0x1d0(%rsp), %rdi
callq 0x26af0
movq %rax, %rsi
leaq 0x1bf(%rsp), %rdi
callq 0x524d0
movq %rax, 0x70(%rsp)
movq $0x1, 0x68(%rsp)
movq 0x68(%rsp), %rax
cmpq 0x1a8(%rsp), %rax
ja 0x523c4
movq 0x68(%rsp), %rsi
leaq 0x90(%rsp), %rdi
callq 0x524a0
movl (%rax), %eax
movl %eax, 0x64(%rsp)
testb $0x1, 0x1be(%rsp)
je 0x522c5
movl 0x78(%rsp), %eax
movl %eax, 0x24(%rsp)
movq 0x70(%rsp), %rax
movsbl (%rax), %eax
movl %eax, 0x20(%rsp)
movq 0x68(%rsp), %rsi
subq $0x1, %rsi
leaq 0x1c0(%rsp), %rdi
callq 0x26af0
movq %rax, %rsi
leaq 0x1bf(%rsp), %rdi
callq 0x524d0
movl 0x20(%rsp), %esi
movq %rax, %rcx
movl 0x24(%rsp), %eax
movsbl (%rcx), %edi
movl $0x1, %ecx
xorl %edx, %edx
cmpl %edi, %esi
cmovel %edx, %ecx
addl %ecx, %eax
movl %eax, 0x60(%rsp)
movq 0x68(%rsp), %rsi
subq $0x1, %rsi
leaq 0x90(%rsp), %rdi
callq 0x524a0
movq %rax, 0x28(%rsp)
movq 0x68(%rsp), %rsi
leaq 0x90(%rsp), %rdi
callq 0x524a0
movq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x4ce20
movl (%rax), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x5c(%rsp), %rsi
callq 0x4ce20
movl (%rax), %eax
movl %eax, 0x34(%rsp)
movq 0x68(%rsp), %rsi
leaq 0x90(%rsp), %rdi
callq 0x524a0
movl 0x34(%rsp), %ecx
movl %ecx, (%rax)
jmp 0x52384
movq 0x70(%rsp), %rax
movsbl (%rax), %eax
movl %eax, 0x1c(%rsp)
movq 0x68(%rsp), %rsi
subq $0x1, %rsi
leaq 0x1c0(%rsp), %rdi
callq 0x26af0
movq %rax, %rsi
leaq 0x1bf(%rsp), %rdi
callq 0x524d0
movq %rax, %rcx
movl 0x1c(%rsp), %eax
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x52327
movl 0x78(%rsp), %eax
movl %eax, 0x18(%rsp)
movq 0x68(%rsp), %rsi
leaq 0x90(%rsp), %rdi
callq 0x524a0
movl 0x18(%rsp), %ecx
movl %ecx, (%rax)
jmp 0x52382
movq 0x68(%rsp), %rsi
subq $0x1, %rsi
leaq 0x90(%rsp), %rdi
callq 0x524a0
movq %rax, 0x8(%rsp)
movq 0x68(%rsp), %rsi
leaq 0x90(%rsp), %rdi
callq 0x524a0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x4ce20
movl (%rax), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
movq 0x68(%rsp), %rsi
leaq 0x90(%rsp), %rdi
callq 0x524a0
movl 0x14(%rsp), %ecx
movl %ecx, (%rax)
jmp 0x52384
movl 0x64(%rsp), %eax
movl %eax, 0x78(%rsp)
movq 0x68(%rsp), %rsi
leaq 0x90(%rsp), %rdi
callq 0x524a0
movq %rax, %rsi
leaq 0x7c(%rsp), %rdi
callq 0x4ce20
movl (%rax), %eax
movl %eax, 0x7c(%rsp)
movq 0x68(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x68(%rsp)
jmp 0x521bd
cmpl $0x0, 0x1b8(%rsp)
je 0x523f6
movl 0x7c(%rsp), %eax
cmpl 0x1b8(%rsp), %eax
jbe 0x523f6
movl 0x1b8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1e4(%rsp)
movl $0x1, 0x58(%rsp)
jmp 0x5243f
jmp 0x523f8
movq 0x80(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x80(%rsp)
jmp 0x52126
movq 0x1a8(%rsp), %rsi
leaq 0x90(%rsp), %rdi
callq 0x524a0
movl (%rax), %eax
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
movl %eax, 0x1e4(%rsp)
movl $0x1, 0x58(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x524e0
movl 0x1e4(%rsp), %eax
addq $0x1e8, %rsp # imm = 0x1E8
retq
nopl (%rax,%rax)
| /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, h4);
h5 = h2 + h6;
h6 = h1 + fetch64(s + 16);
mix_32_bytes(s + 32, h5, h6);
std::swap(h2, h0);
} | 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), %rcx
movabsq $-0x4b6d499041670d8d, %rdx # imm = 0xB492B66FBE98F273
imulq %rdx, %rax
movq %rax, (%rcx)
movq 0x8(%rcx), %rax
addq 0x20(%rcx), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
addq $0x30, %rdi
callq 0x53bd0
movq 0x8(%rsp), %rdi
addq %rax, %rdi
movl $0x2a, %esi
callq 0x53c40
movq %rax, %rcx
movq 0x20(%rsp), %rax
movabsq $-0x4b6d499041670d8d, %rdx # imm = 0xB492B66FBE98F273
imulq %rdx, %rcx
movq %rcx, 0x8(%rax)
movq 0x30(%rax), %rcx
xorq (%rax), %rcx
movq %rcx, (%rax)
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
addq $0x28, %rdi
callq 0x53bd0
movq 0x10(%rsp), %rcx
movq %rax, %rdx
movq 0x20(%rsp), %rax
addq %rdx, %rcx
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rdi
addq 0x28(%rax), %rdi
movl $0x21, %esi
callq 0x53c40
movq 0x20(%rsp), %rdx
movabsq $-0x4b6d499041670d8d, %rcx # imm = 0xB492B66FBE98F273
imulq %rcx, %rax
movq %rax, 0x10(%rdx)
movabsq $-0x4b6d499041670d8d, %rax # imm = 0xB492B66FBE98F273
imulq 0x20(%rdx), %rax
movq %rax, 0x18(%rdx)
movq (%rdx), %rax
addq 0x28(%rdx), %rax
movq %rax, 0x20(%rdx)
movq 0x28(%rsp), %rdi
movq %rdx, %rsi
addq $0x18, %rsi
addq $0x20, %rdx
callq 0x53d80
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rcx
addq 0x30(%rax), %rcx
movq %rcx, 0x28(%rax)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
addq $0x10, %rdi
callq 0x53bd0
movq 0x20(%rsp), %rdx
movq %rax, %rcx
movq 0x18(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x30(%rdx)
movq 0x28(%rsp), %rdi
addq $0x20, %rdi
movq %rdx, %rsi
addq $0x28, %rsi
addq $0x30, %rdx
callq 0x53d80
movq 0x20(%rsp), %rsi
movq %rsi, %rdi
addq $0x10, %rdi
callq 0x53e70
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /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, 7);
a += fetch64(s + 16);
uint64_t vf = a + z;
uint64_t vs = b + llvm::rotr<uint64_t>(a, 31) + c;
a = fetch64(s + 16) + fetch64(s + len - 32);
z = fetch64(s + len - 8);
b = llvm::rotr<uint64_t>(a + z, 52);
c = llvm::rotr<uint64_t>(a, 37);
a += fetch64(s + len - 24);
c += llvm::rotr<uint64_t>(a, 7);
a += fetch64(s + len - 16);
uint64_t wf = a + z;
uint64_t ws = b + llvm::rotr<uint64_t>(a, 31) + c;
uint64_t r = shift_mix((vf + ws) * k2 + (wf + vs) * k0);
return shift_mix((seed ^ (r * k0)) + vs) * k2;
} | 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
callq 0x53bd0
movq (%rsp), %rcx
movq %rax, %rdx
movq 0x8(%rsp), %rax
addq %rdx, %rcx
movabsq $-0x3c5a37a36834ced9, %rdx # imm = 0xC3A5C85C97CB3127
imulq %rdx, %rcx
addq %rcx, %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rdi
addq 0x68(%rsp), %rdi
movl $0x34, %esi
callq 0x53c40
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rdi
movl $0x25, %esi
callq 0x53c40
movq %rax, 0x50(%rsp)
movq 0x80(%rsp), %rdi
addq $0x8, %rdi
callq 0x53bd0
addq 0x60(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rdi
movl $0x7, %esi
callq 0x53c40
addq 0x50(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x80(%rsp), %rdi
addq $0x10, %rdi
callq 0x53bd0
addq 0x60(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq 0x68(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x60(%rsp), %rdi
movl $0x1f, %esi
callq 0x53c40
movq %rax, %rcx
movq 0x10(%rsp), %rax
addq %rcx, %rax
addq 0x50(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x80(%rsp), %rdi
addq $0x10, %rdi
callq 0x53bd0
movq %rax, 0x18(%rsp)
movq 0x80(%rsp), %rdi
addq 0x78(%rsp), %rdi
addq $-0x20, %rdi
callq 0x53bd0
movq %rax, %rcx
movq 0x18(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x60(%rsp)
movq 0x80(%rsp), %rdi
addq 0x78(%rsp), %rdi
addq $-0x8, %rdi
callq 0x53bd0
movq %rax, 0x68(%rsp)
movq 0x60(%rsp), %rdi
addq 0x68(%rsp), %rdi
movl $0x34, %esi
callq 0x53c40
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rdi
movl $0x25, %esi
callq 0x53c40
movq %rax, 0x50(%rsp)
movq 0x80(%rsp), %rdi
addq 0x78(%rsp), %rdi
addq $-0x18, %rdi
callq 0x53bd0
addq 0x60(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rdi
movl $0x7, %esi
callq 0x53c40
addq 0x50(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x80(%rsp), %rdi
addq 0x78(%rsp), %rdi
addq $-0x10, %rdi
callq 0x53bd0
addq 0x60(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq 0x68(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x60(%rsp), %rdi
movl $0x1f, %esi
callq 0x53c40
movq %rax, %rcx
movq 0x20(%rsp), %rax
addq %rcx, %rax
addq 0x50(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rdi
addq 0x30(%rsp), %rdi
movabsq $-0x651e95c4d06fbfb1, %rax # imm = 0x9AE16A3B2F90404F
imulq %rax, %rdi
movq 0x38(%rsp), %rax
addq 0x40(%rsp), %rax
movabsq $-0x3c5a37a36834ced9, %rcx # imm = 0xC3A5C85C97CB3127
imulq %rcx, %rax
addq %rax, %rdi
callq 0x53d60
movq %rax, 0x28(%rsp)
movq 0x70(%rsp), %rdi
movabsq $-0x3c5a37a36834ced9, %rax # imm = 0xC3A5C85C97CB3127
imulq 0x28(%rsp), %rax
xorq %rax, %rdi
addq 0x40(%rsp), %rdi
callq 0x53d60
movabsq $-0x651e95c4d06fbfb1, %rcx # imm = 0x9AE16A3B2F90404F
imulq %rcx, %rax
addq $0x88, %rsp
retq
nopl (%rax)
| /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
xorq -0x20(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rax
xorq -0x20(%rsp), %rax
movabsq $-0x622015f714c7d297, %rcx # imm = 0x9DDFEA08EB382D69
imulq %rcx, %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
shrq $0x2f, %rax
xorq -0x28(%rsp), %rax
movq %rax, -0x28(%rsp)
movabsq $-0x622015f714c7d297, %rax # imm = 0x9DDFEA08EB382D69
imulq -0x28(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
nop
| /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->setPosition(pos);
Callback(Val);
return false;
} | 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(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq 0x20(%rsp), %r8
movq 0x28(%rsp), %r9
leaq 0x40(%rsp), %rax
movq %rax, (%rsp)
callq 0x19240
testb $0x1, %al
jne 0x547b3
jmp 0x547c5
movb $0x1, 0x97(%rsp)
movl $0x1, 0x1c(%rsp)
jmp 0x54811
movq 0x10(%rsp), %rdi
addq $0x80, %rdi
leaq 0x40(%rsp), %rsi
xorl %edx, %edx
callq 0x54fc0
movq 0x10(%rsp), %rdi
movl 0x64(%rsp), %esi
callq 0x11410
movq 0x10(%rsp), %rdi
addq $0xc0, %rdi
leaq 0x40(%rsp), %rsi
callq 0x192f0
movb $0x0, 0x97(%rsp)
movl $0x1, 0x1c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x7290
movb 0x97(%rsp), %al
andb $0x1, %al
addq $0x98, %rsp
retq
nopl (%rax)
| /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 combine because that formation can have varying
// argument types.
size_t partial_store_size = buffer_end - buffer_ptr;
memcpy(buffer_ptr, &data, partial_store_size);
// If the store fails, our buffer is full and ready to hash. We have to
// either initialize the hash state (on the first full buffer) or mix
// this buffer into the existing hash state. Length tracks the *hashed*
// length, not the buffered length.
if (length == 0) {
state = state.create(buffer, seed);
length = 64;
} else {
// Mix this chunk into the current state and bump length up by 64.
state.mix(buffer);
length += 64;
}
// Reset the buffer_ptr to the head of the buffer for the next chunk of
// data.
buffer_ptr = buffer;
// Try again to store into the buffer -- this cannot fail as we only
// store types smaller than the buffer.
if (!store_and_advance(buffer_ptr, buffer_end, data,
partial_store_size))
llvm_unreachable("buffer smaller than stored type");
}
return buffer_ptr;
} | 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(%rsp), %rax
movq 0x60(%rsp), %rcx
subq %rcx, %rax
movq %rax, 0x48(%rsp)
movq 0x60(%rsp), %rdi
movq 0x48(%rsp), %rdx
leaq 0x50(%rsp), %rsi
callq 0x7360
movq 0x68(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x5b571
movq 0x8(%rsp), %rsi
movq 0x78(%rsi), %rdx
leaq 0x10(%rsp), %rdi
callq 0x53240
movq 0x8(%rsp), %rdi
addq $0x40, %rdi
leaq 0x10(%rsp), %rsi
movl $0x38, %edx
callq 0x7360
movq 0x68(%rsp), %rax
movq $0x40, (%rax)
jmp 0x5b591
movq 0x8(%rsp), %rsi
movq %rsi, %rdi
addq $0x40, %rdi
callq 0x53310
movq 0x68(%rsp), %rax
movq (%rax), %rcx
addq $0x40, %rcx
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x58(%rsp), %rsi
movq 0x48(%rsp), %rcx
leaq 0x60(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0x5b5d0
testb $0x1, %al
jne 0x5b5b8
jmp 0x5b5ba
movq 0x60(%rsp), %rax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| /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 least one byte");
// Make sure the current buffer is free of content (we can't flush here; the
// child buffer management logic will be in write_impl).
assert(GetNumBytesInBuffer() == 0 && "Current buffer is non-empty!");
if (BufferMode == BufferKind::InternalBuffer)
delete [] OutBufStart;
OutBufStart = BufferStart;
OutBufEnd = OutBufStart+Size;
OutBufCur = OutBufStart;
BufferMode = Mode;
assert(OutBufStart <= OutBufEnd && "Invalid size!");
} | 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
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rcx
addq 0x20(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x10(%rax), %rcx
movq %rcx, 0x20(%rax)
movl 0x1c(%rsp), %ecx
movl %ecx, 0x2c(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
| /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::read64le(secret + 48)) - seed;
input_lo ^= endian::read64le(input);
input_hi ^= endian::read64le(input + len - 8);
uint64_t acc = uint64_t(len) + byteswap(input_lo) + input_hi +
XXH3_mul128_fold64(input_lo, input_hi);
return XXH3_avalanche(acc);
} | 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(%rsp)
movq 0x40(%rsp), %rdi
addq $0x28, %rdi
callq 0x5fcb0
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
addq $0x30, %rdi
callq 0x5fcb0
movq %rax, %rcx
movq 0x8(%rsp), %rax
xorq %rcx, %rax
subq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x50(%rsp), %rdi
callq 0x5fcb0
xorq 0x30(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x50(%rsp), %rdi
addq 0x48(%rsp), %rdi
addq $-0x8, %rdi
callq 0x5fcb0
xorq 0x28(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0x60a00
movq %rax, %rcx
movq 0x10(%rsp), %rax
addq %rcx, %rax
addq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x60e00
movq %rax, %rcx
movq 0x18(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x60e30
addq $0x58, %rsp
retq
nopw (%rax,%rax)
| /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 =
(endian::read64le(secret + 8) ^ endian::read64le(secret + 16)) - seed;
const uint64_t input64 = (uint64_t)input2 | ((uint64_t)input1 << 32);
acc ^= input64;
// XXH3_rrmxmx(acc, len)
acc ^= rotl64(acc, 49) ^ rotl64(acc, 24);
acc *= PRIME_MX2;
acc ^= (acc >> 35) + (uint64_t)len;
acc *= PRIME_MX2;
return acc ^ (acc >> 28);
} | 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 0x38(%rsp), %rdi
addq $-0x4, %rdi
callq 0x5fcf0
movl %eax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
addq $0x8, %rdi
callq 0x5fcb0
movq %rax, (%rsp)
movq 0x30(%rsp), %rdi
addq $0x10, %rdi
callq 0x5fcb0
movq %rax, %rcx
movq (%rsp), %rax
xorq %rcx, %rax
subq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x20(%rsp), %eax
movl 0x24(%rsp), %ecx
shlq $0x20, %rcx
orq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
xorq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl $0x31, %esi
callq 0x5fcc0
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movl $0x18, %esi
callq 0x5fcc0
movq %rax, %rcx
movq 0x8(%rsp), %rax
xorq %rcx, %rax
xorq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movabsq $-0x604de39ae16720db, %rax # imm = 0x9FB21C651E98DF25
imulq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
shrq $0x23, %rax
addq 0x38(%rsp), %rax
xorq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movabsq $-0x604de39ae16720db, %rax # imm = 0x9FB21C651E98DF25
imulq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x18(%rsp), %rcx
shrq $0x1c, %rcx
xorq %rcx, %rax
addq $0x48, %rsp
retq
| /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 >> 64);
#else
/* First calculate all of the cross products. */
const uint64_t lo_lo = (lhs & 0xFFFFFFFF) * (rhs & 0xFFFFFFFF);
const uint64_t hi_lo = (lhs >> 32) * (rhs & 0xFFFFFFFF);
const uint64_t lo_hi = (lhs & 0xFFFFFFFF) * (rhs >> 32);
const uint64_t hi_hi = (lhs >> 32) * (rhs >> 32);
/* Now add the products together. These will never overflow. */
const uint64_t cross = (lo_lo >> 32) + (hi_lo & 0xFFFFFFFF) + lo_hi;
const uint64_t upper = (hi_lo >> 32) + (cross >> 32) + hi_hi;
const uint64_t lower = (cross << 32) | (lo_lo & 0xFFFFFFFF);
return upper ^ lower;
#endif
} | 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_separator(str[2], style)) {
return str.find_first_of(separators(style), 2);
}
// case "/"
if (str.size() > 0 && is_separator(str[0], style))
return 0;
return StringRef::npos;
} | 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
leaq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x1b290
movl 0x1c(%rsp), %esi
movsbl %al, %edi
callq 0x61750
testb $0x1, %al
jne 0x61b79
jmp 0x61b87
movq $0x2, 0x30(%rsp)
jmp 0x61c8a
jmp 0x61b89
leaq 0x20(%rsp), %rdi
callq 0x11670
cmpq $0x3, %rax
jbe 0x61c46
leaq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1b290
movl 0x1c(%rsp), %esi
movsbl %al, %edi
callq 0x61750
testb $0x1, %al
jne 0x61bc0
jmp 0x61c46
leaq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1b290
movsbl %al, %eax
movl %eax, 0x4(%rsp)
leaq 0x20(%rsp), %rdi
movl $0x1, %esi
callq 0x1b290
movb %al, %cl
movl 0x4(%rsp), %eax
movsbl %cl, %ecx
cmpl %ecx, %eax
jne 0x61c46
leaq 0x20(%rsp), %rdi
movl $0x2, %esi
callq 0x1b290
movl 0x1c(%rsp), %esi
movsbl %al, %edi
callq 0x61750
testb $0x1, %al
jne 0x61c46
movl 0x1c(%rsp), %edi
callq 0x617c0
movq %rax, %rsi
leaq 0x8(%rsp), %rdi
callq 0x7b90
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x20(%rsp), %rdi
movl $0x2, %ecx
callq 0x51280
movq %rax, 0x30(%rsp)
jmp 0x61c8a
leaq 0x20(%rsp), %rdi
callq 0x11670
cmpq $0x0, %rax
jbe 0x61c81
leaq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1b290
movl 0x1c(%rsp), %esi
movsbl %al, %edi
callq 0x61750
testb $0x1, %al
jne 0x61c76
jmp 0x61c81
movq $0x0, 0x30(%rsp)
jmp 0x61c8a
movq $-0x1, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| /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 || has_drive) &&
// {C:,//net}, skip to the next component.
(++pos != e) && is_separator((*pos)[0], style)) {
return *pos;
}
// POSIX style root directory.
if (!has_net && is_separator((*b)[0], style)) {
return *b;
}
}
// No path or no root.
return StringRef();
} | 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), %rdi
leaq 0xd0(%rsp), %rsi
movl $0x30, %edx
callq 0x7360
movq 0x108(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x110(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
leaq 0x60(%rsp), %rdi
callq 0x61310
leaq 0xd0(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x56f50
testb $0x1, %al
jne 0x624c5
jmp 0x626d7
leaq 0xd0(%rsp), %rdi
callq 0x62170
movq %rax, 0x40(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x621a0
movq %rax, %rdi
callq 0x11670
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x2, %rcx
movb %al, 0x1f(%rsp)
jbe 0x6257f
leaq 0xd0(%rsp), %rdi
callq 0x56d40
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1b290
movl 0x104(%rsp), %esi
movsbl %al, %edi
callq 0x61750
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x1f(%rsp)
jne 0x62533
jmp 0x6257f
leaq 0xd0(%rsp), %rdi
callq 0x56d40
movq %rax, %rdi
movl $0x1, %esi
callq 0x1b290
movsbl %al, %eax
movl %eax, 0x18(%rsp)
leaq 0xd0(%rsp), %rdi
callq 0x56d40
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1b290
movb %al, %cl
movl 0x18(%rsp), %eax
movsbl %cl, %ecx
cmpl %ecx, %eax
sete %al
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
andb $0x1, %al
movb %al, 0x4f(%rsp)
movl 0x104(%rsp), %edi
callq 0x617a0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x17(%rsp)
jne 0x625a4
jmp 0x625ee
leaq 0xd0(%rsp), %rdi
callq 0x62170
movq %rax, 0x30(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x621a0
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x2f8a9(%rip), %rsi # 0x91e7a
callq 0x7b90
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x56ee0
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
movb %al, 0x3f(%rsp)
testb $0x1, 0x4f(%rsp)
jne 0x62606
testb $0x1, 0x3f(%rsp)
je 0x6267a
leaq 0x90(%rsp), %rdi
callq 0x61370
movq %rax, %rdi
leaq 0x60(%rsp), %rsi
callq 0x56f50
testb $0x1, %al
jne 0x62626
jmp 0x6267a
leaq 0x90(%rsp), %rdi
callq 0x56d40
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1b290
movl 0x104(%rsp), %esi
movsbl %al, %edi
callq 0x61750
testb $0x1, %al
jne 0x62654
jmp 0x6267a
leaq 0x90(%rsp), %rdi
callq 0x56d40
movq (%rax), %rcx
movq %rcx, 0x118(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x120(%rsp)
jmp 0x626f8
testb $0x1, 0x4f(%rsp)
jne 0x626d5
leaq 0xd0(%rsp), %rdi
callq 0x56d40
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1b290
movl 0x104(%rsp), %esi
movsbl %al, %edi
callq 0x61750
testb $0x1, %al
jne 0x626af
jmp 0x626d5
leaq 0xd0(%rsp), %rdi
callq 0x56d40
movq (%rax), %rcx
movq %rcx, 0x118(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x120(%rsp)
jmp 0x626f8
jmp 0x626d7
leaq 0x118(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x7210
leaq 0x118(%rsp), %rdi
callq 0x11470
movq 0x118(%rsp), %rax
movq 0x120(%rsp), %rdx
addq $0x128, %rsp # imm = 0x128
retq
| /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(
R.Sequence, [](const RuleSpec::Element &E) {
return !E.Symbol.ends_with(OptSuffix);
});
}) &&
"Optional symbols should be eliminated!");
auto T = std::make_unique<GrammarTable>();
// Assemble the name->ID and ID->nonterminal name maps.
llvm::DenseSet<llvm::StringRef> UniqueNonterminals;
llvm::DenseMap<llvm::StringRef, SymbolID> SymbolIds;
llvm::DenseSet<llvm::StringRef> UniqueAttributeValues;
for (uint16_t I = 0; I < NumTerminals; ++I)
SymbolIds.try_emplace(T->Terminals[I], tokenSymbol(tok::TokenKind(I)));
auto Consider = [&](llvm::StringRef Name) {
if (!SymbolIds.count(Name))
UniqueNonterminals.insert(Name);
};
for (const auto &Spec : Specs) {
Consider(Spec.Target);
for (const RuleSpec::Element &Elt : Spec.Sequence) {
Consider(Elt.Symbol);
for (const auto& KV : Elt.Attributes)
UniqueAttributeValues.insert(KV.second);
}
}
for (llvm::StringRef Name : UniqueNonterminals) {
T->Nonterminals.emplace_back();
T->Nonterminals.back().Name = Name.str();
}
assert(T->Nonterminals.size() < (1 << (SymbolBits - 1)) &&
"Too many nonterminals to fit in SymbolID bits!");
llvm::sort(T->Nonterminals, [](const GrammarTable::Nonterminal &L,
const GrammarTable::Nonterminal &R) {
return L.Name < R.Name;
});
// Add an empty string for the corresponding sentinel unset attribute.
T->AttributeValues.push_back("");
UniqueAttributeValues.erase("");
for (llvm::StringRef Name : UniqueAttributeValues) {
T->AttributeValues.emplace_back();
T->AttributeValues.back() = Name.str();
}
llvm::sort(T->AttributeValues);
assert(T->AttributeValues.front() == "");
// Build name -> ID maps for nonterminals.
for (SymbolID SID = 0; SID < T->Nonterminals.size(); ++SID)
SymbolIds.try_emplace(T->Nonterminals[SID].Name, SID);
// Convert the rules.
T->Rules.reserve(Specs.size());
std::vector<SymbolID> Symbols;
auto Lookup = [SymbolIds](llvm::StringRef Name) {
auto It = SymbolIds.find(Name);
assert(It != SymbolIds.end() && "Didn't find the symbol in SymbolIds!");
return It->second;
};
for (const auto &Spec : Specs) {
assert(Spec.Sequence.size() <= Rule::MaxElements);
Symbols.clear();
for (const RuleSpec::Element &Elt : Spec.Sequence)
Symbols.push_back(Lookup(Elt.Symbol));
T->Rules.push_back(Rule(Lookup(Spec.Target), Symbols));
applyAttributes(Spec, *T, T->Rules.back());
}
assert(T->Rules.size() < (1 << RuleBits) &&
"Too many rules to fit in RuleID bits!");
const auto &SymbolOrder = getTopologicalOrder(T.get());
llvm::stable_sort(
T->Rules, [&SymbolOrder](const Rule &Left, const Rule &Right) {
// Sorted by the topological order of the nonterminal Target.
return SymbolOrder[Left.Target] < SymbolOrder[Right.Target];
});
for (SymbolID SID = 0; SID < T->Nonterminals.size(); ++SID) {
auto StartIt = llvm::partition_point(T->Rules, [&](const Rule &R) {
return SymbolOrder[R.Target] < SymbolOrder[SID];
});
RuleID Start = StartIt - T->Rules.begin();
RuleID End = Start;
while (End < T->Rules.size() && T->Rules[End].Target == SID)
++End;
T->Nonterminals[SID].RuleRange = {Start, End};
}
Grammar G(std::move(T));
diagnoseGrammar(G);
return G;
} | 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, 0x3f0(%rsp)
movq 0x3e8(%rsp), %rdx
movq 0x3f0(%rsp), %rcx
leaq 0x3f8(%rsp), %rdi
callq 0x77630
leaq 0x410(%rsp), %rdi
leaq 0x3f8(%rsp), %rsi
callq 0x778a0
movq 0x68(%rsp), %rsi
movq 0x410(%rsp), %rdx
movq 0x418(%rsp), %rcx
leaq 0x420(%rsp), %rdi
callq 0x774d0
leaq 0x3f8(%rsp), %rdi
callq 0x778f0
leaq 0x3e0(%rsp), %rdi
callq 0x77940
leaq 0x3c8(%rsp), %rdi
callq 0x77990
leaq 0x3b0(%rsp), %rdi
xorl %esi, %esi
callq 0x779b0
leaq 0x398(%rsp), %rdi
callq 0x77990
movw $0x0, 0x396(%rsp)
movzwl 0x396(%rsp), %eax
cmpl $0x1c5, %eax # imm = 0x1C5
jge 0x7699b
leaq 0x3e0(%rsp), %rdi
callq 0x6b870
movq %rax, %rdi
addq $0x18, %rdi
movzwl 0x396(%rsp), %eax
movl %eax, %esi
callq 0x6b9c0
movq %rax, %rsi
leaq 0x380(%rsp), %rdi
callq 0x8910
movzwl 0x396(%rsp), %edi
callq 0x6be70
movw %ax, 0x37e(%rsp)
leaq 0x360(%rsp), %rdi
leaq 0x3b0(%rsp), %rsi
leaq 0x380(%rsp), %rdx
leaq 0x37e(%rsp), %rcx
callq 0x779d0
movw 0x396(%rsp), %ax
addw $0x1, %ax
movw %ax, 0x396(%rsp)
jmp 0x76902
leaq 0x3b0(%rsp), %rax
movq %rax, 0x350(%rsp)
leaq 0x3c8(%rsp), %rax
movq %rax, 0x358(%rsp)
leaq 0x420(%rsp), %rax
movq %rax, 0x348(%rsp)
movq 0x348(%rsp), %rdi
callq 0x77b30
movq %rax, 0x340(%rsp)
movq 0x348(%rsp), %rdi
callq 0x77b60
movq %rax, 0x338(%rsp)
leaq 0x340(%rsp), %rdi
leaq 0x338(%rsp), %rsi
callq 0x77b90
testb $0x1, %al
jne 0x76a13
jmp 0x76bd7
leaq 0x340(%rsp), %rdi
callq 0x77bd0
movq %rax, 0x330(%rsp)
movq 0x330(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x320(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x328(%rsp)
movq 0x320(%rsp), %rsi
movq 0x328(%rsp), %rdx
leaq 0x350(%rsp), %rdi
callq 0x77be0
movq 0x330(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x318(%rsp)
movq 0x318(%rsp), %rdi
callq 0x77c30
movq %rax, 0x310(%rsp)
movq 0x318(%rsp), %rdi
callq 0x77c60
movq %rax, 0x308(%rsp)
leaq 0x310(%rsp), %rdi
leaq 0x308(%rsp), %rsi
callq 0x77c90
testb $0x1, %al
jne 0x76ac0
jmp 0x76bc3
leaq 0x310(%rsp), %rdi
callq 0x77cd0
movq %rax, 0x300(%rsp)
movq 0x300(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x2f0(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x2f8(%rsp)
movq 0x2f0(%rsp), %rsi
movq 0x2f8(%rsp), %rdx
leaq 0x350(%rsp), %rdi
callq 0x77be0
movq 0x300(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x2e8(%rsp)
movq 0x2e8(%rsp), %rdi
callq 0x77ce0
movq %rax, 0x2e0(%rsp)
movq 0x2e8(%rsp), %rdi
callq 0x77d10
movq %rax, 0x2d8(%rsp)
leaq 0x2e0(%rsp), %rdi
leaq 0x2d8(%rsp), %rsi
callq 0x77d40
testb $0x1, %al
jne 0x76b6a
jmp 0x76baf
leaq 0x2e0(%rsp), %rdi
callq 0x77d80
movq %rax, 0x2d0(%rsp)
movq 0x2d0(%rsp), %rdx
addq $0x10, %rdx
leaq 0x2b8(%rsp), %rdi
leaq 0x398(%rsp), %rsi
callq 0x4eee0
leaq 0x2e0(%rsp), %rdi
callq 0x77d90
jmp 0x76b4f
jmp 0x76bb1
leaq 0x310(%rsp), %rdi
callq 0x77db0
jmp 0x76aa2
jmp 0x76bc5
leaq 0x340(%rsp), %rdi
callq 0x77dd0
jmp 0x769f5
leaq 0x3c8(%rsp), %rax
movq %rax, 0x2b0(%rsp)
movq 0x2b0(%rsp), %rdi
callq 0x77df0
movq %rax, 0x2a0(%rsp)
movq %rdx, 0x2a8(%rsp)
movq 0x2b0(%rsp), %rdi
callq 0x77e30
movq %rax, 0x290(%rsp)
movq %rdx, 0x298(%rsp)
leaq 0x2a0(%rsp), %rdi
leaq 0x290(%rsp), %rsi
callq 0x77e70
testb $0x1, %al
jne 0x76c3f
jmp 0x76cd9
leaq 0x2a0(%rsp), %rdi
callq 0x4ef30
movq (%rax), %rcx
movq %rcx, 0x280(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x288(%rsp)
leaq 0x3e0(%rsp), %rdi
callq 0x6b870
movq %rax, %rdi
addq $0x28, %rdi
callq 0x77ea0
leaq 0x260(%rsp), %rdi
leaq 0x280(%rsp), %rsi
callq 0x121e0
leaq 0x3e0(%rsp), %rdi
callq 0x6b870
movq %rax, %rdi
addq $0x28, %rdi
callq 0x77f10
movq %rax, %rdi
leaq 0x260(%rsp), %rsi
callq 0x74e0
leaq 0x260(%rsp), %rdi
callq 0x7290
leaq 0x2a0(%rsp), %rdi
callq 0x77f50
jmp 0x76c21
leaq 0x3e0(%rsp), %rdi
callq 0x6b870
movq %rax, %rdi
addq $0x28, %rdi
callq 0x77f80
leaq 0x3e0(%rsp), %rdi
callq 0x6b870
addq $0x40, %rax
movq %rax, 0x50(%rsp)
leaq 0x237(%rsp), %rdi
callq 0x7700
leaq 0x238(%rsp), %rdi
leaq 0x1b0da(%rip), %rsi # 0x91dfe
leaq 0x237(%rsp), %rdx
callq 0x16430
movq 0x50(%rsp), %rdi
leaq 0x238(%rsp), %rsi
callq 0x393a0
leaq 0x238(%rsp), %rdi
callq 0x7290
leaq 0x237(%rsp), %rdi
callq 0x7420
leaq 0x220(%rsp), %rdi
leaq 0x1b092(%rip), %rsi # 0x91dfe
callq 0x7b90
leaq 0x398(%rsp), %rdi
leaq 0x220(%rsp), %rsi
callq 0x77fc0
leaq 0x398(%rsp), %rax
movq %rax, 0x218(%rsp)
movq 0x218(%rsp), %rdi
callq 0x77df0
movq %rax, 0x208(%rsp)
movq %rdx, 0x210(%rsp)
movq 0x218(%rsp), %rdi
callq 0x77e30
movq %rax, 0x1f8(%rsp)
movq %rdx, 0x200(%rsp)
leaq 0x208(%rsp), %rdi
leaq 0x1f8(%rsp), %rsi
callq 0x77e70
testb $0x1, %al
jne 0x76dee
jmp 0x76e88
leaq 0x208(%rsp), %rdi
callq 0x4ef30
movq (%rax), %rcx
movq %rcx, 0x1e8(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x1f0(%rsp)
leaq 0x3e0(%rsp), %rdi
callq 0x6b870
movq %rax, %rdi
addq $0x40, %rdi
callq 0x77ff0
leaq 0x1c8(%rsp), %rdi
leaq 0x1e8(%rsp), %rsi
callq 0x121e0
leaq 0x3e0(%rsp), %rdi
callq 0x6b870
movq %rax, %rdi
addq $0x40, %rdi
callq 0x396e0
movq %rax, %rdi
leaq 0x1c8(%rsp), %rsi
callq 0x74e0
leaq 0x1c8(%rsp), %rdi
callq 0x7290
leaq 0x208(%rsp), %rdi
callq 0x77f50
jmp 0x76dd0
leaq 0x3e0(%rsp), %rdi
callq 0x6b870
movq %rax, %rdi
addq $0x40, %rdi
callq 0x78060
movw $0x0, 0x1c6(%rsp)
movzwl 0x1c6(%rsp), %eax
movq %rax, 0x48(%rsp)
leaq 0x3e0(%rsp), %rdi
callq 0x6b870
movq %rax, %rdi
addq $0x28, %rdi
callq 0x8c30
movq %rax, %rcx
movq 0x48(%rsp), %rax
cmpq %rcx, %rax
jae 0x76f4f
leaq 0x3e0(%rsp), %rdi
callq 0x6b870
movq %rax, %rdi
addq $0x28, %rdi
movzwl 0x1c6(%rsp), %eax
movl %eax, %esi
callq 0x6b880
movq %rax, %rsi
leaq 0x1b0(%rsp), %rdi
callq 0x8910
leaq 0x198(%rsp), %rdi
leaq 0x3b0(%rsp), %rsi
leaq 0x1b0(%rsp), %rdx
leaq 0x1c6(%rsp), %rcx
callq 0x780a0
movw 0x1c6(%rsp), %ax
addw $0x1, %ax
movw %ax, 0x1c6(%rsp)
jmp 0x76eab
leaq 0x3e0(%rsp), %rdi
callq 0x6b870
movq %rax, 0x40(%rsp)
leaq 0x420(%rsp), %rdi
callq 0x78310
movq 0x40(%rsp), %rdi
movq %rax, %rsi
callq 0x78200
leaq 0x180(%rsp), %rdi
callq 0x37510
leaq 0x168(%rsp), %rdi
leaq 0x3b0(%rsp), %rsi
callq 0x78330
leaq 0x420(%rsp), %rax
movq %rax, 0x160(%rsp)
movq 0x160(%rsp), %rdi
callq 0x77b30
movq %rax, 0x158(%rsp)
movq 0x160(%rsp), %rdi
callq 0x77b60
movq %rax, 0x150(%rsp)
leaq 0x158(%rsp), %rdi
leaq 0x150(%rsp), %rsi
callq 0x77b90
testb $0x1, %al
jne 0x76ff5
jmp 0x771ef
leaq 0x158(%rsp), %rdi
callq 0x77bd0
movq %rax, 0x148(%rsp)
leaq 0x180(%rsp), %rdi
callq 0x78370
movq 0x148(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x140(%rsp)
movq 0x140(%rsp), %rdi
callq 0x77c30
movq %rax, 0x138(%rsp)
movq 0x140(%rsp), %rdi
callq 0x77c60
movq %rax, 0x130(%rsp)
leaq 0x138(%rsp), %rdi
leaq 0x130(%rsp), %rsi
callq 0x77c90
testb $0x1, %al
jne 0x77073
jmp 0x770f3
leaq 0x138(%rsp), %rdi
callq 0x77cd0
movq %rax, 0x128(%rsp)
movq 0x128(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x110(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x118(%rsp)
movq 0x110(%rsp), %rsi
movq 0x118(%rsp), %rdx
leaq 0x168(%rsp), %rdi
callq 0x78390
movw %ax, 0x126(%rsp)
leaq 0x180(%rsp), %rdi
leaq 0x126(%rsp), %rsi
callq 0x6b070
leaq 0x138(%rsp), %rdi
callq 0x77db0
jmp 0x77055
leaq 0x3e0(%rsp), %rdi
callq 0x6b870
movq %rax, 0x28(%rsp)
movq 0x148(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0xe8(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0xf0(%rsp)
movq 0xe8(%rsp), %rsi
movq 0xf0(%rsp), %rdx
leaq 0x168(%rsp), %rdi
callq 0x78390
movw %ax, 0x26(%rsp)
leaq 0xd8(%rsp), %rdi
leaq 0x180(%rsp), %rsi
callq 0x78400
movw 0x26(%rsp), %ax
movq 0xd8(%rsp), %rdx
movq 0xe0(%rsp), %rcx
leaq 0xf8(%rsp), %rdi
movzwl %ax, %esi
callq 0x6b540
movq 0x28(%rsp), %rdi
leaq 0xf8(%rsp), %rsi
callq 0x783d0
movq 0x148(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x3e0(%rsp), %rdi
callq 0x125e0
movq %rax, 0x38(%rsp)
leaq 0x3e0(%rsp), %rdi
callq 0x6b870
movq %rax, %rdi
callq 0x78710
movq 0x68(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq %rax, %rcx
callq 0x78450
leaq 0x158(%rsp), %rdi
callq 0x77dd0
jmp 0x76fd7
leaq 0x3e0(%rsp), %rdi
callq 0x12610
movq 0x68(%rsp), %rsi
movq %rax, %rdx
leaq 0xb8(%rsp), %rdi
callq 0x78750
leaq 0xb8(%rsp), %rax
movq %rax, 0xd0(%rsp)
leaq 0x3e0(%rsp), %rdi
callq 0x6b870
movq %rax, %rdi
movq 0xd0(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0xb0(%rsp), %rsi
callq 0x78ad0
movw $0x0, 0xae(%rsp)
movzwl 0xae(%rsp), %eax
movq %rax, 0x18(%rsp)
leaq 0x3e0(%rsp), %rdi
callq 0x6b870
movq %rax, %rdi
addq $0x28, %rdi
callq 0x8c30
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x77403
leaq 0x3e0(%rsp), %rdi
callq 0x6b870
movq %rax, %rdi
movq 0xd0(%rsp), %rax
movq %rax, 0x90(%rsp)
leaq 0xae(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x90(%rsp), %rsi
movq 0x98(%rsp), %rdx
callq 0x78b20
movq %rax, 0xa0(%rsp)
leaq 0x3e0(%rsp), %rdi
callq 0x6b870
movq %rax, %rdi
callq 0x78be0
movq %rax, 0x80(%rsp)
leaq 0xa0(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x78b90
movw %ax, 0x8e(%rsp)
movw 0x8e(%rsp), %ax
movw %ax, 0x7e(%rsp)
movzwl 0x7e(%rsp), %eax
movq %rax, 0x8(%rsp)
leaq 0x3e0(%rsp), %rdi
callq 0x6b870
movq %rax, %rdi
callq 0x6bd80
movq 0x8(%rsp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, 0x17(%rsp)
jae 0x7738c
leaq 0x3e0(%rsp), %rdi
callq 0x6b870
movq %rax, %rdi
movzwl 0x7e(%rsp), %eax
movl %eax, %esi
callq 0x6b8a0
movw (%rax), %ax
andw $0xfff, %ax # imm = 0xFFF
movzwl %ax, %eax
movzwl 0xae(%rsp), %ecx
cmpl %ecx, %eax
sete %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x77396
jmp 0x773a9
movw 0x7e(%rsp), %ax
addw $0x1, %ax
movw %ax, 0x7e(%rsp)
jmp 0x77323
movw 0x8e(%rsp), %ax
movw %ax, 0x7a(%rsp)
movw 0x7e(%rsp), %ax
movw %ax, 0x7c(%rsp)
leaq 0x3e0(%rsp), %rdi
callq 0x6b870
movq %rax, %rdi
addq $0x28, %rdi
movzwl 0xae(%rsp), %eax
movl %eax, %esi
callq 0x6b880
movl 0x7a(%rsp), %ecx
movl %ecx, 0x20(%rax)
movw 0xae(%rsp), %ax
addw $0x1, %ax
movw %ax, 0xae(%rsp)
jmp 0x77258
movb $0x0, 0x79(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x3e0(%rsp), %rsi
callq 0x6b680
movq 0x58(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x6b610
leaq 0x70(%rsp), %rdi
callq 0x13ae0
movq 0x68(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x78c10
movb $0x1, 0x79(%rsp)
testb $0x1, 0x79(%rsp)
jne 0x77458
movq 0x58(%rsp), %rdi
callq 0x10500
leaq 0xb8(%rsp), %rdi
callq 0x378b0
leaq 0x168(%rsp), %rdi
callq 0x79430
leaq 0x180(%rsp), %rdi
callq 0x37760
leaq 0x398(%rsp), %rdi
callq 0x79440
leaq 0x3b0(%rsp), %rdi
callq 0x79450
leaq 0x3c8(%rsp), %rdi
callq 0x79440
leaq 0x3e0(%rsp), %rdi
callq 0x13ae0
leaq 0x420(%rsp), %rdi
callq 0x778f0
movq 0x60(%rsp), %rax
addq $0x458, %rsp # imm = 0x458
retq
nopl (%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>>>>>>(__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>>>>>, __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>>>>>) | 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_CHECKS
detail::presortShuffle<IteratorTy>(Start, End);
#endif
std::sort(Start, End);
}
} | 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_string_view<char>, fmt::v5::basic_format_specs<char> const&, 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>) | 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() > size) {
padding = spec.width() - size;
size = spec.width();
}
} else if (spec.precision > num_digits) {
size = prefix.size() + internal::to_unsigned(spec.precision);
padding = internal::to_unsigned(spec.precision - num_digits);
fill = static_cast<char_type>('0');
}
align_spec as = spec;
if (spec.align() == ALIGN_DEFAULT)
as.align_ = ALIGN_RIGHT;
write_padded(as, padded_int_writer<F>{size, prefix, fill, padding, f});
} | 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
jle 0x77d4
movq %rbx, %r10
addq %rcx, %r10
subl %esi, %ebx
movb $0x30, %r11b
jmp 0x77d6
xorl %ebx, %ebx
movl 0x8(%r8), %esi
movl %esi, 0x10(%rsp)
movq (%r8), %rsi
movq %rsi, 0x8(%rsp)
testl %eax, %eax
jne 0x77f2
movl $0x2, 0x10(%rsp)
leaq 0x18(%rsp), %rax
movq %r10, (%rax)
movq %rdx, 0x8(%rax)
movq %rcx, 0x10(%rax)
movb %r11b, 0x18(%rax)
movq %rbx, 0x20(%rax)
movq %r9, 0x28(%rax)
leaq 0x8(%rsp), %rsi
movq %rax, %rdx
callq 0x7824
addq $0x48, %rsp
popq %rbx
popq %r14
retq
nop
| /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, fmt::v5::basic_format_specs<char>>::num_writer>>(fmt::v5::align_spec const&, 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, fmt::v5::basic_format_specs<char>>::num_writer>&&) | 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 &&it = reserve(width + (size - num_code_points));
char_type fill = static_cast<char_type>(spec.fill());
std::size_t padding = width - num_code_points;
if (spec.align() == ALIGN_RIGHT) {
it = std::fill_n(it, padding, fill);
f(it);
} else if (spec.align() == ALIGN_CENTER) {
std::size_t left_padding = padding / 2;
it = std::fill_n(it, left_padding, fill);
f(it);
it = std::fill_n(it, padding - left_padding, fill);
} else {
f(it);
it = std::fill_n(it, padding, fill);
}
} | 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)
jae 0x7ea2
movq (%rbp), %rax
movq %rbp, %rdi
movq %rbx, %rsi
callq *(%rax)
movq %rbx, 0x10(%rbp)
addq 0x8(%rbp), %r12
movq %r12, (%rsp)
movb 0x4(%r13), %bpl
movl 0x8(%r13), %eax
cmpl $0x3, %eax
je 0x7f29
cmpl $0x2, %eax
jne 0x7f6d
cmpq %r15, 0x8(%rsp)
je 0x7ee1
leaq (%r12,%r14), %rbx
movzbl %bpl, %esi
movq %r12, %rdi
movq %r14, %rdx
callq 0x5190
movq %rbx, %r12
movq %rsp, %rsi
movq %r12, (%rsi)
movq 0x10(%rsp), %rdi
callq 0x8016
jmp 0x7f9e
movq (%rdi), %r14
movq 0x10(%r14), %rbx
addq %rbx, %r15
cmpq %r15, 0x18(%r14)
jae 0x7f11
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *(%rax)
movq %r15, 0x10(%r14)
addq 0x8(%r14), %rbx
movq %rsp, %rsi
movq %rbx, (%rsi)
movq %r12, %rdi
callq 0x7fae
jmp 0x7f9e
movq %r14, %r13
shrq %r13
cmpq $0x2, %r14
jb 0x7f4b
leaq (%r12,%r13), %rbx
movzbl %bpl, %esi
movq %r12, %rdi
movq %r13, %rdx
callq 0x5190
movq %rbx, %r12
movq %rsp, %rbx
movq %r12, (%rbx)
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x8016
movq (%rbx), %rdi
cmpq %r15, 0x8(%rsp)
je 0x7f9a
subq %r13, %r14
jmp 0x7f87
movq %rsp, %rbx
movq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x8016
movq (%rbx), %rdi
cmpq %r15, 0x8(%rsp)
je 0x7f9a
leaq (%rdi,%r14), %rbx
movzbl %bpl, %esi
movq %r14, %rdx
callq 0x5190
movq %rbx, %rdi
movq %rdi, (%rsp)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
| /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 # 0x1aaa0
movl (%rax,%r15,4), %eax
movl %eax, 0x14(%rsp)
movq (%rdi), %rax
movq 0x8(%rax), %rsi
testq %rsi, %rsi
je 0x859c
leaq 0x8(%rsp), %rdi
callq 0x51a0
jmp 0x85a6
leaq 0x8(%rsp), %rdi
callq 0x5490
leaq 0x8(%rsp), %rdi
callq 0x5130
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
movl %eax, %ebp
xorl %r14d, %r14d
xorl %r13d, %r13d
cmpl %r12d, 0x14(%rsp)
setbe %r14b
seta %r13b
leaq 0x8(%rsp), %rdi
callq 0x5350
movl %r15d, %eax
subl %r13d, %eax
cltq
imulq $0x55555556, %rax, %rax # imm = 0x55555556
movq %rax, %rcx
shrq $0x3f, %rcx
shrq $0x20, %rax
addl %ecx, %eax
addl %r15d, %r14d
addl %eax, %r14d
leaq 0x14(%rbx), %rdx
movl 0x18(%rbx), %ecx
movq (%rbx), %rdi
movq 0x8(%rbx), %r8
movl 0x10(%rbx), %eax
movl %eax, 0x18(%rsp)
movl %r14d, 0x1c(%rsp)
movb %bpl, 0x20(%rsp)
movl 0x20(%rsp), %eax
movq 0x18(%rsp), %r9
movl %r14d, %esi
pushq %rax
pushq %r9
callq 0x938c
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5350
movq %rbx, %rdi
callq 0x5400
nop
| /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, %r12
je 0xa270
leaq (%r15,%r12), %r13
movl 0x18(%r14), %esi
movq %r15, %rdi
movq %r12, %rdx
callq 0x5190
movq %r13, (%rbx)
movq 0x28(%r14), %rcx
movq 0x8(%rcx), %rax
movslq 0x30(%r14), %rdx
addq %rdx, %r13
cmpb $0x78, 0x11(%rax)
leaq 0x101ab(%rip), %rsi # 0x1a438
leaq 0x10193(%rip), %rax # 0x1a427
cmoveq %rsi, %rax
movq 0x10(%rcx), %rcx
addq %rdx, %r12
leaq (%r15,%r12), %rdx
decq %rdx
movq %rcx, %rsi
movl %ecx, %edi
andl $0xf, %edi
movb (%rax,%rdi), %dil
movb %dil, (%rdx)
shrq $0x4, %rsi
decq %rdx
cmpq $0xf, %rcx
movq %rsi, %rcx
ja 0xa2a9
movq %r13, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /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, %r12
je 0xa664
leaq (%r15,%r12), %r13
movl 0x18(%r14), %esi
movq %r15, %rdi
movq %r12, %rdx
callq 0x5190
movq %r13, (%rbx)
movq 0x28(%r14), %rax
movslq 0x30(%r14), %rcx
addq %rcx, %r13
addq %rcx, %r12
leaq (%r15,%r12), %rcx
decq %rcx
movq %rax, %rdx
movl %eax, %esi
andb $0x1, %sil
orb $0x30, %sil
movb %sil, (%rcx)
shrq %rdx
decq %rcx
cmpq $0x1, %rax
movq %rdx, %rax
ja 0xa67f
movq %r13, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /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, %r12
je 0xd76e
leaq (%r15,%r12), %r13
movl 0x18(%r14), %esi
movq %r15, %rdi
movq %r12, %rdx
callq 0x5190
movq %r13, (%rbx)
movl 0x28(%r14), %eax
movslq 0x2c(%r14), %rcx
addq %rcx, %r13
addq %rcx, %r12
leaq (%r15,%r12), %rcx
decq %rcx
movl %eax, %edx
movl %eax, %esi
andb $0x1, %sil
orb $0x30, %sil
movb %sil, (%rcx)
shrl %edx
decq %rcx
cmpl $0x1, %eax
movl %edx, %eax
ja 0xd788
movq %r13, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
| /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::v5::basic_format_context<std::back_insert_iterator<fmt::v5::internal::basic_buffer<char>>, char>>>&) | 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 '+':
handler.on_plus();
++begin;
break;
case '-':
handler.on_minus();
++begin;
break;
case ' ':
handler.on_space();
++begin;
break;
}
if (begin == end) return begin;
if (*begin == '#') {
handler.on_hash();
if (++begin == end) return begin;
}
// Parse zero flag.
if (*begin == '0') {
handler.on_zero();
if (++begin == end) return begin;
}
begin = parse_width(begin, end, handler);
if (begin == end) return begin;
// Parse precision.
if (*begin == '.') {
++begin;
auto c = begin != end ? *begin : 0;
if ('0' <= c && c <= '9') {
handler.on_precision(parse_nonnegative_int(begin, end, handler));
} else if (c == '{') {
++begin;
if (begin != end) {
begin = parse_arg_id(
begin, end, precision_adapter<SpecHandler, Char>(handler));
}
if (begin == end || *begin++ != '}')
return handler.on_error("invalid format string"), begin;
} else {
return handler.on_error("missing precision specifier"), begin;
}
handler.end_precision();
}
// Parse type.
if (begin != end && *begin != '}')
handler.on_type(*begin++);
return begin;
} | 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 0x10567
cmpl $0x2b, %eax
jne 0x1058b
movq %rbx, %rdi
callq 0x10a2e
movq (%rbx), %rax
orb $0x3, 0x10(%rax)
jmp 0x10587
movq %rbx, %rdi
callq 0x10a2e
movq (%rbx), %rax
orb $0x4, 0x10(%rax)
jmp 0x10587
movq %rbx, %rdi
callq 0x10a2e
movq (%rbx), %rax
orb $0x1, 0x10(%rax)
incq (%rsp)
movq (%rsp), %rax
cmpq %r14, %rax
je 0x10703
cmpb $0x23, (%rax)
jne 0x105b9
movq %rbx, %rdi
callq 0x1080a
movq (%rsp), %rax
incq %rax
movq %rax, (%rsp)
cmpq %r14, %rax
je 0x10703
movq (%rsp), %rax
cmpb $0x30, (%rax)
jne 0x10601
movl 0x10(%rbx), %eax
decl %eax
cmpl $0x9, %eax
jb 0x105dc
movq 0x8(%rbx), %rdi
leaq 0x9f72(%rip), %rsi # 0x1a549
callq 0x6928
movq (%rbx), %rax
movabsq $0x400000030, %rcx # imm = 0x400000030
movq %rcx, 0x4(%rax)
movq (%rsp), %rax
incq %rax
movq %rax, (%rsp)
cmpq %r14, %rax
je 0x10703
movq (%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x10831
movq %rax, (%rsp)
cmpq %r14, %rax
je 0x10703
cmpb $0x2e, (%rax)
jne 0x106e1
leaq 0x1(%rax), %rcx
movq %rcx, (%rsp)
cmpq %r14, %rcx
je 0x10638
movsbl (%rcx), %ecx
jmp 0x1063a
xorl %ecx, %ecx
leal -0x30(%rcx), %edx
cmpl $0x9, %edx
ja 0x1067a
movq %rsp, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x108c0
movq (%rbx), %rcx
movl %eax, 0xc(%rcx)
movl 0x10(%rbx), %eax
movb $0x1, %bpl
leal -0x1(%rax), %ecx
cmpl $0x7, %ecx
jae 0x1070c
movq 0x8(%rbx), %rdi
leaq 0x9f7b(%rip), %rsi # 0x1a5ee
callq 0x6928
jmp 0x106dc
cmpl $0x7b, %ecx
jne 0x106c6
addq $0x2, %rax
movq %rax, (%rsp)
cmpq %r14, %rax
je 0x106a3
leaq 0x8(%rsp), %rdx
movq %rbx, (%rdx)
movq %rax, %rdi
movq %r14, %rsi
callq 0x10926
movq %rax, (%rsp)
movq (%rsp), %rax
cmpq %r14, %rax
je 0x106b9
leaq 0x1(%rax), %rcx
movq %rcx, (%rsp)
cmpb $0x7d, (%rax)
je 0x10656
movq 0x8(%rbx), %rdi
leaq 0x9ca3(%rip), %rsi # 0x1a367
jmp 0x106d1
movq 0x8(%rbx), %rdi
leaq 0x9e41(%rip), %rsi # 0x1a512
callq 0x6928
xorl %ebp, %ebp
movq (%rsp), %rax
testb %bpl, %bpl
je 0x10703
movq (%rsp), %rax
cmpq %r14, %rax
je 0x106ff
cmpb $0x7d, (%rax)
je 0x106ff
leaq 0x1(%rax), %rcx
movq %rcx, (%rsp)
movb (%rax), %al
movq (%rbx), %rcx
movb %al, 0x11(%rcx)
movq (%rsp), %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0xc, %eax
je 0x10668
jmp 0x10678
| /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_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>&&) | 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 || (*begin != '}' && *begin != ':'))
return handler.on_error("invalid format string"), begin;
handler(index);
return begin;
}
if (!is_name_start(c))
return handler.on_error("invalid format string"), begin;
auto it = begin;
do {
++it;
} while (it != end && (is_name_start(c = *it) || ('0' <= c && c <= '9')));
handler(basic_string_view<Char>(begin, to_unsigned(it - begin)));
return it;
} | 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, %rsi
movq %rbx, %rdx
callq 0x11153
movq (%r15), %rcx
cmpq %r14, %rcx
je 0x109cd
movzbl (%rcx), %ecx
cmpl $0x3a, %ecx
je 0x10984
cmpl $0x7d, %ecx
jne 0x109cd
movq (%rbx), %rsi
movq (%rsi), %rbx
addq $0xc, %rbx
leaq 0x30(%rsp), %r14
movq %r14, %rdi
movl %eax, %edx
callq 0x110c8
movaps (%r14), %xmm0
movaps 0x10(%r14), %xmm1
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
leaq 0x27(%rsp), %rsi
movq %rbx, %rdi
callq 0x1120b
jmp 0x109e0
movq %rdi, %rsi
cmpb $0x5f, %al
je 0x109f2
andb $-0x21, %al
addb $-0x41, %al
cmpb $0x19, %al
jbe 0x109f2
movq (%rbx), %rax
movq 0x8(%rax), %rdi
leaq 0x998c(%rip), %rsi # 0x1a367
callq 0x6928
movq 0x28(%rsp), %r14
movq %r14, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x1(%rsi), %rax
cmpq %r14, %rax
je 0x10a1e
movb (%rax), %cl
leal -0x30(%rcx), %edx
incq %rax
cmpb $0xa, %dl
jb 0x109f6
cmpb $0x5f, %cl
je 0x109f6
andb $-0x21, %cl
addb $-0x41, %cl
cmpb $0x1a, %cl
jb 0x109f6
decq %rax
movq %rax, %r14
movq %r14, %rdx
subq %rsi, %rdx
movq %rbx, %rdi
callq 0x111bc
jmp 0x109e5
| /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 $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 0x5160
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
| /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(details::make_unique<details::name_formatter>(padding));
break;
case 'l': // level
formatters_.push_back(details::make_unique<details::level_formatter>(padding));
break;
case 'L': // short level
formatters_.push_back(details::make_unique<details::short_level_formatter>(padding));
break;
case ('t'): // thread id
formatters_.push_back(details::make_unique<details::t_formatter>(padding));
break;
case ('v'): // the message text
formatters_.push_back(details::make_unique<details::v_formatter>(padding));
break;
case ('a'): // weekday
formatters_.push_back(details::make_unique<details::a_formatter>(padding));
break;
case ('A'): // short weekday
formatters_.push_back(details::make_unique<details::A_formatter>(padding));
break;
case ('b'):
case ('h'): // month
formatters_.push_back(details::make_unique<details::b_formatter>(padding));
break;
case ('B'): // short month
formatters_.push_back(details::make_unique<details::B_formatter>(padding));
break;
case ('c'): // datetime
formatters_.push_back(details::make_unique<details::c_formatter>(padding));
break;
case ('C'): // year 2 digits
formatters_.push_back(details::make_unique<details::C_formatter>(padding));
break;
case ('Y'): // year 4 digits
formatters_.push_back(details::make_unique<details::Y_formatter>(padding));
break;
case ('D'):
case ('x'): // datetime MM/DD/YY
formatters_.push_back(details::make_unique<details::D_formatter>(padding));
break;
case ('m'): // month 1-12
formatters_.push_back(details::make_unique<details::m_formatter>(padding));
break;
case ('d'): // day of month 1-31
formatters_.push_back(details::make_unique<details::d_formatter>(padding));
break;
case ('H'): // hours 24
formatters_.push_back(details::make_unique<details::H_formatter>(padding));
break;
case ('I'): // hours 12
formatters_.push_back(details::make_unique<details::I_formatter>(padding));
break;
case ('M'): // minutes
formatters_.push_back(details::make_unique<details::M_formatter>(padding));
break;
case ('S'): // seconds
formatters_.push_back(details::make_unique<details::S_formatter>(padding));
break;
case ('e'): // milliseconds
formatters_.push_back(details::make_unique<details::e_formatter>(padding));
break;
case ('f'): // microseconds
formatters_.push_back(details::make_unique<details::f_formatter>(padding));
break;
case ('F'): // nanoseconds
formatters_.push_back(details::make_unique<details::F_formatter>(padding));
break;
case ('E'): // seconds since epoch
formatters_.push_back(details::make_unique<details::E_formatter>(padding));
break;
case ('p'): // am/pm
formatters_.push_back(details::make_unique<details::p_formatter>(padding));
break;
case ('r'): // 12 hour clock 02:55:02 pm
formatters_.push_back(details::make_unique<details::r_formatter>(padding));
break;
case ('R'): // 24-hour HH:MM time
formatters_.push_back(details::make_unique<details::R_formatter>(padding));
break;
case ('T'):
case ('X'): // ISO 8601 time format (HH:MM:SS)
formatters_.push_back(details::make_unique<details::T_formatter>(padding));
break;
case ('z'): // timezone
formatters_.push_back(details::make_unique<details::z_formatter>(padding));
break;
case ('P'): // pid
formatters_.push_back(details::make_unique<details::pid_formatter>(padding));
break;
#ifdef SPDLOG_ENABLE_MESSAGE_COUNTER
case ('i'):
formatters_.push_back(details::make_unique<details::i_formatter>(padding));
break;
#endif
case ('^'): // color range start
formatters_.push_back(details::make_unique<details::color_start_formatter>(padding));
break;
case ('$'): // color range end
formatters_.push_back(details::make_unique<details::color_stop_formatter>(padding));
break;
case ('@'): // source location (filename:filenumber)
formatters_.push_back(details::make_unique<details::source_location_formatter>(padding));
break;
case ('s'): // source filename
formatters_.push_back(details::make_unique<details::source_filename_formatter>(padding));
break;
case ('#'): // source line number
formatters_.push_back(details::make_unique<details::source_linenum_formatter>(padding));
break;
case ('!'): // source funcname
formatters_.push_back(details::make_unique<details::source_funcname_formatter>(padding));
break;
case ('%'): // % char
formatters_.push_back(details::make_unique<details::ch_formatter>('%'));
break;
default: // Unknown flag appears as is
auto unknown_flag = details::make_unique<details::aggregate_formatter>();
unknown_flag->add_ch('%');
unknown_flag->add_ch(flag);
formatters_.push_back((std::move(unknown_flag)));
break;
}
} | 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
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
leaq 0x122d9(%rip), %rcx # 0x254e0
movq %rcx, (%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x11fb8
jmp 0x13a4a
addq $0x90, %rbx
movl $0x18, %edi
callq 0x5280
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
leaq 0x12162(%rip), %rcx # 0x253a0
movq %rcx, (%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x11fb8
jmp 0x13a4a
addq $0x90, %rbx
movl $0x18, %edi
callq 0x5280
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
leaq 0x125eb(%rip), %rcx # 0x25860
movq %rcx, (%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x11fb8
jmp 0x13a4a
addq $0x90, %rbx
movl $0x18, %edi
callq 0x5280
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
leaq 0x12534(%rip), %rcx # 0x257e0
movq %rcx, (%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x11fb8
jmp 0x13a4a
addq $0x90, %rbx
movl $0x28, %edi
callq 0x5280
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
leaq 0x125bd(%rip), %rcx # 0x258a0
movq %rcx, (%rax)
movq $0x5, 0x18(%rax)
movq $0x0, 0x20(%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x11fb8
jmp 0x13a4a
addq $0x90, %rbx
movl $0x18, %edi
callq 0x5280
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
leaq 0x121f6(%rip), %rcx # 0x25520
movq %rcx, (%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x11fb8
jmp 0x13a4a
addq $0x90, %rbx
movl $0x18, %edi
callq 0x5280
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
leaq 0x11f7f(%rip), %rcx # 0x252e0
movq %rcx, (%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x11fb8
jmp 0x13a4a
addq $0x90, %rbx
movl $0x18, %edi
callq 0x5280
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
leaq 0x12648(%rip), %rcx # 0x259e0
movq %rcx, (%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x11fb8
jmp 0x13a4a
addq $0x90, %rbx
movl $0x18, %edi
callq 0x5280
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
leaq 0x12051(%rip), %rcx # 0x25420
movq %rcx, (%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x11fb8
jmp 0x13a4a
addq $0x90, %rbx
movl $0x18, %edi
callq 0x5280
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
leaq 0x1241a(%rip), %rcx # 0x25820
movq %rcx, (%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x11fb8
jmp 0x13a4a
addq $0x90, %rbx
movl $0x18, %edi
callq 0x5280
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
leaq 0x12163(%rip), %rcx # 0x255a0
movq %rcx, (%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x11fb8
jmp 0x13a4a
addq $0x90, %rbx
movl $0x18, %edi
callq 0x5280
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
leaq 0x124ec(%rip), %rcx # 0x25960
movq %rcx, (%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x11fb8
jmp 0x13a4a
addq $0x90, %rbx
movl $0x18, %edi
callq 0x5280
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
leaq 0x124f5(%rip), %rcx # 0x259a0
movq %rcx, (%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x11fb8
jmp 0x13a4a
addq $0x90, %rbx
movl $0x18, %edi
callq 0x5280
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
leaq 0x11cfe(%rip), %rcx # 0x251e0
movq %rcx, (%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x11fb8
jmp 0x13a4a
addq $0x90, %rbx
movl $0x18, %edi
callq 0x5280
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
leaq 0x12407(%rip), %rcx # 0x25920
movq %rcx, (%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x11fb8
jmp 0x13a4a
addq $0x90, %rbx
movl $0x18, %edi
callq 0x5280
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
leaq 0x12510(%rip), %rcx # 0x25a60
movq %rcx, (%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x11fb8
jmp 0x13a4a
addq $0x90, %rbx
movl $0x18, %edi
callq 0x5280
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
leaq 0x12499(%rip), %rcx # 0x25a20
movq %rcx, (%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x11fb8
jmp 0x13a4a
addq $0x90, %rbx
movl $0x18, %edi
callq 0x5280
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
leaq 0x11da2(%rip), %rcx # 0x25360
movq %rcx, (%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x11fb8
jmp 0x13a4a
addq $0x90, %rbx
movl $0x18, %edi
callq 0x5280
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
leaq 0x11deb(%rip), %rcx # 0x253e0
movq %rcx, (%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x11fb8
jmp 0x13a4a
addq $0x90, %rbx
movl $0x18, %edi
callq 0x5280
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
leaq 0x11f34(%rip), %rcx # 0x25560
movq %rcx, (%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x11fb8
jmp 0x13a4a
addq $0x90, %rbx
movl $0x18, %edi
callq 0x5280
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
leaq 0x120bd(%rip), %rcx # 0x25720
movq %rcx, (%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x11fb8
jmp 0x13a4a
addq $0x90, %rbx
movl $0x18, %edi
callq 0x5280
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
leaq 0x11fc6(%rip), %rcx # 0x25660
movq %rcx, (%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x11fb8
jmp 0x13a4a
addq $0x90, %rbx
movl $0x20, %edi
callq 0x5280
movq $0x0, 0x8(%rax)
movl $0x0, 0x10(%rax)
leaq 0x123c7(%rip), %rcx # 0x25aa0
movq %rcx, (%rax)
movb $0x25, 0x18(%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x11fb8
jmp 0x13a4a
addq $0x90, %rbx
movl $0x18, %edi
callq 0x5280
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
leaq 0x1204c(%rip), %rcx # 0x25760
movq %rcx, (%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x11fb8
jmp 0x13a4a
addq $0x90, %rbx
movl $0xc0, %edi
callq 0x5280
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
leaq 0x119bd(%rip), %rcx # 0x25108
movq %rcx, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
leaq 0x11a1e(%rip), %rdx # 0x25180
movq %rdx, 0x20(%rax)
leaq 0x40(%rax), %rdx
movq %rdx, 0x28(%rax)
movq $0x80, 0x38(%rax)
movq %rcx, 0x10(%rsp)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x11fb8
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1379b
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x13a5a
leaq 0x10(%rsp), %rdi
callq 0x12bac
jmp 0x13a5a
addq $0x90, %rbx
movl $0x18, %edi
callq 0x5280
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
leaq 0x11cc0(%rip), %rcx # 0x254a0
movq %rcx, (%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x11fb8
jmp 0x13a4a
addq $0x90, %rbx
movl $0x18, %edi
callq 0x5280
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
leaq 0x11e89(%rip), %rcx # 0x256a0
movq %rcx, (%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x11fb8
jmp 0x13a4a
addq $0x90, %rbx
movl $0x18, %edi
callq 0x5280
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
leaq 0x119d2(%rip), %rcx # 0x25220
movq %rcx, (%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x11fb8
jmp 0x13a4a
addq $0x90, %rbx
movl $0x18, %edi
callq 0x5280
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
leaq 0x11bdb(%rip), %rcx # 0x25460
movq %rcx, (%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x11fb8
jmp 0x13a4a
addq $0x90, %rbx
movl $0x18, %edi
callq 0x5280
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
leaq 0x11a64(%rip), %rcx # 0x25320
movq %rcx, (%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x11fb8
jmp 0x13a4a
addq $0x90, %rbx
movl $0x18, %edi
callq 0x5280
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
leaq 0x11ced(%rip), %rcx # 0x255e0
movq %rcx, (%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x11fb8
jmp 0x13a4a
addq $0x90, %rbx
movl $0x18, %edi
callq 0x5280
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
leaq 0x11976(%rip), %rcx # 0x252a0
movq %rcx, (%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x11fb8
jmp 0x13a4a
addq $0x90, %rbx
movl $0x18, %edi
callq 0x5280
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
leaq 0x118ff(%rip), %rcx # 0x25260
movq %rcx, (%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x11fb8
jmp 0x13a4a
addq $0x90, %rbx
movl $0x18, %edi
callq 0x5280
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
leaq 0x11d48(%rip), %rcx # 0x256e0
movq %rcx, (%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x11fb8
jmp 0x13a4a
addq $0x90, %rbx
movl $0x18, %edi
callq 0x5280
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
leaq 0x11f11(%rip), %rcx # 0x258e0
movq %rcx, (%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x11fb8
jmp 0x13a4a
addq $0x90, %rbx
movl $0x18, %edi
callq 0x5280
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
leaq 0x11d9d(%rip), %rcx # 0x257a0
movq %rcx, (%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x11fb8
jmp 0x13a4a
addq $0x90, %rbx
movl $0x18, %edi
callq 0x5280
movq %r14, 0x8(%rax)
movl %ebp, 0x10(%rax)
leaq 0x11be9(%rip), %rcx # 0x25620
movq %rcx, (%rax)
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x11fb8
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x13a5a
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x38, %edi
callq 0x5280
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
xorl %ecx, %ecx
movq %rcx, 0x30(%rax)
movq %rcx, 0x8(%rax)
movl $0x0, 0x10(%rax)
leaq 0x1204b(%rip), %rdx # 0x25ae0
movq %rdx, (%rax)
leaq 0x18(%rax), %rdi
leaq 0x28(%rax), %rdx
movq %rdx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movb $0x0, 0x28(%rax)
movq %rax, 0x8(%rsp)
movl $0x25, %esi
callq 0x5240
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movsbl %r15b, %esi
callq 0x5240
addq $0x90, %rbx
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rsp)
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x11fb8
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x13b02
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x13a5a
leaq 0x8(%rsp), %rdi
callq 0x16072
jmp 0x13a5a
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x13ba0
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x13ba0
jmp 0x13bba
jmp 0x13bba
jmp 0x13bba
jmp 0x13bba
jmp 0x13bba
jmp 0x13bba
jmp 0x13bba
jmp 0x13bba
jmp 0x13bba
jmp 0x13bba
jmp 0x13bba
jmp 0x13bba
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x13b62
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x553b
jmp 0x13bcd
jmp 0x13bba
jmp 0x13bba
jmp 0x13bba
jmp 0x13bba
jmp 0x13bba
jmp 0x13bba
jmp 0x13bba
jmp 0x13bba
jmp 0x13bba
jmp 0x13bba
jmp 0x13bba
jmp 0x13bba
jmp 0x13bba
jmp 0x13bba
jmp 0x13bba
jmp 0x13bba
jmp 0x13bba
jmp 0x13bba
jmp 0x13bba
jmp 0x13bba
jmp 0x13bba
movq %rax, %rbx
movq 0x8(%rsp), %rsi
testq %rsi, %rsi
je 0x13bcd
leaq 0x8(%rsp), %rdi
callq 0x16072
jmp 0x13bcd
jmp 0x13bba
jmp 0x13bba
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x13bcd
movq (%rdi), %rax
callq *0x8(%rax)
movq %rbx, %rdi
callq 0x5400
nop
| /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, dest);
}
else
{
fmt_helper::append_string_view(level_name, dest);
}
} | 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
callq 0x1400a
testq %r15, %r15
je 0x13db7
movq 0x10(%rbx), %r12
addq %r14, %r12
cmpq %r12, 0x18(%rbx)
jae 0x13d9b
movq (%rbx), %rax
movq %rbx, %rdi
movq %r12, %rsi
callq *(%rax)
testq %r14, %r14
je 0x13db3
movq 0x8(%rbx), %rdi
addq 0x10(%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x53b0
movq %r12, 0x10(%rbx)
movq %rsp, %rdi
callq 0x13cc0
jmp 0x13e01
movq (%rax), %r14
testq %r14, %r14
je 0x13e01
movq 0x8(%rax), %r12
movq 0x10(%rbx), %r15
addq %r12, %r15
cmpq %r15, 0x18(%rbx)
jae 0x13de5
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *(%rax)
testq %r12, %r12
je 0x13dfd
movq 0x8(%rbx), %rdi
addq 0x10(%rbx), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x53b0
movq %r15, 0x10(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x13cc0
movq %rbx, %rdi
callq 0x5400
| /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, dest);
}
else
{
fmt_helper::append_int(msg.thread_id, dest);
}
} | 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 # imm = 0x13911
shrl $0xc, %eax
leaq 0x6c86(%rip), %rcx # 0x1aba0
cmpq (%rcx,%rax,8), %rsi
sbbl $-0x1, %eax
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
movq %rbx, %rcx
callq 0x1400a
movq 0x18(%r14), %rsi
leaq 0x30(%rsp), %r15
movq %r15, %rdi
callq 0x12b1e
movq %rax, %r14
movq %rax, 0x18(%r15)
leaq 0x45(%rsp), %r13
movq %r13, %r12
subq %rax, %r12
movq 0x10(%rbx), %r15
addq %r12, %r15
cmpq %r15, 0x18(%rbx)
jae 0x13f6c
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *(%rax)
cmpq %r14, %r13
je 0x13f84
movq 0x8(%rbx), %rdi
addq 0x10(%rbx), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x53b0
movq %r15, 0x10(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x13cc0
jmp 0x13fe7
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x12b1e
movq %rax, %r14
movq %rax, 0x18(%r15)
leaq 0x1d(%rsp), %r13
movq %r13, %r12
subq %rax, %r12
movq 0x10(%rbx), %r15
addq %r12, %r15
cmpq %r15, 0x18(%rbx)
jae 0x13fcb
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *(%rax)
cmpq %r14, %r13
je 0x13fe3
movq 0x8(%rbx), %rdi
addq 0x10(%rbx), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x53b0
movq %r15, 0x10(%rbx)
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x13cc0
movq %rbx, %rdi
callq 0x5400
| /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
movq 0x10(%rbx), %r12
addq %r15, %r12
cmpq %r12, 0x18(%rbx)
jae 0x141c2
movq (%rbx), %rax
movq %rbx, %rdi
movq %r12, %rsi
callq *(%rax)
testq %r15, %r15
je 0x141da
movq 0x8(%rbx), %rdi
addq 0x10(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x53b0
movq %r12, 0x10(%rbx)
movq %rsp, %rdi
callq 0x13cc0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x13cc0
movq %rbx, %rdi
callq 0x5400
nop
| /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
movq 0x10(%rbx), %r12
addq %r15, %r12
cmpq %r12, 0x18(%rbx)
jae 0x1430e
movq (%rbx), %rax
movq %rbx, %rdi
movq %r12, %rsi
callq *(%rax)
testq %r15, %r15
je 0x14326
movq 0x8(%rbx), %rdi
addq 0x10(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x53b0
movq %r12, 0x10(%rbx)
movq %rsp, %rdi
callq 0x13cc0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x13cc0
movq %rbx, %rdi
callq 0x5400
nop
| /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
movq 0x10(%rbx), %r12
addq %r15, %r12
cmpq %r12, 0x18(%rbx)
jae 0x143b4
movq (%rbx), %rax
movq %rbx, %rdi
movq %r12, %rsi
callq *(%rax)
testq %r15, %r15
je 0x143cc
movq 0x8(%rbx), %rdi
addq 0x10(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x53b0
movq %r12, 0x10(%rbx)
movq %rsp, %rdi
callq 0x13cc0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x13cc0
movq %rbx, %rdi
callq 0x5400
nop
| /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
{
dest.push_back('0');
dest.push_back(static_cast<char>('0' + n));
}
else // negatives (unlikely, but just in case, let fmt deal with it)
{
fmt::format_to(dest, "{:02}", n);
}
} | 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
addq %r12, %r15
cmpq %r15, 0x18(%rbx)
jae 0x1474c
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *(%rax)
cmpq %r14, %r13
je 0x14764
movq 0x8(%rbx), %rdi
addq 0x10(%rbx), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x53b0
movq %r15, 0x10(%rbx)
jmp 0x14818
cmpl $0xa, %ebp
jl 0x147be
movl %ebp, %eax
movl $0xcccccccd, %r14d # imm = 0xCCCCCCCD
imulq %rax, %r14
shrq $0x23, %r14
leal (%r14,%r14), %eax
leal (%rax,%rax,4), %eax
subl %eax, %ebp
addb $0x30, %r14b
movq 0x10(%rbx), %rsi
incq %rsi
cmpq %rsi, 0x18(%rbx)
jae 0x147a4
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%rbx)
movb %r14b, (%rax,%rcx)
orb $0x30, %bpl
jmp 0x147ef
testl %ebp, %ebp
js 0x14827
movq 0x10(%rbx), %rsi
incq %rsi
cmpq %rsi, 0x18(%rbx)
jae 0x147d7
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%rbx)
movb $0x30, (%rax,%rcx)
addb $0x30, %bpl
movq 0x10(%rbx), %rsi
incq %rsi
cmpq %rsi, 0x18(%rbx)
jae 0x14804
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%rbx)
movb %bpl, (%rax,%rcx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, %eax
movq %rsp, %r8
movq %rax, (%r8)
leaq 0x5e2c(%rip), %rsi # 0x1a662
movl $0x5, %edx
movl $0x2, %ecx
movq %rbx, %rdi
xorl %r9d, %r9d
callq 0x61c0
jmp 0x14818
nop
| /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
movq %rax, 0x18(%r14)
cmpl $0xfffff893, %r15d # imm = 0xFFFFF893
jg 0x14929
movq %rax, %rcx
decq %rcx
movq %rcx, 0x20(%rsp)
movb $0x2d, -0x1(%rax)
leaq 0x1d(%rsp), %r13
movq 0x3(%r13), %r15
movq %r13, %r12
subq %r15, %r12
movq 0x10(%rbx), %r14
addq %r12, %r14
cmpq %r14, 0x18(%rbx)
jae 0x14950
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *(%rax)
cmpq %r15, %r13
je 0x14968
movq 0x8(%rbx), %rdi
addq 0x10(%rbx), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x53b0
movq %r14, 0x10(%rbx)
leaq 0x28(%rsp), %rdi
callq 0x13cc0
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x13cc0
movq %rbx, %rdi
callq 0x5400
nop
| /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);
dest.push_back(':');
fmt_helper::pad2(tm_time.tm_sec, 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), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%rbx)
movb $0x3a, (%rax,%rcx)
movl 0x4(%r14), %edi
movq %rbx, %rsi
callq 0x146fd
movq 0x10(%rbx), %rsi
incq %rsi
cmpq %rsi, 0x18(%rbx)
jae 0x15792
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%rbx)
movb $0x3a, (%rax,%rcx)
movl (%r14), %edi
movq %rbx, %rsi
callq 0x146fd
movq %rsp, %rdi
callq 0x13cc0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x157c5
jmp 0x157c5
movq %rax, %rbx
movq %rsp, %rdi
callq 0x13cc0
movq %rbx, %rdi
callq 0x5400
| /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,
// it is very fast (already stored in tm.tm_gmtoff)
(void)(msg);
int total_minutes = os::utc_minutes_offset(tm_time);
#endif
bool is_negative = total_minutes < 0;
if (is_negative)
{
total_minutes = -total_minutes;
dest.push_back('-');
}
else
{
dest.push_back('+');
}
fmt_helper::pad2(total_minutes / 60, dest); // hours
dest.push_back(':');
fmt_helper::pad2(total_minutes % 60, dest); // minutes
} | 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 $0x3f, %rcx
shrq $0x5, %r14
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rax
incq %rsi
addl %ecx, %r14d
js 0x1585c
cmpq %rsi, %rax
jae 0x15846
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%rbx)
movb $0x2b, (%rax,%rcx)
jmp 0x15880
cmpq %rsi, %rax
jae 0x15869
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%rbx)
movb $0x2d, (%rax,%rcx)
negl %r14d
movl %r14d, %eax
movl $0x88888889, %r15d # imm = 0x88888889
imulq %rax, %r15
shrq $0x25, %r15
movl %r15d, %edi
movq %rbx, %rsi
callq 0x146fd
movq 0x10(%rbx), %rsi
incq %rsi
cmpq %rsi, 0x18(%rbx)
jae 0x158b1
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
imull $0x3c, %r15d, %eax
subl %eax, %r14d
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%rbx)
movb $0x3a, (%rax,%rcx)
movl %r14d, %edi
movq %rbx, %rsi
callq 0x146fd
leaq 0x8(%rsp), %rdi
callq 0x13cc0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x158f1
jmp 0x158f1
jmp 0x158f1
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x13cc0
movq %rbx, %rdi
callq 0x5400
| /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);
fmt_helper::append_int(pid, dest);
}
else
{
fmt_helper::append_int(pid, 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 # imm = 0x9EF1
shrl $0xc, %esi
leaq 0x5145(%rip), %rax # 0x1aaa0
cmpl (%rax,%rsi,4), %ebp
sbbl $0x0, %esi
incl %esi
movq %rsp, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1400a
movl %ebp, %esi
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x12b1e
movq %rax, %r14
movq %rax, 0x18(%r15)
leaq 0x3d(%rsp), %r13
movq %r13, %r12
subq %rax, %r12
movq 0x10(%rbx), %r15
addq %r12, %r15
cmpq %r15, 0x18(%rbx)
jae 0x159aa
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *(%rax)
cmpq %r14, %r13
je 0x159c2
movq 0x8(%rbx), %rdi
addq 0x10(%rbx), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x53b0
movq %r15, 0x10(%rbx)
movq %rsp, %rdi
callq 0x13cc0
jmp 0x15a23
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
addq %r12, %r15
cmpq %r15, 0x18(%rbx)
jae 0x15a07
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *(%rax)
cmpq %r14, %r13
je 0x15a1f
movq 0x8(%rbx), %rdi
addq 0x10(%rbx), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x53b0
movq %r15, 0x10(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x13cc0
movq %rbx, %rdi
callq 0x5400
nop
| /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
movl %eax, %ecx
orl $0x1, %ecx
bsrl %ecx, %ecx
xorl $-0x20, %ecx
imull $0x4d1, %ecx, %ecx # imm = 0x4D1
addl $0x9ef1, %ecx # imm = 0x9EF1
shrl $0xc, %ecx
leaq 0x4fc2(%rip), %rdx # 0x1aaa0
cmpl (%rdx,%rcx,4), %eax
sbbl $-0x1, %ecx
leaq (%r15,%rcx), %rsi
incq %rsi
movq %rsp, %rdi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1400a
movq 0x38(%r14), %r15
movq %r15, %rdi
callq 0x5120
testq %r15, %r15
je 0x15b41
movq %rax, %r12
movq 0x10(%rbx), %r13
addq %rax, %r13
cmpq %r13, 0x18(%rbx)
jae 0x15b25
movq (%rbx), %rax
movq %rbx, %rdi
movq %r13, %rsi
callq *(%rax)
testq %r12, %r12
je 0x15b3d
movq 0x8(%rbx), %rdi
addq 0x10(%rbx), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x53b0
movq %r13, 0x10(%rbx)
movq 0x10(%rbx), %rsi
incq %rsi
cmpq %rsi, 0x18(%rbx)
jae 0x15b56
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%rbx)
movb $0x3a, (%rax,%rcx)
movl 0x40(%r14), %esi
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x12b1e
movq %rax, %r14
movq %rax, 0x18(%r15)
leaq 0x3d(%rsp), %r13
movq %r13, %r12
subq %rax, %r12
movq 0x10(%rbx), %r15
addq %r12, %r15
cmpq %r15, 0x18(%rbx)
jae 0x15ba5
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *(%rax)
cmpq %r14, %r13
je 0x15bbd
movq 0x8(%rbx), %rdi
addq 0x10(%rbx), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x53b0
movq %r15, 0x10(%rbx)
movq %rsp, %rdi
callq 0x13cc0
jmp 0x15c85
testq %r13, %r13
je 0x15c07
movq 0x10(%rbx), %r12
addq %r15, %r12
cmpq %r12, 0x18(%rbx)
jae 0x15beb
movq (%rbx), %rax
movq %rbx, %rdi
movq %r12, %rsi
callq *(%rax)
testq %r15, %r15
je 0x15c03
movq 0x8(%rbx), %rdi
addq 0x10(%rbx), %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x53b0
movq %r12, 0x10(%rbx)
movq 0x10(%rbx), %rsi
incq %rsi
cmpq %rsi, 0x18(%rbx)
jae 0x15c1c
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x10(%rbx)
movb $0x3a, (%rax,%rcx)
movl 0x40(%r14), %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
addq %r12, %r15
cmpq %r15, 0x18(%rbx)
jae 0x15c69
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *(%rax)
cmpq %r14, %r13
je 0x15c81
movq 0x8(%rbx), %rdi
addq 0x10(%rbx), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x53b0
movq %r15, 0x10(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x15c96
movq %rax, %rbx
movq %rsp, %rdi
callq 0x13cc0
movq %rbx, %rdi
callq 0x5400
nop
| /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();
break;
case color_mode::never:
should_do_colors_ = false;
break;
}
} | 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 0x16e8b
movb 0xf541(%rip), %al # 0x263c0
testb %al, %al
je 0x16e9f
movb 0xf52f(%rip), %al # 0x263b8
jmp 0x16e91
xorl %eax, %eax
jmp 0x16e91
movb $0x1, %al
movb %al, 0x328(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0xf51a(%rip), %rdi # 0x263c0
callq 0x5420
testl %eax, %eax
je 0x16e83
leaq 0xed5a(%rip), %rdi # 0x25c10
leaq 0xedc3(%rip), %r14 # 0x25c80
movq %rsp, %rdx
movq %r14, %rsi
callq 0x175b5
cmpq %r14, %rax
setne 0xf4e6(%rip) # 0x263b8
leaq 0xf4e7(%rip), %rdi # 0x263c0
callq 0x51c0
jmp 0x16e83
movq %rax, %rdi
callq 0x5bc8
| /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);
if (should_do_colors_ && msg.color_range_end > msg.color_range_start)
{
// before color range
print_range_(formatted, 0, msg.color_range_start);
// in color range
print_ccode_(colors_[msg.level]);
print_range_(formatted, msg.color_range_start, msg.color_range_end);
print_ccode_(reset);
// after color range
print_range_(formatted, msg.color_range_end, formatted.size());
}
else // no color
{
print_range_(formatted, 0, formatted.size());
}
fflush(target_file_);
} | 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
movq %r13, -0x20(%r12)
movq %r12, -0x18(%r12)
movq $0x1f4, -0x8(%r12) # imm = 0x1F4
movq 0x10(%r14), %rdi
movq (%rdi), %rax
leaq 0x8(%rsp), %rdx
movq %r15, %rsi
callq *0x10(%rax)
cmpb $0x1, 0x328(%r14)
jne 0x1735c
movq 0x28(%r15), %rdx
cmpq %rdx, 0x30(%r15)
jbe 0x1735c
movq 0x10(%rsp), %rdi
movq 0x318(%r14), %rcx
movl $0x1, %esi
callq 0x5470
leaq 0x330(%r14), %rdi
leaq 0x8(%r15), %rsi
callq 0x17a84
movq (%rax), %rdi
movq 0x8(%rax), %rdx
movq 0x318(%r14), %rcx
movl $0x1, %esi
callq 0x5470
movq 0x28(%r15), %rax
movq 0x30(%r15), %rdx
movq 0x10(%rsp), %rdi
addq %rax, %rdi
subq %rax, %rdx
movq 0x318(%r14), %rcx
movl $0x1, %esi
callq 0x5470
movq 0x18(%r14), %rdi
movq 0x20(%r14), %rdx
movq 0x318(%r14), %rcx
movl $0x1, %esi
callq 0x5470
movq 0x30(%r15), %rax
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rdi
addq %rax, %rdi
subq %rax, %rdx
jmp 0x17366
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
movq 0x318(%r14), %rcx
movl $0x1, %esi
callq 0x5470
movq 0x318(%r14), %rdi
callq 0x52e0
movq %r13, 0x8(%rsp)
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x1739c
movq 0x20(%rsp), %rsi
callq 0x5290
movq %rbx, %rdi
callq 0x5200
addq $0x220, %rsp # imm = 0x220
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl %eax, %edi
callq 0x51d0
movq %rax, %r14
movq %r13, 0x8(%rsp)
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x173d8
movq 0x20(%rsp), %rsi
callq 0x5290
movq %rbx, %rdi
callq 0x5200
movq %r14, %rdi
callq 0x5400
| /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 %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x12e7e
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2eda(%rip), %rsi # 0x1a365
leaq 0x2ed4(%rip), %rdx # 0x1a366
movq %rsp, %rdi
callq 0x1174c
leaq 0x20(%rsp), %rsi
movq %rsp, %rcx
movq %r14, %rdi
xorl %edx, %edx
callq 0x12d70
movq 0x10(%r15), %rdi
movq %r14, 0x10(%r15)
testq %rdi, %rdi
je 0x174bf
movq (%rdi), %rax
callq *0x8(%rax)
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x174d5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5290
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x174ec
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x5290
movq %rbx, %rdi
callq 0x5200
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl %eax, %edi
callq 0x51d0
movq %rax, %r15
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x17527
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5290
jmp 0x17527
movq %rax, %r15
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x17543
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x5290
jmp 0x17543
movq %rax, %r15
movl $0xa8, %esi
movq %r14, %rdi
callq 0x5290
jmp 0x17555
movq %rax, %r15
movq %rbx, %rdi
callq 0x5200
movq %r15, %rdi
callq 0x5400
nop
| /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(level_);
new_logger->flush_on(flush_level_);
if (automatic_registration_)
{
register_logger_(std::move(new_logger));
}
} | 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
leaq 0x8(%rsp), %r15
movq (%r13), %r12
movq (%rsp), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *0x18(%rax)
movq (%r12), %rax
movq %r12, %rdi
movq %r15, %rsi
callq *0x28(%rax)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1861c
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
addq $0x10, %r13
cmpq %rbp, %r13
jne 0x185ee
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1863d
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rsp)
cmpq $0x0, 0xd0(%rbx)
je 0x18690
leaq 0xc0(%rbx), %rsi
movq (%r14), %r15
leaq 0x28(%rsp), %rdi
callq 0x116ee
addq $0x48, %r15
leaq 0x28(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x1165c
movq 0x10(%r12), %rax
testq %rax, %rax
je 0x18690
leaq 0x28(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq (%r14), %rax
movl 0xb8(%rbx), %ecx
xchgl %ecx, 0x40(%rax)
movq (%r14), %rax
movl 0xbc(%rbx), %ecx
xchgl %ecx, 0x44(%rax)
cmpb $0x1, 0x108(%rbx)
jne 0x186e1
xorl %eax, %eax
leaq 0x10(%rsp), %rsi
movq %rax, 0x8(%rsi)
movups (%r14), %xmm0
movq %rax, 0x8(%r14)
movaps %xmm0, (%rsi)
movq %rax, (%r14)
movq %rbx, %rdi
callq 0x1983c
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x186e1
callq 0x5bd4
movq %rbx, %rdi
callq 0x5200
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %edi
callq 0x51d0
movq %rax, %rdi
callq 0x5bc8
movq %rax, %r14
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x18758
callq 0x5bd4
jmp 0x18758
movq %rax, %r14
jmp 0x18758
movq %rax, %r14
jmp 0x18741
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x18738
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x18750
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rsp)
movq %rbx, %rdi
callq 0x5200
movq %r14, %rdi
callq 0x5400
| /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, %rdi
je 0x18d76
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x5200
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl %eax, %edi
callq 0x51d0
movq %rax, %r14
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x18dab
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x5200
movq %r14, %rdi
callq 0x5400
| /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(%rsp), %r12
movups %xmm0, -0x18(%r12)
leaq 0xbfb7(%rip), %rax # 0x24fc8
movq %rax, -0x20(%r12)
movq %r12, -0x18(%r12)
movq $0x1f4, -0x8(%r12) # imm = 0x1F4
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movl %edx, %esi
movq %rax, %rdx
callq 0x19125
movq 0x8(%r15), %rsi
leaq 0x10(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq 0x10(%r15), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x1174c
movq %rsp, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5310
movq (%rbx), %rdi
cmpq %rbp, %rdi
je 0x1907c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x5290
leaq 0xbf45(%rip), %rax # 0x24fc8
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x1909c
movq 0x38(%rsp), %rsi
callq 0x5290
addq $0x238, %rsp # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
leaq 0xbf10(%rip), %rax # 0x24fc8
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x190d1
movq 0x38(%rsp), %rsi
callq 0x5290
movq (%r14), %rdi
cmpq %r13, %rdi
je 0x190e5
movq (%r13), %rsi
incq %rsi
callq 0x5290
movq %rbx, %rdi
callq 0x5440
movq %r15, %rdi
callq 0x5400
nop
| /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 (result == 0) {
writer w(out);
w.write(message);
w.write(": ");
w.write(system_message);
return;
}
if (result != ERANGE)
break; // Can't get error message, report error code instead.
buf.resize(buf.size() * 2);
}
} | 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, -0x18(%rcx)
movl $0x1f4, %eax # imm = 0x1F4
movq %rax, -0x8(%rcx)
movq %rax, -0x10(%rcx)
movq 0x18(%rsp), %rbp
movq 0x20(%rsp), %r13
movl %ebx, %edi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x50a0
movq %rax, %r15
cmpq %rax, %rbp
jne 0x191a0
movq %rbp, %rdi
callq 0x5120
decq %r13
movl $0x22, %ecx
cmpq %r13, %rax
je 0x191a5
xorl %ecx, %ecx
movq %r15, %rbp
cmpl $0x22, %ecx
je 0x1926f
testl %ecx, %ecx
jne 0x1929a
movq 0x10(%r12), %r13
movq (%rsp), %rax
leaq (%rax,%r13), %r15
cmpq %r15, 0x18(%r12)
jae 0x191d6
movq (%r12), %rax
movq %r12, %rdi
movq %r15, %rsi
callq *(%rax)
movq %r15, 0x10(%r12)
movq (%rsp), %rdx
testq %rdx, %rdx
je 0x191f6
addq 0x8(%r12), %r13
movq %r13, %rdi
movq 0x8(%rsp), %rsi
callq 0x53b0
movq 0x10(%r12), %r14
leaq 0x2(%r14), %r15
cmpq %r15, 0x18(%r12)
jae 0x19212
movq (%r12), %rax
movq %r12, %rdi
movq %r15, %rsi
callq *(%rax)
movq %r15, 0x10(%r12)
movq 0x8(%r12), %rax
movw $0x203a, (%rax,%r14) # imm = 0x203A
movq %rbp, %rdi
callq 0x5120
movq %rax, %r13
movq 0x10(%r12), %r15
leaq (%r15,%rax), %r14
cmpq %r14, 0x18(%r12)
jae 0x1924a
movq (%r12), %rax
movq %r12, %rdi
movq %r14, %rsi
callq *(%rax)
movq %r14, 0x10(%r12)
movl $0x1, %r14d
testq %r13, %r13
je 0x192a0
addq 0x8(%r12), %r15
movq %r15, %rdi
movq %rbp, %rsi
movq %r13, %rdx
callq 0x53b0
jmp 0x192a0
movq 0x20(%rsp), %r15
addq %r15, %r15
cmpq %r15, 0x28(%rsp)
jae 0x1928d
movq 0x10(%rsp), %rax
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq *(%rax)
movq %r15, 0x20(%rsp)
xorl %r14d, %r14d
movb $0x1, %bpl
jmp 0x192a2
movl $0x2, %r14d
xorl %ebp, %ebp
testl %r14d, %r14d
je 0x1916c
cmpl $0x2, %r14d
jne 0x192b4
movb $0x1, %bpl
leaq 0xbd0d(%rip), %rax # 0x24fc8
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
movq (%rsp), %r14
je 0x192dd
movq 0x28(%rsp), %rsi
callq 0x5290
testb %bpl, %bpl
je 0x193dc
xorl %eax, %eax
movq %rax, 0x10(%r12)
movl %ebx, %ecx
negl %ecx
cmovsl %ebx, %ecx
movl %ecx, %edx
orl $0x1, %edx
bsrl %edx, %edx
xorl $-0x20, %edx
imull $0x4d1, %edx, %edx # imm = 0x4D1
addl $0x9ef1, %edx # imm = 0x9EF1
shrl $0xc, %edx
leaq 0x178b(%rip), %rsi # 0x1aaa0
cmpl (%rsi,%rdx,4), %ecx
sbbl $0x0, %edx
incl %edx
movq %r12, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movl %ebx, %eax
shrl $0x1f, %eax
addq %rdx, %rax
movl $0x1ec, %ecx # imm = 0x1EC
subq %rax, %rcx
cmpq %r14, %rcx
jb 0x19399
cmpq %r14, 0x18(%r12)
jae 0x1934f
movq (%r12), %rax
movq %r12, %rdi
movq %r14, %rsi
callq *(%rax)
movq %r14, 0x10(%r12)
testq %r14, %r14
je 0x1936b
movq 0x8(%r12), %rdi
movq 0x8(%rsp), %rsi
movq %r14, %rdx
callq 0x53b0
movq 0x10(%rsp), %r14
movq 0x10(%r14), %r12
leaq 0x2(%r12), %r15
cmpq %r15, 0x18(%r14)
jae 0x1938a
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *(%rax)
movq %r15, 0x10(%r14)
movq 0x8(%r14), %rax
movw $0x203a, (%rax,%r12) # imm = 0x203A
movq 0x10(%rsp), %r14
movq 0x10(%r14), %r12
leaq 0x6(%r12), %r15
cmpq %r15, 0x18(%r14)
jae 0x193b8
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *(%rax)
movq %r15, 0x10(%r14)
movq 0x8(%r14), %rax
movw $0x2072, 0x4(%rax,%r12) # imm = 0x2072
movl $0x6f727265, (%rax,%r12) # imm = 0x6F727265
leaq 0x10(%rsp), %rdi
movl %ebx, %esi
callq 0x81fa
addq $0x228, %rsp # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rdi
callq 0x5bc8
jmp 0x193f8
movq %rax, %r15
leaq 0xbbc6(%rip), %rax # 0x24fc8
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x19420
movq 0x28(%rsp), %rsi
callq 0x5290
movq %r15, %rdi
callq 0x5110
callq 0x53c0
movq (%rsp), %r14
jmp 0x192e6
jmp 0x193ee
| /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 $0x78, %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x19b12
movups (%rbx), %xmm0
xorps %xmm1, %xmm1
movups %xmm1, (%rbx)
movq 0x8(%rax), %rdi
movups %xmm0, (%rax)
testq %rdi, %rdi
je 0x198a8
callq 0x5bd4
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x198bf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5290
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x198e5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5290
movq %rbx, %rdi
callq 0x5400
nop
| /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
jmp 0x44638
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0x44b90
jmp 0x44647
movb $0x1, -0x1(%rbp)
movl $0x1, -0x38(%rbp)
jmp 0x44689
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x4469d
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x50, %esi
callq 0x37410
jmp 0x4469d
movb $0x0, -0x1(%rbp)
movl $0x1, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x377f8
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x377f8
movq -0x30(%rbp), %rdi
callq 0x37710
nop
| /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::allocator<char>> const&, char const*, unsigned long, char const*, int) | 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(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0x2c(%rbp), %ecx
callq 0x5b520
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0x53130
movq -0x88(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x37720
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x38530
jmp 0x5b3d9
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdi
movq -0x98(%rbp), %rcx
addq $0xc8, %rcx
leaq -0x50(%rbp), %rdx
callq 0x53170
jmp 0x5b3fd
leaq -0x50(%rbp), %rdi
callq 0x377f8
leaq -0x51(%rbp), %rdi
callq 0x37460
movq -0x98(%rbp), %rdi
addq $0xc8, %rdi
movq %rdi, -0xa0(%rbp)
callq 0x5b560
movq -0x98(%rbp), %rdi
addq $0xd0, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
incq %rcx
movq -0x28(%rbp), %r8
movl -0x2c(%rbp), %r9d
callq 0x5b5a0
jmp 0x5b455
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x5b481
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x377f8
leaq -0x51(%rbp), %rdi
callq 0x37460
jmp 0x5b4ad
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
callq 0x3d1c0
movq -0x80(%rbp), %rdi
callq 0x3c6e0
movq -0x90(%rbp), %rdi
callq 0x3c740
movq -0x60(%rbp), %rdi
callq 0x37710
nopw %cs:(%rax,%rax)
nopl (%rax)
| /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>> const&, char const*, unsigned long, char const*, int) | 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(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0x2c(%rbp), %ecx
callq 0x5be80
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0x53130
movq -0x88(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x37720
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x38530
jmp 0x5b639
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdi
movq -0x98(%rbp), %rcx
addq $0xc8, %rcx
leaq -0x50(%rbp), %rdx
callq 0x53170
jmp 0x5b65d
leaq -0x50(%rbp), %rdi
callq 0x377f8
leaq -0x51(%rbp), %rdi
callq 0x37460
movq -0x98(%rbp), %rdi
addq $0xc8, %rdi
movq %rdi, -0xa0(%rbp)
callq 0x5bec0
movq -0x98(%rbp), %rdi
addq $0xd0, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
incq %rcx
movq -0x28(%rbp), %r8
movl -0x2c(%rbp), %r9d
callq 0x5bf00
jmp 0x5b6b5
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x5b6e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x377f8
leaq -0x51(%rbp), %rdi
callq 0x37460
jmp 0x5b70d
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
callq 0x3d220
movq -0x80(%rbp), %rdi
callq 0x3c6e0
movq -0x90(%rbp), %rdi
callq 0x3c740
movq -0x60(%rbp), %rdi
callq 0x37710
nopw %cs:(%rax,%rax)
nopl (%rax)
| /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_TYPED_TEST_APPEND_TYPENAME
detail::MakeIndexTypedTestName<TypeParam>(testsuite, index)
#else
detail::MakeIndexTestName(testsuite, index)
#endif
, internal::GetTypeId<detail::None>() // TypeId を統一するためダミー引数を渡す
, IUTEST_GET_SETUP_TESTSUITE(TestBody, file, line)
, IUTEST_GET_TEARDOWN_TESTSUITE(TestBody, file, line)
#if defined(IUTEST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS)
, detail::explicit_type<_MyTestSuite>()
#endif
);
} | 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 -0x1c(%rbp), %esi
callq 0x5b7f0
movq %rax, -0x58(%rbp)
jmp 0x5b77f
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x5b9a0
movq %rax, -0x70(%rbp)
jmp 0x5b791
movq -0x70(%rbp), %r8
movq -0x58(%rbp), %rcx
movq -0x60(%rbp), %rdx
movq -0x68(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x53550
movq %rax, -0x78(%rbp)
jmp 0x5b7b0
leaq -0x40(%rbp), %rdi
callq 0x377f8
movq -0x78(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x377f8
movq -0x48(%rbp), %rdi
callq 0x37710
nopw %cs:(%rax,%rax)
nop
| /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);
IUTEST_CHECK_( testcase == NULL || testsuite == NULL )
<< "Test can not provide both SetUpTestSuite and SetUpTestCase, please make sure there is only one present at "
<< detail::FormatCompilerIndependentFileLocation(file, line);
return testcase != NULL ? testcase : testsuite;
} | 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 %eax, %eax
jne 0x5b835
jmp 0x5b833
jmp 0x5b835
movb $0x1, %al
cmpq $0x0, -0x18(%rbp)
movb %al, -0x1e1(%rbp)
je 0x5b852
cmpq $0x0, -0x20(%rbp)
sete %al
movb %al, -0x1e1(%rbp)
movb -0x1e1(%rbp), %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x54ae0
testb $0x1, %al
jne 0x5b957
leaq 0x7e6d(%rip), %rdx # 0x636df
leaq -0x1b0(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
movl $0x3, %esi
movl $0x4b, %ecx
callq 0x446f0
movq -0x1f8(%rbp), %rdi
callq 0x44870
movq %rax, %rdi
addq $0x10, %rdi
leaq 0x7e95(%rip), %rsi # 0x6373e
callq 0x373e0
movq %rax, -0x1f0(%rbp)
jmp 0x5b8b7
movq -0x1f0(%rbp), %rdi
leaq 0x7eb2(%rip), %rsi # 0x63777
callq 0x373e0
movq %rax, -0x200(%rbp)
jmp 0x5b8d3
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
leaq -0x1e0(%rbp), %rdi
callq 0x50280
jmp 0x5b8e8
movq -0x200(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
callq 0x373a0
jmp 0x5b8fd
leaq -0x1e0(%rbp), %rdi
callq 0x377f8
leaq -0x1b0(%rbp), %rdi
callq 0x448a0
jmp 0x5b957
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
jmp 0x5b949
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0x377f8
leaq -0x1b0(%rbp), %rdi
callq 0x448a0
jmp 0x5b988
jmp 0x5b959
cmpq $0x0, -0x18(%rbp)
je 0x5b96d
movq -0x18(%rbp), %rax
movq %rax, -0x208(%rbp)
jmp 0x5b978
movq -0x20(%rbp), %rax
movq %rax, -0x208(%rbp)
movq -0x208(%rbp), %rax
addq $0x210, %rsp # imm = 0x210
popq %rbp
retq
movq -0x1b8(%rbp), %rdi
callq 0x37710
nopw %cs:(%rax,%rax)
nop
| /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::TearDownTestSuite);
IUTEST_CHECK_( testcase == NULL || testsuite == NULL )
<< "Test can not provide both TearDownTestSuite and TearDownTestCase, please make sure there is only one present at "
<< detail::FormatCompilerIndependentFileLocation(file, line);
return testcase != NULL ? testcase : testsuite;
} | 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 %eax, %eax
jne 0x5b9e5
jmp 0x5b9e3
jmp 0x5b9e5
movb $0x1, %al
cmpq $0x0, -0x18(%rbp)
movb %al, -0x1e1(%rbp)
je 0x5ba02
cmpq $0x0, -0x20(%rbp)
sete %al
movb %al, -0x1e1(%rbp)
movb -0x1e1(%rbp), %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x54ae0
testb $0x1, %al
jne 0x5bb07
leaq 0x7cbd(%rip), %rdx # 0x636df
leaq -0x1b0(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
movl $0x3, %esi
movl $0x56, %ecx
callq 0x446f0
movq -0x1f8(%rbp), %rdi
callq 0x44870
movq %rax, %rdi
addq $0x10, %rdi
leaq 0x7ce5(%rip), %rsi # 0x6373e
callq 0x373e0
movq %rax, -0x1f0(%rbp)
jmp 0x5ba67
movq -0x1f0(%rbp), %rdi
leaq 0x7d6d(%rip), %rsi # 0x637e2
callq 0x373e0
movq %rax, -0x200(%rbp)
jmp 0x5ba83
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
leaq -0x1e0(%rbp), %rdi
callq 0x50280
jmp 0x5ba98
movq -0x200(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
callq 0x373a0
jmp 0x5baad
leaq -0x1e0(%rbp), %rdi
callq 0x377f8
leaq -0x1b0(%rbp), %rdi
callq 0x448a0
jmp 0x5bb07
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
jmp 0x5baf9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0x377f8
leaq -0x1b0(%rbp), %rdi
callq 0x448a0
jmp 0x5bb38
jmp 0x5bb09
cmpq $0x0, -0x18(%rbp)
je 0x5bb1d
movq -0x18(%rbp), %rax
movq %rax, -0x208(%rbp)
jmp 0x5bb28
movq -0x20(%rbp), %rax
movq %rax, -0x208(%rbp)
movq -0x208(%rbp), %rax
addq $0x210, %rsp # imm = 0x210
popq %rbp
retq
movq -0x1b8(%rbp), %rdi
callq 0x37710
nopw %cs:(%rax,%rax)
nop
| /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 0x5bcf1
jmp 0x5bcef
jmp 0x5bcf1
movss -0xc(%rbp), %xmm0
divss -0x10(%rbp), %xmm0
leaq -0x3c(%rbp), %rdi
callq 0x58660
leaq -0x40(%rbp), %rdi
callq 0x5be40
leaq -0x38(%rbp), %rdi
leaq 0x7b95(%rip), %rsi # 0x638ad
leaq 0x7bb3(%rip), %rdx # 0x638d2
leaq -0x3c(%rbp), %rcx
leaq -0x40(%rbp), %r8
callq 0x58610
leaq -0x38(%rbp), %rdi
callq 0x553e0
testb $0x1, %al
jne 0x5bd3b
jmp 0x5bd40
jmp 0x5be17
leaq -0x1c8(%rbp), %rdi
movq %rdi, -0x210(%rbp)
xorl %esi, %esi
movl $0x188, %edx # imm = 0x188
callq 0x371f0
movq -0x210(%rbp), %rdi
callq 0x4b740
jmp 0x5bd68
leaq -0x38(%rbp), %rdi
callq 0x55400
movq %rax, %rcx
leaq 0x5417(%rip), %rsi # 0x61192
leaq -0x208(%rbp), %rdi
movl $0x50, %edx
movl $0x1, %r8d
callq 0x4cd50
jmp 0x5bd94
leaq -0x208(%rbp), %rdi
leaq -0x1c8(%rbp), %rsi
callq 0x4cd90
jmp 0x5bda9
leaq -0x208(%rbp), %rdi
callq 0x4b780
leaq -0x1c8(%rbp), %rdi
callq 0x4b760
jmp 0x5be17
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
jmp 0x5be29
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
jmp 0x5be09
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1d0(%rbp)
movl %eax, -0x1d4(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x4b780
leaq -0x1c8(%rbp), %rdi
callq 0x4b760
jmp 0x5be29
leaq -0x38(%rbp), %rdi
callq 0x55420
addq $0x210, %rsp # imm = 0x210
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x55420
movq -0x1d0(%rbp), %rdi
callq 0x37710
nop
| /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&, char const*, unsigned long, char const*, int) | 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(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0x2c(%rbp), %ecx
callq 0x5c7e0
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0x53130
movq -0x88(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x37720
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x38530
jmp 0x5bf99
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdi
movq -0x98(%rbp), %rcx
addq $0xc8, %rcx
leaq -0x50(%rbp), %rdx
callq 0x53170
jmp 0x5bfbd
leaq -0x50(%rbp), %rdi
callq 0x377f8
leaq -0x51(%rbp), %rdi
callq 0x37460
movq -0x98(%rbp), %rdi
addq $0xc8, %rdi
movq %rdi, -0xa0(%rbp)
callq 0x5c820
movq -0x98(%rbp), %rdi
addq $0xd0, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
incq %rcx
movq -0x28(%rbp), %r8
movl -0x2c(%rbp), %r9d
callq 0x5c860
jmp 0x5c015
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x5c041
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x377f8
leaq -0x51(%rbp), %rdi
callq 0x37460
jmp 0x5c06d
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
callq 0x3d240
movq -0x80(%rbp), %rdi
callq 0x3c6e0
movq -0x90(%rbp), %rdi
callq 0x3c740
movq -0x60(%rbp), %rdi
callq 0x37710
nopw %cs:(%rax,%rax)
nopl (%rax)
| /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_TYPED_TEST_APPEND_TYPENAME
detail::MakeIndexTypedTestName<TypeParam>(testsuite, index)
#else
detail::MakeIndexTestName(testsuite, index)
#endif
, internal::GetTypeId<detail::None>() // TypeId を統一するためダミー引数を渡す
, IUTEST_GET_SETUP_TESTSUITE(TestBody, file, line)
, IUTEST_GET_TEARDOWN_TESTSUITE(TestBody, file, line)
#if defined(IUTEST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS)
, detail::explicit_type<_MyTestSuite>()
#endif
);
} | 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 -0x1c(%rbp), %esi
callq 0x5c150
movq %rax, -0x58(%rbp)
jmp 0x5c0df
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x5c300
movq %rax, -0x70(%rbp)
jmp 0x5c0f1
movq -0x70(%rbp), %r8
movq -0x58(%rbp), %rcx
movq -0x60(%rbp), %rdx
movq -0x68(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x55ec0
movq %rax, -0x78(%rbp)
jmp 0x5c110
leaq -0x40(%rbp), %rdi
callq 0x377f8
movq -0x78(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x377f8
movq -0x48(%rbp), %rdi
callq 0x37710
nopw %cs:(%rax,%rax)
nop
| /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);
IUTEST_CHECK_( testcase == NULL || testsuite == NULL )
<< "Test can not provide both SetUpTestSuite and SetUpTestCase, please make sure there is only one present at "
<< detail::FormatCompilerIndependentFileLocation(file, line);
return testcase != NULL ? testcase : testsuite;
} | 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 %eax, %eax
jne 0x5c195
jmp 0x5c193
jmp 0x5c195
movb $0x1, %al
cmpq $0x0, -0x18(%rbp)
movb %al, -0x1e1(%rbp)
je 0x5c1b2
cmpq $0x0, -0x20(%rbp)
sete %al
movb %al, -0x1e1(%rbp)
movb -0x1e1(%rbp), %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x54ae0
testb $0x1, %al
jne 0x5c2b7
leaq 0x750d(%rip), %rdx # 0x636df
leaq -0x1b0(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
movl $0x3, %esi
movl $0x4b, %ecx
callq 0x446f0
movq -0x1f8(%rbp), %rdi
callq 0x44870
movq %rax, %rdi
addq $0x10, %rdi
leaq 0x7535(%rip), %rsi # 0x6373e
callq 0x373e0
movq %rax, -0x1f0(%rbp)
jmp 0x5c217
movq -0x1f0(%rbp), %rdi
leaq 0x7552(%rip), %rsi # 0x63777
callq 0x373e0
movq %rax, -0x200(%rbp)
jmp 0x5c233
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
leaq -0x1e0(%rbp), %rdi
callq 0x50280
jmp 0x5c248
movq -0x200(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
callq 0x373a0
jmp 0x5c25d
leaq -0x1e0(%rbp), %rdi
callq 0x377f8
leaq -0x1b0(%rbp), %rdi
callq 0x448a0
jmp 0x5c2b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
jmp 0x5c2a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0x377f8
leaq -0x1b0(%rbp), %rdi
callq 0x448a0
jmp 0x5c2e8
jmp 0x5c2b9
cmpq $0x0, -0x18(%rbp)
je 0x5c2cd
movq -0x18(%rbp), %rax
movq %rax, -0x208(%rbp)
jmp 0x5c2d8
movq -0x20(%rbp), %rax
movq %rax, -0x208(%rbp)
movq -0x208(%rbp), %rax
addq $0x210, %rsp # imm = 0x210
popq %rbp
retq
movq -0x1b8(%rbp), %rdi
callq 0x37710
nopw %cs:(%rax,%rax)
nop
| /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::TearDownTestSuite);
IUTEST_CHECK_( testcase == NULL || testsuite == NULL )
<< "Test can not provide both TearDownTestSuite and TearDownTestCase, please make sure there is only one present at "
<< detail::FormatCompilerIndependentFileLocation(file, line);
return testcase != NULL ? testcase : testsuite;
} | 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 %eax, %eax
jne 0x5c345
jmp 0x5c343
jmp 0x5c345
movb $0x1, %al
cmpq $0x0, -0x18(%rbp)
movb %al, -0x1e1(%rbp)
je 0x5c362
cmpq $0x0, -0x20(%rbp)
sete %al
movb %al, -0x1e1(%rbp)
movb -0x1e1(%rbp), %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x54ae0
testb $0x1, %al
jne 0x5c467
leaq 0x735d(%rip), %rdx # 0x636df
leaq -0x1b0(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
movl $0x3, %esi
movl $0x56, %ecx
callq 0x446f0
movq -0x1f8(%rbp), %rdi
callq 0x44870
movq %rax, %rdi
addq $0x10, %rdi
leaq 0x7385(%rip), %rsi # 0x6373e
callq 0x373e0
movq %rax, -0x1f0(%rbp)
jmp 0x5c3c7
movq -0x1f0(%rbp), %rdi
leaq 0x740d(%rip), %rsi # 0x637e2
callq 0x373e0
movq %rax, -0x200(%rbp)
jmp 0x5c3e3
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
leaq -0x1e0(%rbp), %rdi
callq 0x50280
jmp 0x5c3f8
movq -0x200(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
callq 0x373a0
jmp 0x5c40d
leaq -0x1e0(%rbp), %rdi
callq 0x377f8
leaq -0x1b0(%rbp), %rdi
callq 0x448a0
jmp 0x5c467
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
jmp 0x5c459
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0x377f8
leaq -0x1b0(%rbp), %rdi
callq 0x448a0
jmp 0x5c498
jmp 0x5c469
cmpq $0x0, -0x18(%rbp)
je 0x5c47d
movq -0x18(%rbp), %rax
movq %rax, -0x208(%rbp)
jmp 0x5c488
movq -0x20(%rbp), %rax
movq %rax, -0x208(%rbp)
movq -0x208(%rbp), %rax
addq $0x210, %rsp # imm = 0x210
popq %rbp
retq
movq -0x1b8(%rbp), %rdi
callq 0x37710
nopw %cs:(%rax,%rax)
nop
| /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 0x5c651
jmp 0x5c64f
jmp 0x5c651
movsd -0x10(%rbp), %xmm0
divsd -0x18(%rbp), %xmm0
leaq -0x48(%rbp), %rdi
callq 0x59800
leaq -0x50(%rbp), %rdi
callq 0x5c7a0
leaq -0x40(%rbp), %rdi
leaq 0x7235(%rip), %rsi # 0x638ad
leaq 0x7253(%rip), %rdx # 0x638d2
leaq -0x48(%rbp), %rcx
leaq -0x50(%rbp), %r8
callq 0x597b0
leaq -0x40(%rbp), %rdi
callq 0x553e0
testb $0x1, %al
jne 0x5c69b
jmp 0x5c6a0
jmp 0x5c777
leaq -0x1d8(%rbp), %rdi
movq %rdi, -0x220(%rbp)
xorl %esi, %esi
movl $0x188, %edx # imm = 0x188
callq 0x371f0
movq -0x220(%rbp), %rdi
callq 0x4b740
jmp 0x5c6c8
leaq -0x40(%rbp), %rdi
callq 0x55400
movq %rax, %rcx
leaq 0x4ab7(%rip), %rsi # 0x61192
leaq -0x218(%rbp), %rdi
movl $0x50, %edx
movl $0x1, %r8d
callq 0x4cd50
jmp 0x5c6f4
leaq -0x218(%rbp), %rdi
leaq -0x1d8(%rbp), %rsi
callq 0x4cd90
jmp 0x5c709
leaq -0x218(%rbp), %rdi
callq 0x4b780
leaq -0x1d8(%rbp), %rdi
callq 0x4b760
jmp 0x5c777
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1e0(%rbp)
movl %eax, -0x1e4(%rbp)
jmp 0x5c789
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1e0(%rbp)
movl %eax, -0x1e4(%rbp)
jmp 0x5c769
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1e0(%rbp)
movl %eax, -0x1e4(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x4b780
leaq -0x1d8(%rbp), %rdi
callq 0x4b760
jmp 0x5c789
leaq -0x40(%rbp), %rdi
callq 0x55420
addq $0x220, %rsp # imm = 0x220
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0x55420
movq -0x1e0(%rbp), %rdi
callq 0x37710
nop
| /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_TYPED_TEST_APPEND_TYPENAME
detail::MakeIndexTypedTestName<TypeParam>(testsuite, index)
#else
detail::MakeIndexTestName(testsuite, index)
#endif
, internal::GetTypeId<detail::None>() // TypeId を統一するためダミー引数を渡す
, IUTEST_GET_SETUP_TESTSUITE(TestBody, file, line)
, IUTEST_GET_TEARDOWN_TESTSUITE(TestBody, file, line)
#if defined(IUTEST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS)
, detail::explicit_type<_MyTestSuite>()
#endif
);
} | 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 -0x1c(%rbp), %esi
callq 0x5c940
movq %rax, -0x58(%rbp)
jmp 0x5c8cf
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x5caf0
movq %rax, -0x70(%rbp)
jmp 0x5c8e1
movq -0x70(%rbp), %r8
movq -0x58(%rbp), %rcx
movq -0x60(%rbp), %rdx
movq -0x68(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x569e0
movq %rax, -0x78(%rbp)
jmp 0x5c900
leaq -0x40(%rbp), %rdi
callq 0x377f8
movq -0x78(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x377f8
movq -0x48(%rbp), %rdi
callq 0x37710
nopw %cs:(%rax,%rax)
nop
| /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);
IUTEST_CHECK_( testcase == NULL || testsuite == NULL )
<< "Test can not provide both SetUpTestSuite and SetUpTestCase, please make sure there is only one present at "
<< detail::FormatCompilerIndependentFileLocation(file, line);
return testcase != NULL ? testcase : testsuite;
} | 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 %eax, %eax
jne 0x5c985
jmp 0x5c983
jmp 0x5c985
movb $0x1, %al
cmpq $0x0, -0x18(%rbp)
movb %al, -0x1e1(%rbp)
je 0x5c9a2
cmpq $0x0, -0x20(%rbp)
sete %al
movb %al, -0x1e1(%rbp)
movb -0x1e1(%rbp), %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x54ae0
testb $0x1, %al
jne 0x5caa7
leaq 0x6d1d(%rip), %rdx # 0x636df
leaq -0x1b0(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
movl $0x3, %esi
movl $0x4b, %ecx
callq 0x446f0
movq -0x1f8(%rbp), %rdi
callq 0x44870
movq %rax, %rdi
addq $0x10, %rdi
leaq 0x6d45(%rip), %rsi # 0x6373e
callq 0x373e0
movq %rax, -0x1f0(%rbp)
jmp 0x5ca07
movq -0x1f0(%rbp), %rdi
leaq 0x6d62(%rip), %rsi # 0x63777
callq 0x373e0
movq %rax, -0x200(%rbp)
jmp 0x5ca23
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
leaq -0x1e0(%rbp), %rdi
callq 0x50280
jmp 0x5ca38
movq -0x200(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
callq 0x373a0
jmp 0x5ca4d
leaq -0x1e0(%rbp), %rdi
callq 0x377f8
leaq -0x1b0(%rbp), %rdi
callq 0x448a0
jmp 0x5caa7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
jmp 0x5ca99
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0x377f8
leaq -0x1b0(%rbp), %rdi
callq 0x448a0
jmp 0x5cad8
jmp 0x5caa9
cmpq $0x0, -0x18(%rbp)
je 0x5cabd
movq -0x18(%rbp), %rax
movq %rax, -0x208(%rbp)
jmp 0x5cac8
movq -0x20(%rbp), %rax
movq %rax, -0x208(%rbp)
movq -0x208(%rbp), %rax
addq $0x210, %rsp # imm = 0x210
popq %rbp
retq
movq -0x1b8(%rbp), %rdi
callq 0x37710
nopw %cs:(%rax,%rax)
nop
| /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::TearDownTestSuite);
IUTEST_CHECK_( testcase == NULL || testsuite == NULL )
<< "Test can not provide both TearDownTestSuite and TearDownTestCase, please make sure there is only one present at "
<< detail::FormatCompilerIndependentFileLocation(file, line);
return testcase != NULL ? testcase : testsuite;
} | 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 %eax, %eax
jne 0x5cb35
jmp 0x5cb33
jmp 0x5cb35
movb $0x1, %al
cmpq $0x0, -0x18(%rbp)
movb %al, -0x1e1(%rbp)
je 0x5cb52
cmpq $0x0, -0x20(%rbp)
sete %al
movb %al, -0x1e1(%rbp)
movb -0x1e1(%rbp), %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x54ae0
testb $0x1, %al
jne 0x5cc57
leaq 0x6b6d(%rip), %rdx # 0x636df
leaq -0x1b0(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
movl $0x3, %esi
movl $0x56, %ecx
callq 0x446f0
movq -0x1f8(%rbp), %rdi
callq 0x44870
movq %rax, %rdi
addq $0x10, %rdi
leaq 0x6b95(%rip), %rsi # 0x6373e
callq 0x373e0
movq %rax, -0x1f0(%rbp)
jmp 0x5cbb7
movq -0x1f0(%rbp), %rdi
leaq 0x6c1d(%rip), %rsi # 0x637e2
callq 0x373e0
movq %rax, -0x200(%rbp)
jmp 0x5cbd3
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
leaq -0x1e0(%rbp), %rdi
callq 0x50280
jmp 0x5cbe8
movq -0x200(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
callq 0x373a0
jmp 0x5cbfd
leaq -0x1e0(%rbp), %rdi
callq 0x377f8
leaq -0x1b0(%rbp), %rdi
callq 0x448a0
jmp 0x5cc57
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
jmp 0x5cc49
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0x377f8
leaq -0x1b0(%rbp), %rdi
callq 0x448a0
jmp 0x5cc88
jmp 0x5cc59
cmpq $0x0, -0x18(%rbp)
je 0x5cc6d
movq -0x18(%rbp), %rax
movq %rax, -0x208(%rbp)
jmp 0x5cc78
movq -0x20(%rbp), %rax
movq %rax, -0x208(%rbp)
movq -0x208(%rbp), %rax
addq $0x210, %rsp # imm = 0x210
popq %rbp
retq
movq -0x1b8(%rbp), %rdi
callq 0x37710
nopw %cs:(%rax,%rax)
nop
| /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 %st, %st(1)
movq %rsp, %rax
fstpt (%rax)
leaq -0x70(%rbp), %rdi
callq 0x5a8e0
leaq -0x80(%rbp), %rdi
callq 0x5cf80
leaq -0x58(%rbp), %rdi
leaq 0x6a53(%rip), %rsi # 0x638ad
leaq 0x6a71(%rip), %rdx # 0x638d2
leaq -0x70(%rbp), %rcx
leaq -0x80(%rbp), %r8
callq 0x5a890
leaq -0x58(%rbp), %rdi
callq 0x553e0
testb $0x1, %al
jne 0x5ce7d
jmp 0x5ce82
jmp 0x5cf59
leaq -0x208(%rbp), %rdi
movq %rdi, -0x250(%rbp)
xorl %esi, %esi
movl $0x188, %edx # imm = 0x188
callq 0x371f0
movq -0x250(%rbp), %rdi
callq 0x4b740
jmp 0x5ceaa
leaq -0x58(%rbp), %rdi
callq 0x55400
movq %rax, %rcx
leaq 0x42d5(%rip), %rsi # 0x61192
leaq -0x248(%rbp), %rdi
movl $0x50, %edx
movl $0x1, %r8d
callq 0x4cd50
jmp 0x5ced6
leaq -0x248(%rbp), %rdi
leaq -0x208(%rbp), %rsi
callq 0x4cd90
jmp 0x5ceeb
leaq -0x248(%rbp), %rdi
callq 0x4b780
leaq -0x208(%rbp), %rdi
callq 0x4b760
jmp 0x5cf59
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
jmp 0x5cf6b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
jmp 0x5cf4b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
leaq -0x248(%rbp), %rdi
callq 0x4b780
leaq -0x208(%rbp), %rdi
callq 0x4b760
jmp 0x5cf6b
leaq -0x58(%rbp), %rdi
callq 0x55420
addq $0x260, %rsp # imm = 0x260
popq %rbp
retq
leaq -0x58(%rbp), %rdi
callq 0x55420
movq -0x210(%rbp), %rdi
callq 0x37710
| /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::allocator<char>> const&, char const*, unsigned long, char const*, int) | 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(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0x2c(%rbp), %ecx
callq 0x5d250
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0x53130
movq -0x88(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x37720
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x38530
jmp 0x5d109
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdi
movq -0x98(%rbp), %rcx
addq $0xc8, %rcx
leaq -0x50(%rbp), %rdx
callq 0x53170
jmp 0x5d12d
leaq -0x50(%rbp), %rdi
callq 0x377f8
leaq -0x51(%rbp), %rdi
callq 0x37460
movq -0x98(%rbp), %rdi
addq $0xc8, %rdi
movq %rdi, -0xa0(%rbp)
callq 0x5d290
movq -0x98(%rbp), %rdi
addq $0xd0, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
incq %rcx
movq -0x28(%rbp), %r8
movl -0x2c(%rbp), %r9d
callq 0x5d2d0
jmp 0x5d185
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x5d1b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x377f8
leaq -0x51(%rbp), %rdi
callq 0x37460
jmp 0x5d1dd
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
callq 0x3d300
movq -0x80(%rbp), %rdi
callq 0x3c6e0
movq -0x90(%rbp), %rdi
callq 0x3c740
movq -0x60(%rbp), %rdi
callq 0x37710
nopw %cs:(%rax,%rax)
nopl (%rax)
| /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<char>> const&, char const*, unsigned long, char const*, int) | 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(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0x2c(%rbp), %ecx
callq 0x5eb20
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0x53130
movq -0x88(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x37720
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x38530
jmp 0x5d369
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdi
movq -0x98(%rbp), %rcx
addq $0xc8, %rcx
leaq -0x50(%rbp), %rdx
callq 0x53170
jmp 0x5d38d
leaq -0x50(%rbp), %rdi
callq 0x377f8
leaq -0x51(%rbp), %rdi
callq 0x37460
movq -0x98(%rbp), %rdi
addq $0xc8, %rdi
movq %rdi, -0xa0(%rbp)
callq 0x5eb60
movq -0x98(%rbp), %rdi
addq $0xd0, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
incq %rcx
movq -0x28(%rbp), %r8
movl -0x2c(%rbp), %r9d
callq 0x5eba0
jmp 0x5d3e5
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x5d411
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x377f8
leaq -0x51(%rbp), %rdi
callq 0x37460
jmp 0x5d43d
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
callq 0x3d360
movq -0x80(%rbp), %rdi
callq 0x3c6e0
movq -0x90(%rbp), %rdi
callq 0x3c740
movq -0x60(%rbp), %rdi
callq 0x37710
nopw %cs:(%rax,%rax)
nopl (%rax)
| /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);
IUTEST_CHECK_( testcase == NULL || testsuite == NULL )
<< "Test can not provide both SetUpTestSuite and SetUpTestCase, please make sure there is only one present at "
<< detail::FormatCompilerIndependentFileLocation(file, line);
return testcase != NULL ? testcase : testsuite;
} | 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 %eax, %eax
jne 0x5d565
jmp 0x5d563
jmp 0x5d565
movb $0x1, %al
cmpq $0x0, -0x18(%rbp)
movb %al, -0x1e1(%rbp)
je 0x5d582
cmpq $0x0, -0x20(%rbp)
sete %al
movb %al, -0x1e1(%rbp)
movb -0x1e1(%rbp), %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x54ae0
testb $0x1, %al
jne 0x5d687
leaq 0x613d(%rip), %rdx # 0x636df
leaq -0x1b0(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
movl $0x3, %esi
movl $0x4b, %ecx
callq 0x446f0
movq -0x1f8(%rbp), %rdi
callq 0x44870
movq %rax, %rdi
addq $0x10, %rdi
leaq 0x6165(%rip), %rsi # 0x6373e
callq 0x373e0
movq %rax, -0x1f0(%rbp)
jmp 0x5d5e7
movq -0x1f0(%rbp), %rdi
leaq 0x6182(%rip), %rsi # 0x63777
callq 0x373e0
movq %rax, -0x200(%rbp)
jmp 0x5d603
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
leaq -0x1e0(%rbp), %rdi
callq 0x50280
jmp 0x5d618
movq -0x200(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
callq 0x373a0
jmp 0x5d62d
leaq -0x1e0(%rbp), %rdi
callq 0x377f8
leaq -0x1b0(%rbp), %rdi
callq 0x448a0
jmp 0x5d687
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
jmp 0x5d679
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0x377f8
leaq -0x1b0(%rbp), %rdi
callq 0x448a0
jmp 0x5d6b8
jmp 0x5d689
cmpq $0x0, -0x18(%rbp)
je 0x5d69d
movq -0x18(%rbp), %rax
movq %rax, -0x208(%rbp)
jmp 0x5d6a8
movq -0x20(%rbp), %rax
movq %rax, -0x208(%rbp)
movq -0x208(%rbp), %rax
addq $0x210, %rsp # imm = 0x210
popq %rbp
retq
movq -0x1b8(%rbp), %rdi
callq 0x37710
nopw %cs:(%rax,%rax)
nop
| /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::TearDownTestSuite);
IUTEST_CHECK_( testcase == NULL || testsuite == NULL )
<< "Test can not provide both TearDownTestSuite and TearDownTestCase, please make sure there is only one present at "
<< detail::FormatCompilerIndependentFileLocation(file, line);
return testcase != NULL ? testcase : testsuite;
} | 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 %eax, %eax
jne 0x5d715
jmp 0x5d713
jmp 0x5d715
movb $0x1, %al
cmpq $0x0, -0x18(%rbp)
movb %al, -0x1e1(%rbp)
je 0x5d732
cmpq $0x0, -0x20(%rbp)
sete %al
movb %al, -0x1e1(%rbp)
movb -0x1e1(%rbp), %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x54ae0
testb $0x1, %al
jne 0x5d837
leaq 0x5f8d(%rip), %rdx # 0x636df
leaq -0x1b0(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
movl $0x3, %esi
movl $0x56, %ecx
callq 0x446f0
movq -0x1f8(%rbp), %rdi
callq 0x44870
movq %rax, %rdi
addq $0x10, %rdi
leaq 0x5fb5(%rip), %rsi # 0x6373e
callq 0x373e0
movq %rax, -0x1f0(%rbp)
jmp 0x5d797
movq -0x1f0(%rbp), %rdi
leaq 0x603d(%rip), %rsi # 0x637e2
callq 0x373e0
movq %rax, -0x200(%rbp)
jmp 0x5d7b3
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
leaq -0x1e0(%rbp), %rdi
callq 0x50280
jmp 0x5d7c8
movq -0x200(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
callq 0x373a0
jmp 0x5d7dd
leaq -0x1e0(%rbp), %rdi
callq 0x377f8
leaq -0x1b0(%rbp), %rdi
callq 0x448a0
jmp 0x5d837
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
jmp 0x5d829
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0x377f8
leaq -0x1b0(%rbp), %rdi
callq 0x448a0
jmp 0x5d868
jmp 0x5d839
cmpq $0x0, -0x18(%rbp)
je 0x5d84d
movq -0x18(%rbp), %rax
movq %rax, -0x208(%rbp)
jmp 0x5d858
movq -0x20(%rbp), %rax
movq %rax, -0x208(%rbp)
movq -0x208(%rbp), %rax
addq $0x210, %rsp # imm = 0x210
popq %rbp
retq
movq -0x1b8(%rbp), %rdi
callq 0x37710
nopw %cs:(%rax,%rax)
nop
| /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 0x5db5d
leaq -0x1b8(%rbp), %rdi
movq %rdi, -0x410(%rbp)
xorl %esi, %esi
movl $0x188, %edx # imm = 0x188
callq 0x371f0
movq -0x410(%rbp), %rdi
callq 0x4b740
jmp 0x5da48
leaq 0x5e95(%rip), %rdx # 0x638e4
leaq 0x3afd(%rip), %rcx # 0x61553
leaq 0x3aea(%rip), %r8 # 0x61547
leaq -0x218(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5dd60
jmp 0x5da6f
leaq -0x218(%rbp), %rdi
callq 0x37170
movq %rax, %rcx
leaq 0x370d(%rip), %rsi # 0x61192
leaq -0x1f8(%rbp), %rdi
movl $0x58, %edx
movl $0xfffffffd, %r8d # imm = 0xFFFFFFFD
callq 0x4cd50
jmp 0x5da9e
leaq -0x1f8(%rbp), %rdi
leaq -0x1b8(%rbp), %rsi
callq 0x4cd90
jmp 0x5dab3
leaq -0x1f8(%rbp), %rdi
callq 0x4b780
leaq -0x218(%rbp), %rdi
callq 0x377f8
leaq -0x1b8(%rbp), %rdi
callq 0x4b760
movl $0x1, -0x21c(%rbp)
jmp 0x5db67
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
jmp 0x5dbce
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
jmp 0x5db4f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
jmp 0x5db43
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
leaq -0x1f8(%rbp), %rdi
callq 0x4b780
leaq -0x218(%rbp), %rdi
callq 0x377f8
leaq -0x1b8(%rbp), %rdi
callq 0x4b760
jmp 0x5dbce
movl $0x0, -0x21c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x55420
movl -0x21c(%rbp), %eax
testl %eax, %eax
je 0x5db81
jmp 0x5db7c
jmp 0x5dcf5
jmp 0x5db83
movss 0x1c885(%rip), %xmm0 # 0x7a410
movss %xmm0, -0x220(%rbp)
movss 0x1d6f1(%rip), %xmm0 # 0x7b28c
movss %xmm0, -0x224(%rbp)
movss -0x220(%rbp), %xmm0
movss -0x224(%rbp), %xmm1
divss %xmm1, %xmm0
mulss %xmm1, %xmm0
movss %xmm0, -0x228(%rbp)
callq 0x54ad0
testl %eax, %eax
je 0x5dbdc
jmp 0x5dbde
leaq -0x30(%rbp), %rdi
callq 0x55420
jmp 0x5dd0a
jmp 0x5dbde
leaq -0x250(%rbp), %rdi
leaq 0x5d24(%rip), %rsi # 0x63910
leaq -0x228(%rbp), %rdx
callq 0x5dec0
leaq -0x250(%rbp), %rdi
callq 0x553e0
testb $0x1, %al
jne 0x5dc0a
jmp 0x5dc0f
jmp 0x5dce9
leaq -0x3d8(%rbp), %rdi
movq %rdi, -0x418(%rbp)
xorl %esi, %esi
movl $0x188, %edx # imm = 0x188
callq 0x371f0
movq -0x418(%rbp), %rdi
callq 0x4b740
jmp 0x5dc37
leaq -0x250(%rbp), %rdi
callq 0x55400
movq %rax, %rcx
leaq 0x3545(%rip), %rsi # 0x61192
leaq -0x408(%rbp), %rdi
movl $0x5d, %edx
movl $0x1, %r8d
callq 0x4cd50
jmp 0x5dc66
leaq -0x408(%rbp), %rdi
leaq -0x3d8(%rbp), %rsi
callq 0x4cd90
jmp 0x5dc7b
leaq -0x408(%rbp), %rdi
callq 0x4b780
leaq -0x3d8(%rbp), %rdi
callq 0x4b760
jmp 0x5dce9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
jmp 0x5dcfe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
jmp 0x5dcdb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1c0(%rbp)
movl %eax, -0x1c4(%rbp)
leaq -0x408(%rbp), %rdi
callq 0x4b780
leaq -0x3d8(%rbp), %rdi
callq 0x4b760
jmp 0x5dcfe
leaq -0x250(%rbp), %rdi
callq 0x55420
addq $0x420, %rsp # imm = 0x420
popq %rbp
retq
leaq -0x250(%rbp), %rdi
callq 0x55420
movq -0x1c0(%rbp), %rdi
callq 0x37710
nopw %cs:(%rax,%rax)
| /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 += " (";
str += ar.message();
str += ")";
}
str += "\nExpected: ";
str += expected;
return 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), %rdi
movq -0x48(%rbp), %rdx
leaq 0x5b6d(%rip), %rsi # 0x63914
callq 0x38530
jmp 0x5ddae
leaq -0x2a(%rbp), %rdi
callq 0x37460
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x373c0
jmp 0x5ddc6
movq -0x50(%rbp), %rdi
leaq 0x5aa7(%rip), %rsi # 0x63878
callq 0x373c0
jmp 0x5ddd8
movq -0x50(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x373c0
jmp 0x5dde7
movq -0x10(%rbp), %rdi
callq 0x55400
movq %rax, %rdi
callq 0x5dfe0
movb %al, -0x59(%rbp)
jmp 0x5ddfd
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x5de71
jmp 0x5de06
movq -0x50(%rbp), %rdi
leaq 0x5b15(%rip), %rsi # 0x63926
callq 0x373c0
jmp 0x5de18
movq -0x10(%rbp), %rdi
callq 0x55400
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x373c0
jmp 0x5de2f
movq -0x50(%rbp), %rdi
leaq 0x5aa8(%rip), %rsi # 0x638e2
callq 0x373c0
jmp 0x5de41
jmp 0x5de71
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x2a(%rbp), %rdi
callq 0x37460
jmp 0x5deaf
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x377f8
jmp 0x5deaf
movq -0x50(%rbp), %rdi
leaq 0x5a08(%rip), %rsi # 0x63884
callq 0x373c0
jmp 0x5de83
movq -0x50(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x373c0
jmp 0x5de92
movb $0x1, -0x29(%rbp)
testb $0x1, -0x29(%rbp)
jne 0x5dea5
movq -0x50(%rbp), %rdi
callq 0x377f8
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x37710
nopl (%rax,%rax)
| /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
<< "\n Actual: " << actual << "\nExpected: NaN";
} | 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 -0x68(%rbp), %rdi
callq 0x555c0
jmp 0x5dfc4
leaq -0x48(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x558e0
movq -0x78(%rbp), %rdi
leaq 0x59f0(%rip), %rsi # 0x63914
callq 0x5e0a0
movq %rax, -0x70(%rbp)
jmp 0x5df2f
movq -0x70(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x5e180
movq %rax, -0x80(%rbp)
jmp 0x5df42
movq -0x80(%rbp), %rdi
leaq 0x592b(%rip), %rsi # 0x63878
callq 0x5e260
movq %rax, -0x88(%rbp)
jmp 0x5df5b
movq -0x88(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5e340
movq %rax, -0x90(%rbp)
jmp 0x5df74
movq -0x90(%rbp), %rdi
leaq 0x59a7(%rip), %rsi # 0x63929
callq 0x5e420
movq %rax, -0x98(%rbp)
jmp 0x5df90
movq -0x98(%rbp), %rsi
movq -0x68(%rbp), %rdi
callq 0x559f0
jmp 0x5dfa2
leaq -0x48(%rbp), %rdi
callq 0x55420
jmp 0x5dfc4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x55420
jmp 0x5dfd1
movq -0x60(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x37710
nopw (%rax,%rax)
| /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 0x5e870
leaq -0x30(%rbp), %rdi
callq 0x377f8
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x377f8
movq -0x38(%rbp), %rdi
callq 0x37710
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /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>> const&, char const*, unsigned long, char const*, int) | 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(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0x2c(%rbp), %ecx
callq 0x5fa70
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0x53130
movq -0x88(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x80(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x51(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x37720
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x38530
jmp 0x5ec39
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdi
movq -0x98(%rbp), %rcx
addq $0xc8, %rcx
leaq -0x50(%rbp), %rdx
callq 0x53170
jmp 0x5ec5d
leaq -0x50(%rbp), %rdi
callq 0x377f8
leaq -0x51(%rbp), %rdi
callq 0x37460
movq -0x98(%rbp), %rdi
addq $0xc8, %rdi
movq %rdi, -0xa0(%rbp)
callq 0x5fab0
movq -0x98(%rbp), %rdi
addq $0xd0, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
incq %rcx
movq -0x28(%rbp), %r8
movl -0x2c(%rbp), %r9d
callq 0x5faf0
jmp 0x5ecb5
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x5ece1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x377f8
leaq -0x51(%rbp), %rdi
callq 0x37460
jmp 0x5ed0d
movq -0xa0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
callq 0x3d380
movq -0x80(%rbp), %rdi
callq 0x3c6e0
movq -0x90(%rbp), %rdi
callq 0x3c740
movq -0x60(%rbp), %rdi
callq 0x37710
nopw %cs:(%rax,%rax)
nopl (%rax)
| /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_TYPED_TEST_APPEND_TYPENAME
detail::MakeIndexTypedTestName<TypeParam>(testsuite, index)
#else
detail::MakeIndexTestName(testsuite, index)
#endif
, internal::GetTypeId<detail::None>() // TypeId を統一するためダミー引数を渡す
, IUTEST_GET_SETUP_TESTSUITE(TestBody, file, line)
, IUTEST_GET_TEARDOWN_TESTSUITE(TestBody, file, line)
#if defined(IUTEST_NO_EXPLICIT_FUNCTION_TEMPLATE_ARGUMENTS)
, detail::explicit_type<_MyTestSuite>()
#endif
);
} | 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 -0x1c(%rbp), %esi
callq 0x5edf0
movq %rax, -0x58(%rbp)
jmp 0x5ed7f
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x5efa0
movq %rax, -0x70(%rbp)
jmp 0x5ed91
movq -0x70(%rbp), %r8
movq -0x58(%rbp), %rcx
movq -0x60(%rbp), %rdx
movq -0x68(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x55ec0
movq %rax, -0x78(%rbp)
jmp 0x5edb0
leaq -0x40(%rbp), %rdi
callq 0x377f8
movq -0x78(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x377f8
movq -0x48(%rbp), %rdi
callq 0x37710
nopw %cs:(%rax,%rax)
nop
| /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::TearDownTestSuite);
IUTEST_CHECK_( testcase == NULL || testsuite == NULL )
<< "Test can not provide both TearDownTestSuite and TearDownTestCase, please make sure there is only one present at "
<< detail::FormatCompilerIndependentFileLocation(file, line);
return testcase != NULL ? testcase : testsuite;
} | 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 %eax, %eax
jne 0x5efe5
jmp 0x5efe3
jmp 0x5efe5
movb $0x1, %al
cmpq $0x0, -0x18(%rbp)
movb %al, -0x1e1(%rbp)
je 0x5f002
cmpq $0x0, -0x20(%rbp)
sete %al
movb %al, -0x1e1(%rbp)
movb -0x1e1(%rbp), %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x54ae0
testb $0x1, %al
jne 0x5f107
leaq 0x46bd(%rip), %rdx # 0x636df
leaq -0x1b0(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
movl $0x3, %esi
movl $0x56, %ecx
callq 0x446f0
movq -0x1f8(%rbp), %rdi
callq 0x44870
movq %rax, %rdi
addq $0x10, %rdi
leaq 0x46e5(%rip), %rsi # 0x6373e
callq 0x373e0
movq %rax, -0x1f0(%rbp)
jmp 0x5f067
movq -0x1f0(%rbp), %rdi
leaq 0x476d(%rip), %rsi # 0x637e2
callq 0x373e0
movq %rax, -0x200(%rbp)
jmp 0x5f083
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
leaq -0x1e0(%rbp), %rdi
callq 0x50280
jmp 0x5f098
movq -0x200(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
callq 0x373a0
jmp 0x5f0ad
leaq -0x1e0(%rbp), %rdi
callq 0x377f8
leaq -0x1b0(%rbp), %rdi
callq 0x448a0
jmp 0x5f107
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
jmp 0x5f0f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0x377f8
leaq -0x1b0(%rbp), %rdi
callq 0x448a0
jmp 0x5f138
jmp 0x5f109
cmpq $0x0, -0x18(%rbp)
je 0x5f11d
movq -0x18(%rbp), %rax
movq %rax, -0x208(%rbp)
jmp 0x5f128
movq -0x20(%rbp), %rax
movq %rax, -0x208(%rbp)
movq -0x208(%rbp), %rax
addq $0x210, %rsp # imm = 0x210
popq %rbp
retq
movq -0x1b8(%rbp), %rdi
callq 0x37710
nopw %cs:(%rax,%rax)
nop
| /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
<< "\n Actual: " << actual << "\nExpected: NaN";
} | 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 -0x68(%rbp), %rdi
callq 0x555c0
jmp 0x5f6f4
leaq -0x48(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x558e0
movq -0x78(%rbp), %rdi
leaq 0x42c0(%rip), %rsi # 0x63914
callq 0x5e0a0
movq %rax, -0x70(%rbp)
jmp 0x5f65f
movq -0x70(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x5e180
movq %rax, -0x80(%rbp)
jmp 0x5f672
movq -0x80(%rbp), %rdi
leaq 0x41fb(%rip), %rsi # 0x63878
callq 0x5e260
movq %rax, -0x88(%rbp)
jmp 0x5f68b
movq -0x88(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x5f790
movq %rax, -0x90(%rbp)
jmp 0x5f6a4
movq -0x90(%rbp), %rdi
leaq 0x4277(%rip), %rsi # 0x63929
callq 0x5e420
movq %rax, -0x98(%rbp)
jmp 0x5f6c0
movq -0x98(%rbp), %rsi
movq -0x68(%rbp), %rdi
callq 0x559f0
jmp 0x5f6d2
leaq -0x48(%rbp), %rdi
callq 0x55420
jmp 0x5f6f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x55420
jmp 0x5f701
movq -0x60(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x37710
nopw (%rax,%rax)
| /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);
IUTEST_CHECK_( testcase == NULL || testsuite == NULL )
<< "Test can not provide both SetUpTestSuite and SetUpTestCase, please make sure there is only one present at "
<< detail::FormatCompilerIndependentFileLocation(file, line);
return testcase != NULL ? testcase : testsuite;
} | 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 %eax, %eax
jne 0x5fc15
jmp 0x5fc13
jmp 0x5fc15
movb $0x1, %al
cmpq $0x0, -0x18(%rbp)
movb %al, -0x1e1(%rbp)
je 0x5fc32
cmpq $0x0, -0x20(%rbp)
sete %al
movb %al, -0x1e1(%rbp)
movb -0x1e1(%rbp), %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x54ae0
testb $0x1, %al
jne 0x5fd37
leaq 0x3a8d(%rip), %rdx # 0x636df
leaq -0x1b0(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
movl $0x3, %esi
movl $0x4b, %ecx
callq 0x446f0
movq -0x1f8(%rbp), %rdi
callq 0x44870
movq %rax, %rdi
addq $0x10, %rdi
leaq 0x3ab5(%rip), %rsi # 0x6373e
callq 0x373e0
movq %rax, -0x1f0(%rbp)
jmp 0x5fc97
movq -0x1f0(%rbp), %rdi
leaq 0x3ad2(%rip), %rsi # 0x63777
callq 0x373e0
movq %rax, -0x200(%rbp)
jmp 0x5fcb3
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
leaq -0x1e0(%rbp), %rdi
callq 0x50280
jmp 0x5fcc8
movq -0x200(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
callq 0x373a0
jmp 0x5fcdd
leaq -0x1e0(%rbp), %rdi
callq 0x377f8
leaq -0x1b0(%rbp), %rdi
callq 0x448a0
jmp 0x5fd37
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
jmp 0x5fd29
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0x377f8
leaq -0x1b0(%rbp), %rdi
callq 0x448a0
jmp 0x5fd68
jmp 0x5fd39
cmpq $0x0, -0x18(%rbp)
je 0x5fd4d
movq -0x18(%rbp), %rax
movq %rax, -0x208(%rbp)
jmp 0x5fd58
movq -0x20(%rbp), %rax
movq %rax, -0x208(%rbp)
movq -0x208(%rbp), %rax
addq $0x210, %rsp # imm = 0x210
popq %rbp
retq
movq -0x1b8(%rbp), %rdi
callq 0x37710
nopw %cs:(%rax,%rax)
nop
| /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::TearDownTestSuite);
IUTEST_CHECK_( testcase == NULL || testsuite == NULL )
<< "Test can not provide both TearDownTestSuite and TearDownTestCase, please make sure there is only one present at "
<< detail::FormatCompilerIndependentFileLocation(file, line);
return testcase != NULL ? testcase : testsuite;
} | 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 %eax, %eax
jne 0x5fdc5
jmp 0x5fdc3
jmp 0x5fdc5
movb $0x1, %al
cmpq $0x0, -0x18(%rbp)
movb %al, -0x1e1(%rbp)
je 0x5fde2
cmpq $0x0, -0x20(%rbp)
sete %al
movb %al, -0x1e1(%rbp)
movb -0x1e1(%rbp), %al
movzbl %al, %edi
andl $0x1, %edi
callq 0x54ae0
testb $0x1, %al
jne 0x5fee7
leaq 0x38dd(%rip), %rdx # 0x636df
leaq -0x1b0(%rbp), %rdi
movq %rdi, -0x1f8(%rbp)
movl $0x3, %esi
movl $0x56, %ecx
callq 0x446f0
movq -0x1f8(%rbp), %rdi
callq 0x44870
movq %rax, %rdi
addq $0x10, %rdi
leaq 0x3905(%rip), %rsi # 0x6373e
callq 0x373e0
movq %rax, -0x1f0(%rbp)
jmp 0x5fe47
movq -0x1f0(%rbp), %rdi
leaq 0x398d(%rip), %rsi # 0x637e2
callq 0x373e0
movq %rax, -0x200(%rbp)
jmp 0x5fe63
movq -0x8(%rbp), %rsi
movl -0xc(%rbp), %edx
leaq -0x1e0(%rbp), %rdi
callq 0x50280
jmp 0x5fe78
movq -0x200(%rbp), %rdi
leaq -0x1e0(%rbp), %rsi
callq 0x373a0
jmp 0x5fe8d
leaq -0x1e0(%rbp), %rdi
callq 0x377f8
leaq -0x1b0(%rbp), %rdi
callq 0x448a0
jmp 0x5fee7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
jmp 0x5fed9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0x377f8
leaq -0x1b0(%rbp), %rdi
callq 0x448a0
jmp 0x5ff18
jmp 0x5fee9
cmpq $0x0, -0x18(%rbp)
je 0x5fefd
movq -0x18(%rbp), %rax
movq %rax, -0x208(%rbp)
jmp 0x5ff08
movq -0x20(%rbp), %rax
movq %rax, -0x208(%rbp)
movq -0x208(%rbp), %rax
addq $0x210, %rsp # imm = 0x210
popq %rbp
retq
movq -0x1b8(%rbp), %rdi
callq 0x37710
nopw %cs:(%rax,%rax)
nop
| /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
<< "\n Actual: " << actual << "\nExpected: NaN";
} | 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 -0x68(%rbp), %rdi
callq 0x555c0
jmp 0x604c4
leaq -0x48(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x558e0
movq -0x78(%rbp), %rdi
leaq 0x34f0(%rip), %rsi # 0x63914
callq 0x5e0a0
movq %rax, -0x70(%rbp)
jmp 0x6042f
movq -0x70(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x5e180
movq %rax, -0x80(%rbp)
jmp 0x60442
movq -0x80(%rbp), %rdi
leaq 0x342b(%rip), %rsi # 0x63878
callq 0x5e260
movq %rax, -0x88(%rbp)
jmp 0x6045b
movq -0x88(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x60520
movq %rax, -0x90(%rbp)
jmp 0x60474
movq -0x90(%rbp), %rdi
leaq 0x34a7(%rip), %rsi # 0x63929
callq 0x5e420
movq %rax, -0x98(%rbp)
jmp 0x60490
movq -0x98(%rbp), %rsi
movq -0x68(%rbp), %rdi
callq 0x559f0
jmp 0x604a2
leaq -0x48(%rbp), %rdi
callq 0x55420
jmp 0x604c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x55420
jmp 0x604d1
movq -0x60(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x37710
nopw (%rax,%rax)
| /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 0x60640
leaq -0x30(%rbp), %rdi
callq 0x377f8
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x377f8
movq -0x38(%rbp), %rdi
callq 0x37710
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /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 *) ctx;
#if SIZE_MAX > UINT_MAX
if( md_alg == MBEDTLS_MD_NONE && UINT_MAX < hash_len )
return( MBEDTLS_ERR_PK_BAD_INPUT_DATA );
#endif /* SIZE_MAX > UINT_MAX */
*sig_len = mbedtls_rsa_get_len( rsa );
return( mbedtls_rsa_pkcs1_sign( rsa, f_rng, p_rng, MBEDTLS_RSA_PRIVATE,
md_alg, (unsigned int) hash_len, hash, sig ) );
} | 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, %r13
callq 0x11176
movq %rax, (%r12)
pushq $0x1
popq %rcx
movq %r13, %rdi
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
movl %ebp, %r8d
movl %r15d, %r9d
pushq %r14
pushq %rbx
callq 0x12c0c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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,
hash, hash_len, sig, sig_len );
if( ret == MBEDTLS_ERR_ECP_SIG_LEN_MISMATCH )
return( MBEDTLS_ERR_PK_SIG_LEN_MISMATCH );
return( ret );
} | 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,
size_t *olen,
const unsigned char *input,
unsigned char *output,
size_t output_max_len )
{
int ret;
size_t ilen, i, pad_len;
unsigned char *p, bad, pad_done;
unsigned char buf[MBEDTLS_MPI_MAX_SIZE];
unsigned char lhash[MBEDTLS_MD_MAX_SIZE];
unsigned int hlen;
const mbedtls_md_info_t *md_info;
mbedtls_md_context_t md_ctx;
/*
* Parameters sanity checks
*/
if( mode == MBEDTLS_RSA_PRIVATE && ctx->padding != MBEDTLS_RSA_PKCS_V21 )
return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
ilen = ctx->len;
if( ilen < 16 || ilen > sizeof( buf ) )
return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
md_info = mbedtls_md_info_from_type( (mbedtls_md_type_t) ctx->hash_id );
if( md_info == NULL )
return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
hlen = mbedtls_md_get_size( md_info );
// checking for integer underflow
if( 2 * hlen + 2 > ilen )
return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
/*
* RSA operation
*/
ret = ( mode == MBEDTLS_RSA_PUBLIC )
? mbedtls_rsa_public( ctx, input, buf )
: mbedtls_rsa_private( ctx, f_rng, p_rng, input, buf );
if( ret != 0 )
goto cleanup;
/*
* Unmask data and generate lHash
*/
mbedtls_md_init( &md_ctx );
if( ( ret = mbedtls_md_setup( &md_ctx, md_info, 0 ) ) != 0 )
{
mbedtls_md_free( &md_ctx );
goto cleanup;
}
/* seed: Apply seedMask to maskedSeed */
if( ( ret = mgf_mask( buf + 1, hlen, buf + hlen + 1, ilen - hlen - 1,
&md_ctx ) ) != 0 ||
/* DB: Apply dbMask to maskedDB */
( ret = mgf_mask( buf + hlen + 1, ilen - hlen - 1, buf + 1, hlen,
&md_ctx ) ) != 0 )
{
mbedtls_md_free( &md_ctx );
goto cleanup;
}
mbedtls_md_free( &md_ctx );
/* Generate lHash */
if( ( ret = mbedtls_md( md_info, label, label_len, lhash ) ) != 0 )
goto cleanup;
/*
* Check contents, in "constant-time"
*/
p = buf;
bad = 0;
bad |= *p++; /* First byte must be 0 */
p += hlen; /* Skip seed */
/* Check lHash */
for( i = 0; i < hlen; i++ )
bad |= lhash[i] ^ *p++;
/* Get zero-padding len, but always read till end of buffer
* (minus one, for the 01 byte) */
pad_len = 0;
pad_done = 0;
for( i = 0; i < ilen - 2 * hlen - 2; i++ )
{
pad_done |= p[i];
pad_len += ((pad_done | (unsigned char)-pad_done) >> 7) ^ 1;
}
p += pad_len;
bad |= *p++ ^ 0x01;
/*
* The only information "leaked" is whether the padding was correct or not
* (eg, no data is copied if it was not correct). This meets the
* recommendations in PKCS#1 v2.2: an opponent cannot distinguish between
* the different error conditions.
*/
if( bad != 0 )
{
ret = MBEDTLS_ERR_RSA_INVALID_PADDING;
goto cleanup;
}
if( ilen - ( p - buf ) > output_max_len )
{
ret = MBEDTLS_ERR_RSA_OUTPUT_TOO_LARGE;
goto cleanup;
}
*olen = ilen - (p - buf);
memcpy( output, p, *olen );
ret = 0;
cleanup:
mbedtls_zeroize( buf, sizeof( buf ) );
mbedtls_zeroize( lhash, sizeof( lhash ) );
return( ret );
} | 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(%rcx), %rax
movl $0xffffbf80, %ebp # imm = 0xFFFFBF80
cmpq $-0x3f1, %rax # imm = 0xFC0F
jb 0x1234a
movq %r8, 0x18(%rsp)
movq %r9, 0x20(%rsp)
movq %rcx, 0x8(%rsp)
movl 0x14c(%r15), %edi
callq 0xc7e3
testq %rax, %rax
je 0x1234a
movq %rax, %r13
movq %rax, %rdi
callq 0xcd62
movzbl %al, %ecx
leal 0x2(,%rcx,2), %eax
cmpq %rax, 0x8(%rsp)
jb 0x1234a
movq %rcx, 0x10(%rsp)
movq 0x4c8(%rsp), %rcx
testl %ebx, %ebx
je 0x1228d
leaq 0x80(%rsp), %r8
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x1174f
jmp 0x122a0
leaq 0x80(%rsp), %rdx
movq %r15, %rdi
movq %rcx, %rsi
callq 0x11699
movl %eax, %ebp
testl %eax, %eax
jne 0x1232b
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0xc7fc
movq %rbx, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0xc8a2
testl %eax, %eax
jne 0x1231f
leaq 0x81(%rsp), %rbx
movq 0x10(%rsp), %r12
leaq (%rsp,%r12), %r14
addq $0x81, %r14
movq %r12, %r15
notq %r15
addq 0x8(%rsp), %r15
leaq 0x28(%rsp), %r8
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x11f31
testl %eax, %eax
jne 0x1231f
leaq 0x28(%rsp), %r8
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x11f31
testl %eax, %eax
je 0x1235e
movl %eax, %ebp
leaq 0x28(%rsp), %rdi
callq 0xc808
leaq 0x80(%rsp), %rdi
movl $0x400, %esi # imm = 0x400
callq 0x1246f
leaq 0x40(%rsp), %rdi
pushq $0x40
popq %rsi
callq 0x1246f
movl %ebp, %eax
addq $0x488, %rsp # imm = 0x488
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x28(%rsp), %rdi
callq 0xc808
leaq 0x40(%rsp), %rcx
movq %r13, %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0xc962
movl %eax, %ebp
testl %eax, %eax
jne 0x1232b
movq 0x4d8(%rsp), %rcx
movq 0x4d0(%rsp), %rdi
movq 0x4c0(%rsp), %rax
movq 0x10(%rsp), %r11
movl %r11d, %r9d
addl %r11d, %r9d
movb 0x80(%rsp), %r8b
leaq (%rsp,%r11), %rdx
addq $0x80, %rdx
xorl %esi, %esi
cmpq %rsi, %r11
je 0x123d4
movb 0x1(%rdx,%rsi), %r10b
xorb 0x40(%rsp,%rsi), %r10b
orb %r10b, %r8b
incq %rsi
jmp 0x123bd
movl %r9d, %r9d
movq 0x8(%rsp), %r10
subq %r9, %r10
addq $-0x2, %r10
xorl %r11d, %r11d
xorl %r9d, %r9d
xorl %ebx, %ebx
cmpq %r11, %r10
je 0x12417
leaq (%rdx,%r11), %r14
movzbl 0x1(%rsi,%r14), %ebp
orl %ebp, %ebx
movl %ebx, %ebp
negl %ebp
movzbl %bpl, %r14d
orl %ebx, %r14d
shrl $0x7, %r14d
xorl $0x1, %r14d
addq %r14, %r9
incq %r11
jmp 0x123eb
addq %r9, %rdx
movb 0x1(%rsi,%rdx), %r10b
xorb $0x1, %r10b
movl $0xffffbf00, %ebp # imm = 0xFFFFBF00
orb %r8b, %r10b
jne 0x1232b
movq 0x8(%rsp), %r10
subq 0x10(%rsp), %r10
subq %r9, %r10
subq %rsi, %r10
addq $-0x2, %r10
movl $0xffffbc00, %ebp # imm = 0xFFFFBC00
cmpq %rcx, %r10
ja 0x1232b
movq %r10, %r8
addq %rdx, %rsi
addq $0x2, %rsi
movq %r10, %rdx
movq %r8, (%rax)
callq 0xb160
xorl %ebp, %ebp
jmp 0x1232b
| /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,
unsigned char *output,
size_t output_max_len)
{
int ret;
size_t ilen, pad_count = 0, i;
unsigned char *p, bad, pad_done = 0;
unsigned char buf[MBEDTLS_MPI_MAX_SIZE];
if( mode == MBEDTLS_RSA_PRIVATE && ctx->padding != MBEDTLS_RSA_PKCS_V15 )
return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
ilen = ctx->len;
if( ilen < 16 || ilen > sizeof( buf ) )
return( MBEDTLS_ERR_RSA_BAD_INPUT_DATA );
ret = ( mode == MBEDTLS_RSA_PUBLIC )
? mbedtls_rsa_public( ctx, input, buf )
: mbedtls_rsa_private( ctx, f_rng, p_rng, input, buf );
if( ret != 0 )
goto cleanup;
p = buf;
bad = 0;
/*
* Check and get padding len in "constant-time"
*/
bad |= *p++; /* First byte must be 0 */
/* This test does not depend on secret data */
if( mode == MBEDTLS_RSA_PRIVATE )
{
bad |= *p++ ^ MBEDTLS_RSA_CRYPT;
/* Get padding len, but always read till end of buffer
* (minus one, for the 00 byte) */
for( i = 0; i < ilen - 3; i++ )
{
pad_done |= ((p[i] | (unsigned char)-p[i]) >> 7) ^ 1;
pad_count += ((pad_done | (unsigned char)-pad_done) >> 7) ^ 1;
}
p += pad_count;
bad |= *p++; /* Must be zero */
}
else
{
bad |= *p++ ^ MBEDTLS_RSA_SIGN;
/* Get padding len, but always read till end of buffer
* (minus one, for the 00 byte) */
for( i = 0; i < ilen - 3; i++ )
{
pad_done |= ( p[i] != 0xFF );
pad_count += ( pad_done == 0 );
}
p += pad_count;
bad |= *p++; /* Must be zero */
}
bad |= ( pad_count < 8 );
if( bad )
{
ret = MBEDTLS_ERR_RSA_INVALID_PADDING;
goto cleanup;
}
if( ilen - ( p - buf ) > output_max_len )
{
ret = MBEDTLS_ERR_RSA_OUTPUT_TOO_LARGE;
goto cleanup;
}
*olen = ilen - (p - buf);
memcpy( output, p, *olen );
ret = 0;
cleanup:
mbedtls_zeroize( buf, sizeof( buf ) );
return( ret );
} | 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 = 0xFFFFBF80
cmpq $-0x3f1, %rax # imm = 0xFC0F
jb 0x125c3
testl %ebp, %ebp
je 0x124d8
movq %rsp, %r8
movq %r9, %rcx
callq 0x1174f
jmp 0x124e3
movq %rsp, %rdx
movq %r9, %rsi
callq 0x11699
movl %eax, %r14d
testl %eax, %eax
jne 0x125b6
leaq -0x3(%r15), %rsi
movb (%rsp), %dl
movb 0x1(%rsp), %al
xorl %ecx, %ecx
xorl %edi, %edi
xorl %r8d, %r8d
cmpl $0x1, %ebp
jne 0x12539
cmpq %rdi, %rsi
je 0x1255c
xorl %r9d, %r9d
cmpb $0x0, 0x2(%rsp,%rdi)
sete %r9b
orl %r8d, %r9d
movl %r9d, %r10d
negl %r10d
movzbl %r10b, %r10d
orl %r8d, %r10d
shrl $0x7, %r10d
xorl $0x1, %r10d
addq %r10, %rcx
incq %rdi
movl %r9d, %r8d
jmp 0x12505
cmpq %rdi, %rsi
je 0x12561
xorl %r9d, %r9d
cmpb $-0x1, 0x2(%rsp,%rdi)
setne %r9b
xorl %r10d, %r10d
orl %r9d, %r8d
sete %r10b
addq %r10, %rcx
incq %rdi
jmp 0x12539
movb $0x2, %sil
jmp 0x12564
movb $0x1, %sil
xorb %sil, %al
orb 0x2(%rsp,%rcx), %al
orb %dl, %al
cmpq $0x8, %rcx
setb %dl
movl $0xffffbf00, %r14d # imm = 0xFFFFBF00
orb %al, %dl
jne 0x125b6
leaq 0x2(%rsp), %rax
leaq (%rax,%rcx), %rsi
incq %rsi
movq %rsp, %rdx
subq %rsi, %rdx
addq %r15, %rdx
movl $0xffffbc00, %r14d # imm = 0xFFFFBC00
cmpq 0x438(%rsp), %rdx
ja 0x125b6
movq 0x430(%rsp), %rdi
movq %rdx, (%rbx)
callq 0xb160
xorl %r14d, %r14d
movq %rsp, %rdi
movl $0x400, %esi # imm = 0x400
callq 0x1246f
movl %r14d, %eax
addq $0x408, %rsp # imm = 0x408
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
| /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 )
return( mbedtls_ecp_set_zero( pt ) );
else
return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
}
plen = mbedtls_mpi_size( &grp->P );
if( buf[0] != 0x04 )
return( MBEDTLS_ERR_ECP_FEATURE_UNAVAILABLE );
if( ilen != 2 * plen + 1 )
return( MBEDTLS_ERR_ECP_BAD_INPUT_DATA );
MBEDTLS_MPI_CHK( mbedtls_mpi_read_binary( &pt->X, buf + 1, plen ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_read_binary( &pt->Y, buf + 1 + plen, plen ) );
MBEDTLS_MPI_CHK( mbedtls_mpi_lset( &pt->Z, 1 ) );
cleanup:
return( ret );
} | 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)
jne 0x1dab3
leaq 0x1(,%r15,2), %rcx
movl $0xffffb080, %eax # imm = 0xFFFFB080
cmpq %r12, %rcx
jne 0x1dab3
incq %r14
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1a121
testl %eax, %eax
jne 0x1dab3
leaq 0x18(%rbx), %rdi
addq %r15, %r14
movq %r14, %rsi
movq %r15, %rdx
callq 0x1a121
testl %eax, %eax
jne 0x1dab3
addq $0x30, %rbx
pushq $0x1
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x19928
cmpq $0x1, %r12
jne 0x1dab3
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1d838
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /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, GetLocation()), 1ull << alignment_log2, offset));
} | 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)
movq %r14, 0x8(%r13)
movq 0x8(%rbx), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%r13)
leaq 0x58(%rsp), %r14
movq %r14, %rdi
movl %r12d, %esi
movq %r13, %rdx
callq 0x3e686
movl $0x1, %r12d
movl %r15d, %ecx
shlq %cl, %r12
movl $0xa0, %edi
callq 0x151f0
movq %rax, %r15
leaq 0xa0(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x3e6d4
leaq 0x30(%rsp), %r9
xorps %xmm0, %xmm0
movups %xmm0, 0xc(%r9)
movaps %xmm0, (%r9)
movq %r15, %rdi
movl %ebp, %esi
movq %r13, %rdx
movq %r12, %rcx
movq (%rsp), %r8
callq 0x221c6
movq %r13, %rdi
callq 0x3e814
leaq 0x8(%rsp), %r14
movq %r15, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1f410
movl %eax, %ebx
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1a0bf
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x3e814
movl %ebx, %eax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /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 # 0x817d0
movq %rax, (%r14)
leaq 0x50(%r14), %rax
movq %rax, 0x40(%r14)
movq $0x0, 0x48(%r14)
xorl %eax, %eax
movb %al, 0x50(%r14)
leaq 0x60(%r14), %r12
movb %al, 0x60(%r14)
leaq 0x68(%r14), %rdi
callq 0x3e66c
xorps %xmm0, %xmm0
movups %xmm0, 0x100(%r14)
movups %xmm0, 0xf0(%r14)
movups %xmm0, 0xe0(%r14)
movups %xmm0, 0xd0(%r14)
movups %xmm0, 0xc0(%r14)
movups %xmm0, 0xb0(%r14)
movl $0x0, 0x110(%r14)
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1f4fe
leaq 0x8(%rsp), %r15
movq %r14, (%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1f410
movl %eax, %ebp
movq (%r15), %rdi
testq %rdi, %rdi
je 0x1a22f
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
cmpl $0x1, %ebp
jne 0x1a24f
movl $0x1, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
addq $0xe0, %r14
movq %rbx, %rdi
movl $0x2, %esi
movq %r14, %rdx
xorl %ecx, %ecx
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1f2b6
| /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 %rax, 0x10(%r14)
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x3e686
movl $0x88, %edi
callq 0x151f0
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x24(%rax)
movl $0x9, 0x38(%rax)
leaq 0x67531(%rip), %rax # 0x81820
movq %rax, (%r14)
leaq 0x40(%r14), %rdi
movq %r15, %rsi
callq 0x3e72c
leaq 0x8(%rsp), %r15
movq %r14, (%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1f410
movl %eax, %ebx
movq (%r15), %rdi
testq %rdi, %rdi
je 0x1a321
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x3e814
movl %ebx, %eax
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
| /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 %rax, 0x10(%r14)
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x3e686
movl $0x88, %edi
callq 0x151f0
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x24(%rax)
movl $0xa, 0x38(%rax)
leaq 0x674b3(%rip), %rax # 0x81870
movq %rax, (%r14)
leaq 0x40(%r14), %rdi
movq %r15, %rsi
callq 0x3e72c
leaq 0x8(%rsp), %r15
movq %r14, (%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1f410
movl %eax, %ebx
movq (%r15), %rdi
testq %rdi, %rdi
je 0x1a3ef
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x3e814
movl %ebx, %eax
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
| /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 %rax, 0x10(%r14)
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x3e686
movl $0x88, %edi
callq 0x151f0
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x24(%rax)
movl $0xc, 0x38(%rax)
leaq 0x672d5(%rip), %rax # 0x81910
movq %rax, (%r14)
leaq 0x40(%r14), %rdi
movq %r15, %rsi
callq 0x3e72c
leaq 0x8(%rsp), %r15
movq %r14, (%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1f410
movl %eax, %ebx
movq (%r15), %rdi
testq %rdi, %rdi
je 0x1a66d
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x3e814
movl %ebx, %eax
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
| /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
callq 0x3e66c
movq %r15, 0x58(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rbx)
leaq 0x8(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x1f5da
movl %eax, %ebp
movq 0x68(%r15), %rdi
testq %rdi, %rdi
je 0x1a9e2
movq (%rdi), %rax
movq 0x8(%rdi), %r14
callq *0x8(%rax)
movq %r14, %rdi
testq %r14, %r14
jne 0x1a9d0
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rbx)
movq $0x0, 0x58(%rbx)
movq %rbx, %rdi
callq 0x3e814
movl %ebp, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
| /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(%rsp), %r15
movq %rax, (%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x1f410
movl %eax, %ebx
movq (%r15), %rdi
testq %rdi, %rdi
je 0x1aa68
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
| /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(%rsp), %r15
movq %rax, (%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x1f410
movl %eax, %ebx
movq (%r15), %rdi
testq %rdi, %rdi
je 0x1aadc
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
| /WebAssembly[P]wabt/src/binary-reader-ir.cc |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.