name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
llvm::SmallVectorTemplateBase<llvm::cl::Option*, true>::push_back(llvm::cl::Option*)
|
void push_back(ValueParamT Elt) {
const T *EltPtr = reserveForParamAndGetAddress(Elt);
memcpy(reinterpret_cast<void *>(this->end()), EltPtr, sizeof(T));
this->set_size(this->size() + 1);
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %edx
cmpl 0xc(%rdi), %edx
jae 0x5f1e1
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
movq %r14, (%rax,%rcx,8)
incl 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
incq %rdx
leaq 0x10(%rbx), %rsi
movl $0x8, %ecx
movq %rbx, %rdi
callq 0x56f14
jmp 0x5f1cc
nop
|
/llvm/ADT/SmallVector.h
|
llvm::ConvertUTF8toWide(unsigned int, llvm::StringRef, char*&, unsigned char const*&)
|
bool ConvertUTF8toWide(unsigned WideCharWidth, llvm::StringRef Source,
char *&ResultPtr, const UTF8 *&ErrorPtr) {
assert(WideCharWidth == 1 || WideCharWidth == 2 || WideCharWidth == 4);
ConversionResult result = conversionOK;
// Copy the character span over.
if (WideCharWidth == 1) {
const UTF8 *Pos = reinterpret_cast<const UTF8*>(Source.begin());
if (!isLegalUTF8String(&Pos, reinterpret_cast<const UTF8*>(Source.end()))) {
result = sourceIllegal;
ErrorPtr = Pos;
} else {
memcpy(ResultPtr, Source.data(), Source.size());
ResultPtr += Source.size();
}
} else if (WideCharWidth == 2) {
const UTF8 *sourceStart = (const UTF8*)Source.data();
// FIXME: Make the type of the result buffer correct instead of
// using reinterpret_cast.
UTF16 *targetStart = reinterpret_cast<UTF16 *>(ResultPtr);
ConversionFlags flags = strictConversion;
result =
ConvertUTF8toUTF16(&sourceStart, sourceStart + Source.size(),
&targetStart, targetStart + Source.size(), flags);
if (result == conversionOK)
ResultPtr = reinterpret_cast<char *>(targetStart);
else
ErrorPtr = sourceStart;
} else if (WideCharWidth == 4) {
const UTF8 *sourceStart = (const UTF8 *)Source.data();
// FIXME: Make the type of the result buffer correct instead of
// using reinterpret_cast.
UTF32 *targetStart = reinterpret_cast<UTF32 *>(ResultPtr);
ConversionFlags flags = strictConversion;
result =
ConvertUTF8toUTF32(&sourceStart, sourceStart + Source.size(),
&targetStart, targetStart + Source.size(), flags);
if (result == conversionOK)
ResultPtr = reinterpret_cast<char *>(targetStart);
else
ErrorPtr = sourceStart;
}
assert((result != targetExhausted) &&
"ConvertUTF8toUTFXX exhausted target buffer");
return result == conversionOK;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %r14
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r15
cmpl $0x4, %edi
je 0x5fb48
cmpl $0x2, %edi
je 0x5fb23
xorl %ebp, %ebp
cmpl $0x1, %edi
jne 0x5fb90
movq %rsp, %rdi
movq %r15, (%rdi)
leaq (%r15,%r12), %rsi
callq 0x75685
testb %al, %al
je 0x5fb84
movq (%rbx), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3c370
addq %r12, (%rbx)
jmp 0x5fb90
movq %rsp, %rdi
movq %r15, (%rdi)
movq (%rbx), %rax
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
addq %r12, %r15
leaq (%rax,%r12,2), %rcx
movq %r15, %rsi
xorl %r8d, %r8d
callq 0x756ee
jmp 0x5fb6b
movq %rsp, %rdi
movq %r15, (%rdi)
movq (%rbx), %rax
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
addq %r12, %r15
leaq (%rax,%r12,4), %rcx
movq %r15, %rsi
xorl %r8d, %r8d
callq 0x75b22
movl %eax, %ebp
testl %eax, %eax
je 0x5fb7a
movq (%rsp), %rax
movq %rax, (%r14)
jmp 0x5fb90
movq 0x8(%rsp), %rax
movq %rax, (%rbx)
jmp 0x5fb90
movq (%rsp), %rax
movq %rax, (%r14)
movl $0x3, %ebp
testl %ebp, %ebp
sete %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/Support/ConvertUTFWrapper.cpp
|
(anonymous namespace)::DebugCounterOwner::~DebugCounterOwner()
|
~DebugCounterOwner() {
if (ShouldPrintCounter)
print(dbgs());
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x61(%rdi)
jne 0x60906
callq 0x5ff49
movq %rbx, %rdi
movq %rax, %rsi
callq 0x60bca
leaq 0x210(%rbx), %r14
leaq 0x4572cc(%rip), %r15 # 0x4b7be0
addq $0x10, %r15
movq %r15, 0x210(%rbx)
movq 0x2c0(%rbx), %rax
testq %rax, %rax
je 0x6093c
leaq 0x2b0(%rbx), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %r14, %rdi
callq 0x5c52c
leaq 0x150(%rbx), %r14
movq %r15, 0x150(%rbx)
movq 0x200(%rbx), %rax
testq %rax, %rax
je 0x6096f
leaq 0x1f0(%rbx), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %r14, %rdi
callq 0x5c52c
leaq 0x4577ca(%rip), %rax # 0x4b8148
addq $0x10, %rax
movq %rax, 0x68(%rbx)
movq 0x140(%rbx), %rax
testq %rax, %rax
je 0x609a3
leaq 0x130(%rbx), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x68(%rbx), %r14
movq 0x110(%rbx), %rdi
testq %rdi, %rdi
je 0x609c2
movq 0x120(%rbx), %rsi
subq %rdi, %rsi
callq 0x3c080
leaq 0xf0(%rbx), %rdi
callq 0x61556
movq %r14, %rdi
callq 0x5c52c
leaq 0x18(%rbx), %r14
leaq 0x48(%rbx), %rdi
callq 0x5ff4e
movq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0x61ad8
movq %rbx, %rdi
callq 0x61b3c
movq (%rbx), %rdi
movl 0x10(%rbx), %esi
shlq $0x7, %rsi
movl $0x8, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x56dc8
|
/Support/DebugCounter.cpp
|
llvm::DebugCounter::getCounterInfo[abi:cxx11](unsigned int) const
|
std::pair<std::string, std::string> getCounterInfo(unsigned ID) const {
return std::make_pair(RegisteredCounters[ID], Counters.lookup(ID).Desc);
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
leaq 0x4(%rsp), %rax
movl %edx, (%rax)
leal -0x1(%rdx), %r14d
shlq $0x5, %r14
addq 0x48(%rsi), %r14
leaq 0x8(%rsp), %rdi
movq %rax, %rdx
callq 0x61720
leaq 0x20(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x617f2
movq 0x20(%r15), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x616f5
callq 0x3c3a0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x61710
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3c080
movq %rbx, %rax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/llvm/Support/DebugCounter.h
|
llvm::DenseMapBase<llvm::DenseMap<unsigned int, llvm::DebugCounter::CounterInfo, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::DebugCounter::CounterInfo>>, unsigned int, llvm::DebugCounter::CounterInfo, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::DebugCounter::CounterInfo>>::FindAndConstruct(unsigned int const&)
|
value_type& FindAndConstruct(const KeyT &Key) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return *TheBucket;
return *InsertIntoBucket(TheBucket, Key);
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x6185c
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x61c7f
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x61c8a
movl (%rbx), %ecx
movl %ecx, (%rax)
leaq 0x30(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x38(%rax)
movups %xmm0, 0x48(%rax)
xorl %edx, %edx
movq %rdx, 0x78(%rax)
movups %xmm0, 0x68(%rax)
movups %xmm0, 0x58(%rax)
movups %xmm0, 0x8(%rax)
movq %rcx, 0x20(%rax)
movq %rdx, 0x28(%rax)
movb $0x0, 0x30(%rax)
leaq 0x50(%rax), %rcx
movq %rcx, 0x40(%rax)
movabsq $0x300000000, %rcx # imm = 0x300000000
movq %rcx, 0x48(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
|
/llvm/ADT/DenseMap.h
|
llvm::ErrorList::log(llvm::raw_ostream&) const
|
void log(raw_ostream &OS) const override {
OS << "Multiple errors:\n";
for (const auto &ErrPayload : Payloads) {
ErrPayload->log(OS);
OS << "\n";
}
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2c1231(%rip), %rsi # 0x323820
movl $0x11, %edx
movq %rbx, %rdi
callq 0x577a6
movq 0x8(%r14), %r15
movq 0x10(%r14), %r12
cmpq %r12, %r15
je 0x62635
leaq 0x2ee940(%rip), %r14 # 0x350f50
movq (%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x577a6
addq $0x8, %r15
cmpq %r12, %r15
jne 0x62610
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/llvm/Support/Error.h
|
llvm::ManagedStaticBase::RegisterManagedStatic(void* (*)(), void (*)(void*)) const
|
void ManagedStaticBase::RegisterManagedStatic(void *(*Creator)(),
void (*Deleter)(void*)) const {
assert(Creator);
if (llvm_is_multithreaded()) {
std::lock_guard<std::recursive_mutex> Lock(*getManagedStaticMutex());
if (!Ptr.load(std::memory_order_relaxed)) {
void *Tmp = Creator();
Ptr.store(Tmp, std::memory_order_release);
DeleterFn = Deleter;
// Add to list of managed statics.
Next = StaticList;
StaticList = this;
}
} else {
assert(!Ptr && !DeleterFn && !Next &&
"Partially initialized ManagedStatic!?");
Ptr = Creator();
DeleterFn = Deleter;
// Add to list of managed statics.
Next = StaticList;
StaticList = this;
}
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x4781fb(%rip), %rdi # 0x4db360
callq 0x3c400
testl %eax, %eax
jne 0x631a3
movq (%rbx), %rax
testq %rax, %rax
jne 0x63192
callq *%r15
movq %rax, (%rbx)
movq %r14, 0x8(%rbx)
movq 0x4b3a01(%rip), %rax # 0x516b88
movq %rax, 0x10(%rbx)
movq %rbx, 0x4b39f6(%rip) # 0x516b88
leaq 0x4781c7(%rip), %rdi # 0x4db360
popq %rbx
popq %r14
popq %r15
jmp 0x3c3e0
movl %eax, %edi
callq 0x3c1b0
|
/Support/ManagedStatic.cpp
|
operator new(unsigned long, (anonymous namespace)::NamedBufferAlloc const&)
|
void *operator new(size_t N, const NamedBufferAlloc &Alloc) {
SmallString<256> NameBuf;
StringRef NameRef = Alloc.Name.toStringRef(NameBuf);
// We use malloc() and manually handle it returning null instead of calling
// operator new because we need all uses of NamedBufferAlloc to be
// deallocated with a call to free() due to needing to use malloc() in
// WritableMemoryBuffer::getNewUninitMemBuffer() to work around the out-of-
// memory handler installed by default in LLVM. See operator delete() member
// functions within this file for the paired call to free().
char *Mem =
static_cast<char *>(std::malloc(N + sizeof(size_t) + NameRef.size() + 1));
if (!Mem)
llvm::report_bad_alloc_error("Allocation failed");
*reinterpret_cast<size_t *>(Mem + N) = NameRef.size();
CopyStringRef(Mem + N + sizeof(size_t), NameRef);
return Mem;
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x120, %rsp # imm = 0x120
movq %rdi, %r14
leaq 0x20(%rsp), %r13
movq %r13, -0x18(%r13)
movq $0x0, -0x10(%r13)
movq $0x100, -0x8(%r13) # imm = 0x100
movq (%rsi), %rdi
leaq 0x8(%rsp), %rsi
callq 0x57944
movq %rax, %r12
movq %rdx, %r15
leaq (%r14,%rdx), %rdi
addq $0x9, %rdi
callq 0x3c5f0
testq %rax, %rax
je 0x6329d
movq %rax, %rbx
movq %r15, (%rax,%r14)
addq %rax, %r14
addq $0x8, %r14
testq %r15, %r15
je 0x63275
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3c370
movb $0x0, (%r14,%r15)
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x63289
callq 0x3c3a0
movq %rbx, %rax
addq $0x120, %rsp # imm = 0x120
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x2bee2d(%rip), %rdi # 0x3220d1
movl $0x1, %esi
callq 0x576e8
|
/Support/MemoryBuffer.cpp
|
llvm::MD5::body(llvm::ArrayRef<unsigned char>)
|
const uint8_t *MD5::body(ArrayRef<uint8_t> Data) {
const uint8_t *ptr;
MD5_u32plus a, b, c, d;
MD5_u32plus saved_a, saved_b, saved_c, saved_d;
unsigned long Size = Data.size();
ptr = Data.data();
a = InternalState.a;
b = InternalState.b;
c = InternalState.c;
d = InternalState.d;
do {
saved_a = a;
saved_b = b;
saved_c = c;
saved_d = d;
// Round 1
STEP(F, a, b, c, d, SET(0), 0xd76aa478, 7)
STEP(F, d, a, b, c, SET(1), 0xe8c7b756, 12)
STEP(F, c, d, a, b, SET(2), 0x242070db, 17)
STEP(F, b, c, d, a, SET(3), 0xc1bdceee, 22)
STEP(F, a, b, c, d, SET(4), 0xf57c0faf, 7)
STEP(F, d, a, b, c, SET(5), 0x4787c62a, 12)
STEP(F, c, d, a, b, SET(6), 0xa8304613, 17)
STEP(F, b, c, d, a, SET(7), 0xfd469501, 22)
STEP(F, a, b, c, d, SET(8), 0x698098d8, 7)
STEP(F, d, a, b, c, SET(9), 0x8b44f7af, 12)
STEP(F, c, d, a, b, SET(10), 0xffff5bb1, 17)
STEP(F, b, c, d, a, SET(11), 0x895cd7be, 22)
STEP(F, a, b, c, d, SET(12), 0x6b901122, 7)
STEP(F, d, a, b, c, SET(13), 0xfd987193, 12)
STEP(F, c, d, a, b, SET(14), 0xa679438e, 17)
STEP(F, b, c, d, a, SET(15), 0x49b40821, 22)
// Round 2
STEP(G, a, b, c, d, GET(1), 0xf61e2562, 5)
STEP(G, d, a, b, c, GET(6), 0xc040b340, 9)
STEP(G, c, d, a, b, GET(11), 0x265e5a51, 14)
STEP(G, b, c, d, a, GET(0), 0xe9b6c7aa, 20)
STEP(G, a, b, c, d, GET(5), 0xd62f105d, 5)
STEP(G, d, a, b, c, GET(10), 0x02441453, 9)
STEP(G, c, d, a, b, GET(15), 0xd8a1e681, 14)
STEP(G, b, c, d, a, GET(4), 0xe7d3fbc8, 20)
STEP(G, a, b, c, d, GET(9), 0x21e1cde6, 5)
STEP(G, d, a, b, c, GET(14), 0xc33707d6, 9)
STEP(G, c, d, a, b, GET(3), 0xf4d50d87, 14)
STEP(G, b, c, d, a, GET(8), 0x455a14ed, 20)
STEP(G, a, b, c, d, GET(13), 0xa9e3e905, 5)
STEP(G, d, a, b, c, GET(2), 0xfcefa3f8, 9)
STEP(G, c, d, a, b, GET(7), 0x676f02d9, 14)
STEP(G, b, c, d, a, GET(12), 0x8d2a4c8a, 20)
// Round 3
STEP(H, a, b, c, d, GET(5), 0xfffa3942, 4)
STEP(H, d, a, b, c, GET(8), 0x8771f681, 11)
STEP(H, c, d, a, b, GET(11), 0x6d9d6122, 16)
STEP(H, b, c, d, a, GET(14), 0xfde5380c, 23)
STEP(H, a, b, c, d, GET(1), 0xa4beea44, 4)
STEP(H, d, a, b, c, GET(4), 0x4bdecfa9, 11)
STEP(H, c, d, a, b, GET(7), 0xf6bb4b60, 16)
STEP(H, b, c, d, a, GET(10), 0xbebfbc70, 23)
STEP(H, a, b, c, d, GET(13), 0x289b7ec6, 4)
STEP(H, d, a, b, c, GET(0), 0xeaa127fa, 11)
STEP(H, c, d, a, b, GET(3), 0xd4ef3085, 16)
STEP(H, b, c, d, a, GET(6), 0x04881d05, 23)
STEP(H, a, b, c, d, GET(9), 0xd9d4d039, 4)
STEP(H, d, a, b, c, GET(12), 0xe6db99e5, 11)
STEP(H, c, d, a, b, GET(15), 0x1fa27cf8, 16)
STEP(H, b, c, d, a, GET(2), 0xc4ac5665, 23)
// Round 4
STEP(I, a, b, c, d, GET(0), 0xf4292244, 6)
STEP(I, d, a, b, c, GET(7), 0x432aff97, 10)
STEP(I, c, d, a, b, GET(14), 0xab9423a7, 15)
STEP(I, b, c, d, a, GET(5), 0xfc93a039, 21)
STEP(I, a, b, c, d, GET(12), 0x655b59c3, 6)
STEP(I, d, a, b, c, GET(3), 0x8f0ccc92, 10)
STEP(I, c, d, a, b, GET(10), 0xffeff47d, 15)
STEP(I, b, c, d, a, GET(1), 0x85845dd1, 21)
STEP(I, a, b, c, d, GET(8), 0x6fa87e4f, 6)
STEP(I, d, a, b, c, GET(15), 0xfe2ce6e0, 10)
STEP(I, c, d, a, b, GET(6), 0xa3014314, 15)
STEP(I, b, c, d, a, GET(13), 0x4e0811a1, 21)
STEP(I, a, b, c, d, GET(4), 0xf7537e82, 6)
STEP(I, d, a, b, c, GET(11), 0xbd3af235, 10)
STEP(I, c, d, a, b, GET(2), 0x2ad7d2bb, 15)
STEP(I, b, c, d, a, GET(9), 0xeb86d391, 21)
a += saved_a;
b += saved_b;
c += saved_c;
d += saved_d;
ptr += 64;
} while (Size -= 64);
InternalState.a = a;
InternalState.b = b;
InternalState.c = c;
InternalState.d = d;
return ptr;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rax
movl (%rdi), %r10d
movl 0x4(%rdi), %r9d
movl 0x8(%rdi), %r8d
movq %rdi, -0x60(%rsp)
movl 0xc(%rdi), %ecx
movq %rax, -0x18(%rsp)
movq %r9, -0x28(%rsp)
movq %rdx, (%rsp)
movl %r10d, -0x3c(%rsp)
movl %r8d, %esi
movl %ecx, %edx
movl %r8d, %ecx
xorl %edx, %ecx
andl %r9d, %ecx
xorl %edx, %ecx
movq %rdx, %r8
movq %rdx, -0x8(%rsp)
movl (%rax), %edx
movq %rdx, -0x30(%rsp)
movq -0x60(%rsp), %rdi
movl %edx, 0x58(%rdi)
addl %r10d, %ecx
addl %edx, %ecx
addl $0xd76aa478, %ecx # imm = 0xD76AA478
roll $0x7, %ecx
movl %r9d, %edx
addl %r9d, %ecx
xorl %esi, %edx
andl %ecx, %edx
movl 0x4(%rax), %ebx
movq %rbx, -0x58(%rsp)
xorl %esi, %edx
movq %rsi, %r10
movq %rsi, -0x10(%rsp)
leal (%r8,%rbx), %esi
leal (%rdx,%rsi), %r11d
addl $0xe8c7b756, %r11d # imm = 0xE8C7B756
roll $0xc, %r11d
movl %ebx, 0x5c(%rdi)
movl %ecx, %esi
xorl %r9d, %esi
addl %ecx, %r11d
andl %r11d, %esi
xorl %r9d, %esi
movl 0x8(%rax), %edx
movl %edx, 0x60(%rdi)
leal (%r10,%rdx), %r8d
movq %rdx, %r14
addl %r8d, %esi
addl $0x242070db, %esi # imm = 0x242070DB
roll $0x11, %esi
addl %r11d, %esi
movl %r11d, %r8d
xorl %ecx, %r8d
andl %esi, %r8d
xorl %ecx, %r8d
movl 0xc(%rax), %r9d
movq %r9, -0x38(%rsp)
movl %r9d, 0x64(%rdi)
movq -0x28(%rsp), %rdx
addl %edx, %r9d
addl %r8d, %r9d
addl $0xc1bdceee, %r9d # imm = 0xC1BDCEEE
roll $0x16, %r9d
addl %esi, %r9d
movl %esi, %r8d
xorl %r11d, %r8d
andl %r9d, %r8d
xorl %r11d, %r8d
movl 0x10(%rax), %edx
movl %edx, -0x70(%rsp)
movl %edx, 0x68(%rdi)
addl %edx, %ecx
addl %r8d, %ecx
addl $0xf57c0faf, %ecx # imm = 0xF57C0FAF
roll $0x7, %ecx
movl %r9d, %r8d
addl %r9d, %ecx
xorl %esi, %r8d
andl %ecx, %r8d
movl 0x14(%rax), %edx
movl %edx, -0x7c(%rsp)
xorl %esi, %r8d
addl %edx, %r11d
addl %r8d, %r11d
addl $0x4787c62a, %r11d # imm = 0x4787C62A
roll $0xc, %r11d
movl %edx, 0x6c(%rdi)
movl %ecx, %edx
xorl %r9d, %edx
addl %ecx, %r11d
andl %r11d, %edx
xorl %r9d, %edx
movl 0x18(%rax), %r8d
movl %r8d, 0x70(%rdi)
addl %r8d, %esi
movl %r8d, -0x64(%rsp)
addl %edx, %esi
addl $0xa8304613, %esi # imm = 0xA8304613
roll $0x11, %esi
addl %r11d, %esi
movl %r11d, %edx
xorl %ecx, %edx
andl %esi, %edx
xorl %ecx, %edx
movl 0x1c(%rax), %r10d
movl %r10d, -0x40(%rsp)
addl %r10d, %r9d
addl %r9d, %edx
addl $0xfd469501, %edx # imm = 0xFD469501
movl %r10d, 0x74(%rdi)
roll $0x16, %edx
addl %esi, %edx
movl %esi, %r9d
xorl %r11d, %r9d
andl %edx, %r9d
xorl %r11d, %r9d
movl 0x20(%rax), %r10d
movl %r10d, -0x74(%rsp)
addl %r10d, %ecx
addl %r9d, %ecx
addl $0x698098d8, %ecx # imm = 0x698098D8
movl %r10d, 0x78(%rdi)
roll $0x7, %ecx
addl %edx, %ecx
movl %edx, %r9d
xorl %esi, %r9d
andl %ecx, %r9d
xorl %esi, %r9d
movl 0x24(%rax), %r10d
addl %r10d, %r11d
addl %r9d, %r11d
addl $0x8b44f7af, %r11d # imm = 0x8B44F7AF
roll $0xc, %r11d
movl %r10d, 0x7c(%rdi)
movl %r10d, -0x68(%rsp)
movl %ecx, %r15d
xorl %edx, %r15d
addl %ecx, %r11d
andl %r11d, %r15d
xorl %edx, %r15d
movl 0x28(%rax), %ebx
addl %ebx, %esi
leal (%r15,%rsi), %ebp
addl $0xffff5bb1, %ebp # imm = 0xFFFF5BB1
movl %ebx, 0x80(%rdi)
movl %ebx, -0x4c(%rsp)
roll $0x11, %ebp
addl %r11d, %ebp
movl %r11d, %esi
xorl %ecx, %esi
andl %ebp, %esi
xorl %ecx, %esi
movl 0x2c(%rax), %r9d
addl %r9d, %edx
leal (%rsi,%rdx), %r15d
addl $0x895cd7be, %r15d # imm = 0x895CD7BE
movl %r9d, 0x84(%rdi)
movl %r9d, %esi
movl %r9d, -0x6c(%rsp)
roll $0x16, %r15d
addl %ebp, %r15d
movl %ebp, %edx
xorl %r11d, %edx
andl %r15d, %edx
xorl %r11d, %edx
movl 0x30(%rax), %r9d
movl %r9d, -0x48(%rsp)
addl %r9d, %ecx
addl %edx, %ecx
addl $0x6b901122, %ecx # imm = 0x6B901122
movl %r9d, 0x88(%rdi)
roll $0x7, %ecx
addl %r15d, %ecx
movl %r15d, %edx
xorl %ebp, %edx
andl %ecx, %edx
xorl %ebp, %edx
movl 0x34(%rax), %r9d
movl %r9d, -0x78(%rsp)
addl %r9d, %r11d
leal (%rdx,%r11), %r12d
addl $0xfd987193, %r12d # imm = 0xFD987193
roll $0xc, %r12d
movl %r9d, 0x8c(%rdi)
movl %ecx, %r11d
xorl %r15d, %r11d
addl %ecx, %r12d
andl %r12d, %r11d
xorl %r15d, %r11d
movl 0x38(%rax), %r9d
addl %r9d, %ebp
addl %r11d, %ebp
addl $0xa679438e, %ebp # imm = 0xA679438E
movl %r9d, 0x90(%rdi)
roll $0x11, %ebp
addl %r12d, %ebp
movl %r12d, %r13d
xorl %ecx, %r13d
andl %ebp, %r13d
xorl %ecx, %r13d
movl 0x3c(%rax), %edx
addl %edx, %r15d
movl %edx, %eax
movl %edx, -0x44(%rsp)
addl %r13d, %r15d
addl $0x49b40821, %r15d # imm = 0x49B40821
roll $0x16, %r15d
addl %ebp, %r15d
movl %r15d, %r13d
xorl %ebp, %r13d
andl %r12d, %r13d
addl -0x58(%rsp), %ecx
xorl %ebp, %r13d
addl %ecx, %r13d
addl $0xf61e2562, %r13d # imm = 0xF61E2562
roll $0x5, %r13d
addl %r15d, %r13d
movl %r13d, %ecx
xorl %r15d, %ecx
andl %ebp, %ecx
xorl %r15d, %ecx
addl %r8d, %r12d
addl %ecx, %r12d
addl $0xc040b340, %r12d # imm = 0xC040B340
roll $0x9, %r12d
addl %r13d, %r12d
movl %r12d, %ecx
xorl %r13d, %ecx
andl %r15d, %ecx
xorl %r13d, %ecx
addl %esi, %ebp
addl %ebp, %ecx
addl $0x265e5a51, %ecx # imm = 0x265E5A51
roll $0xe, %ecx
addl %r12d, %ecx
movl %ecx, %ebp
xorl %r12d, %ebp
andl %r13d, %ebp
addl -0x30(%rsp), %r15d
xorl %r12d, %ebp
addl %r15d, %ebp
addl $0xe9b6c7aa, %ebp # imm = 0xE9B6C7AA
roll $0x14, %ebp
addl %ecx, %ebp
movl %ebp, %r15d
xorl %ecx, %r15d
andl %r12d, %r15d
xorl %ecx, %r15d
movl -0x7c(%rsp), %edx
addl %edx, %r13d
addl %r15d, %r13d
addl $0xd62f105d, %r13d # imm = 0xD62F105D
roll $0x5, %r13d
addl %ebp, %r13d
movl %r13d, %r15d
xorl %ebp, %r15d
andl %ecx, %r15d
xorl %ebp, %r15d
addl %ebx, %r12d
addl %r12d, %r15d
addl $0x2441453, %r15d # imm = 0x2441453
roll $0x9, %r15d
addl %r13d, %r15d
movl %r15d, %r12d
xorl %r13d, %r12d
andl %ebp, %r12d
addl %eax, %ecx
xorl %r13d, %r12d
addl %ecx, %r12d
addl $0xd8a1e681, %r12d # imm = 0xD8A1E681
roll $0xe, %r12d
addl %r15d, %r12d
movl %r12d, %ecx
xorl %r15d, %ecx
andl %r13d, %ecx
xorl %r15d, %ecx
movl -0x70(%rsp), %edi
addl %edi, %ebp
addl %ecx, %ebp
addl $0xe7d3fbc8, %ebp # imm = 0xE7D3FBC8
roll $0x14, %ebp
addl %r12d, %ebp
movl %ebp, %ecx
xorl %r12d, %ecx
andl %r15d, %ecx
xorl %r12d, %ecx
addl %r10d, %r13d
addl %r13d, %ecx
addl $0x21e1cde6, %ecx # imm = 0x21E1CDE6
roll $0x5, %ecx
addl %ebp, %ecx
movl %ecx, %r13d
xorl %ebp, %r13d
andl %r12d, %r13d
movl %r9d, -0x50(%rsp)
addl %r9d, %r15d
xorl %ebp, %r13d
addl %r13d, %r15d
addl $0xc33707d6, %r15d # imm = 0xC33707D6
roll $0x9, %r15d
addl %ecx, %r15d
movl %r15d, %r13d
xorl %ecx, %r13d
andl %ebp, %r13d
xorl %ecx, %r13d
movq -0x38(%rsp), %r8
addl %r8d, %r12d
addl %r13d, %r12d
addl $0xf4d50d87, %r12d # imm = 0xF4D50D87
roll $0xe, %r12d
addl %r15d, %r12d
movl %r12d, %r13d
xorl %r15d, %r13d
andl %ecx, %r13d
xorl %r15d, %r13d
movl -0x74(%rsp), %r10d
addl %r10d, %ebp
addl %ebp, %r13d
addl $0x455a14ed, %r13d # imm = 0x455A14ED
roll $0x14, %r13d
addl %r12d, %r13d
movl %r13d, %ebp
xorl %r12d, %ebp
andl %r15d, %ebp
movl -0x78(%rsp), %eax
addl %eax, %ecx
xorl %r12d, %ebp
addl %ebp, %ecx
addl $0xa9e3e905, %ecx # imm = 0xA9E3E905
roll $0x5, %ecx
addl %r13d, %ecx
movl %ecx, %ebp
xorl %r13d, %ebp
andl %r12d, %ebp
xorl %r13d, %ebp
movq %r14, %r11
movq %r14, -0x20(%rsp)
addl %r11d, %r15d
addl %ebp, %r15d
addl $0xfcefa3f8, %r15d # imm = 0xFCEFA3F8
roll $0x9, %r15d
addl %ecx, %r15d
movl %r15d, %ebp
xorl %ecx, %ebp
andl %r13d, %ebp
xorl %ecx, %ebp
movl -0x40(%rsp), %esi
addl %esi, %r12d
leal (%r12,%rbp), %ebx
addl $0x676f02d9, %ebx # imm = 0x676F02D9
roll $0xe, %ebx
addl %r15d, %ebx
movl %ebx, %r12d
xorl %r15d, %r12d
movl %r12d, %ebp
andl %ecx, %ebp
xorl %r15d, %ebp
movl -0x48(%rsp), %r14d
addl %r14d, %r13d
addl %ebp, %r13d
addl $0x8d2a4c8a, %r13d # imm = 0x8D2A4C8A
roll $0x14, %r13d
addl %ebx, %r13d
addl %edx, %ecx
xorl %r13d, %r12d
addl %r12d, %ecx
addl $0xfffa3942, %ecx # imm = 0xFFFA3942
roll $0x4, %ecx
addl %r13d, %ecx
movl %r13d, %r12d
xorl %ebx, %r12d
addl %r10d, %r15d
xorl %ecx, %r12d
addl %r12d, %r15d
addl $0x8771f681, %r15d # imm = 0x8771F681
roll $0xb, %r15d
addl %ecx, %r15d
movl %ecx, %r12d
xorl %r13d, %r12d
addl -0x6c(%rsp), %ebx
xorl %r15d, %r12d
addl %ebx, %r12d
addl $0x6d9d6122, %r12d # imm = 0x6D9D6122
roll $0x10, %r12d
addl %r15d, %r12d
movl %r15d, %ebx
xorl %ecx, %ebx
addl %r9d, %r13d
xorl %r12d, %ebx
addl %ebx, %r13d
addl $0xfde5380c, %r13d # imm = 0xFDE5380C
roll $0x17, %r13d
addl %r12d, %r13d
movl %r12d, %ebx
xorl %r15d, %ebx
addl -0x58(%rsp), %ecx
xorl %r13d, %ebx
addl %ebx, %ecx
addl $0xa4beea44, %ecx # imm = 0xA4BEEA44
roll $0x4, %ecx
addl %r13d, %ecx
movl %r13d, %ebx
xorl %r12d, %ebx
addl %edi, %r15d
xorl %ecx, %ebx
addl %ebx, %r15d
addl $0x4bdecfa9, %r15d # imm = 0x4BDECFA9
roll $0xb, %r15d
addl %ecx, %r15d
movl %ecx, %ebx
xorl %r13d, %ebx
addl %esi, %r12d
movl %esi, %r10d
xorl %r15d, %ebx
addl %ebx, %r12d
addl $0xf6bb4b60, %r12d # imm = 0xF6BB4B60
roll $0x10, %r12d
addl %r15d, %r12d
movl %r15d, %ebx
xorl %ecx, %ebx
movl -0x4c(%rsp), %r9d
addl %r9d, %r13d
xorl %r12d, %ebx
addl %ebx, %r13d
addl $0xbebfbc70, %r13d # imm = 0xBEBFBC70
roll $0x17, %r13d
addl %r12d, %r13d
movl %r12d, %ebx
xorl %r15d, %ebx
addl %eax, %ecx
movq -0x18(%rsp), %rax
xorl %r13d, %ebx
addl %ebx, %ecx
addl $0x289b7ec6, %ecx # imm = 0x289B7EC6
roll $0x4, %ecx
addl %r13d, %ecx
movl %r13d, %ebx
xorl %r12d, %ebx
movq -0x30(%rsp), %rdx
addl %edx, %r15d
xorl %ecx, %ebx
addl %ebx, %r15d
addl $0xeaa127fa, %r15d # imm = 0xEAA127FA
roll $0xb, %r15d
addl %ecx, %r15d
movl %ecx, %ebx
xorl %r13d, %ebx
addl %r8d, %r12d
xorl %r15d, %ebx
leal (%rbx,%r12), %ebp
addl $0xd4ef3085, %ebp # imm = 0xD4EF3085
roll $0x10, %ebp
addl %r15d, %ebp
movl %r15d, %ebx
xorl %ecx, %ebx
addl -0x64(%rsp), %r13d
xorl %ebp, %ebx
addl %ebx, %r13d
addl $0x4881d05, %r13d # imm = 0x4881D05
roll $0x17, %r13d
addl %ebp, %r13d
movl %ebp, %ebx
xorl %r15d, %ebx
addl -0x68(%rsp), %ecx
xorl %r13d, %ebx
leal (%rbx,%rcx), %r12d
addl $0xd9d4d039, %r12d # imm = 0xD9D4D039
roll $0x4, %r12d
addl %r13d, %r12d
movl %r13d, %ecx
xorl %ebp, %ecx
movl %r14d, %esi
addl %r14d, %r15d
xorl %r12d, %ecx
addl %ecx, %r15d
addl $0xe6db99e5, %r15d # imm = 0xE6DB99E5
roll $0xb, %r15d
addl %r12d, %r15d
movl %r12d, %ecx
xorl %r13d, %ecx
movl -0x44(%rsp), %edi
addl %edi, %ebp
xorl %r15d, %ecx
addl %ecx, %ebp
addl $0x1fa27cf8, %ebp # imm = 0x1FA27CF8
roll $0x10, %ebp
addl %r15d, %ebp
movl %r15d, %ecx
xorl %r12d, %ecx
addl %r11d, %r13d
xorl %ebp, %ecx
addl %r13d, %ecx
addl $0xc4ac5665, %ecx # imm = 0xC4AC5665
addl %edx, %r12d
roll $0x17, %ecx
addl %ebp, %ecx
movl %r15d, %ebx
notl %ebx
orl %ecx, %ebx
xorl %ebp, %ebx
leal (%rbx,%r12), %r14d
addl $0xf4292244, %r14d # imm = 0xF4292244
roll $0x6, %r14d
addl %r10d, %r15d
movl %ebp, %r8d
notl %r8d
addl %ecx, %r14d
orl %r14d, %r8d
xorl %ecx, %r8d
addl %r15d, %r8d
addl $0x432aff97, %r8d # imm = 0x432AFF97
addl -0x50(%rsp), %ebp
roll $0xa, %r8d
addl %r14d, %r8d
movl %ecx, %edx
notl %edx
orl %r8d, %edx
xorl %r14d, %edx
addl %ebp, %edx
addl $0xab9423a7, %edx # imm = 0xAB9423A7
addl -0x7c(%rsp), %ecx
roll $0xf, %edx
addl %r8d, %edx
movl %r14d, %r10d
notl %r10d
orl %edx, %r10d
xorl %r8d, %r10d
addl %r10d, %ecx
addl $0xfc93a039, %ecx # imm = 0xFC93A039
addl %esi, %r14d
roll $0x15, %ecx
addl %edx, %ecx
movl %r8d, %esi
notl %esi
orl %ecx, %esi
xorl %edx, %esi
addl %r14d, %esi
addl $0x655b59c3, %esi # imm = 0x655B59C3
roll $0x6, %esi
addl -0x38(%rsp), %r8d
movl %edx, %r10d
notl %r10d
addl %ecx, %esi
orl %esi, %r10d
xorl %ecx, %r10d
addl %r10d, %r8d
addl $0x8f0ccc92, %r8d # imm = 0x8F0CCC92
addl %r9d, %edx
roll $0xa, %r8d
addl %esi, %r8d
movl %ecx, %r9d
notl %r9d
orl %r8d, %r9d
xorl %esi, %r9d
addl %r9d, %edx
addl $0xffeff47d, %edx # imm = 0xFFEFF47D
addl -0x58(%rsp), %ecx
roll $0xf, %edx
addl %r8d, %edx
movl %esi, %r9d
notl %r9d
orl %edx, %r9d
xorl %r8d, %r9d
leal (%r9,%rcx), %r10d
addl $0x85845dd1, %r10d # imm = 0x85845DD1
roll $0x15, %r10d
addl %edx, %r10d
addl -0x74(%rsp), %esi
movl %r8d, %ecx
notl %ecx
orl %r10d, %ecx
xorl %edx, %ecx
leal (%rcx,%rsi), %r9d
addl $0x6fa87e4f, %r9d # imm = 0x6FA87E4F
roll $0x6, %r9d
movl %edx, %ecx
notl %ecx
addl %r10d, %r9d
orl %r9d, %ecx
xorl %r10d, %ecx
addl %edi, %r8d
addl %r8d, %ecx
addl $0xfe2ce6e0, %ecx # imm = 0xFE2CE6E0
roll $0xa, %ecx
addl -0x64(%rsp), %edx
addl %r9d, %ecx
movl %r10d, %esi
notl %esi
orl %ecx, %esi
xorl %r9d, %esi
leal (%rsi,%rdx), %r8d
addl $0xa3014314, %r8d # imm = 0xA3014314
roll $0xf, %r8d
addl %ecx, %r8d
addl -0x78(%rsp), %r10d
movl %r9d, %edx
notl %edx
orl %r8d, %edx
xorl %ecx, %edx
leal (%rdx,%r10), %esi
addl $0x4e0811a1, %esi # imm = 0x4E0811A1
roll $0x15, %esi
addl -0x70(%rsp), %r9d
movl %ecx, %edx
notl %edx
addl %r8d, %esi
orl %esi, %edx
xorl %r8d, %edx
leal (%rdx,%r9), %r10d
addl $0xf7537e82, %r10d # imm = 0xF7537E82
movq -0x60(%rsp), %rdx
movl %edi, 0x94(%rdx)
roll $0x6, %r10d
addl -0x6c(%rsp), %ecx
addl %esi, %r10d
movl %r8d, %r9d
notl %r9d
orl %r10d, %r9d
xorl %esi, %r9d
addl %r9d, %ecx
addl $0xbd3af235, %ecx # imm = 0xBD3AF235
roll $0xa, %ecx
addl %r10d, %ecx
addl -0x20(%rsp), %r8d
movl %esi, %r9d
notl %r9d
orl %ecx, %r9d
xorl %r10d, %r9d
addl %r9d, %r8d
addl $0x2ad7d2bb, %r8d # imm = 0x2AD7D2BB
roll $0xf, %r8d
addl -0x68(%rsp), %esi
movl %r10d, %r9d
notl %r9d
addl %ecx, %r8d
orl %r8d, %r9d
xorl %ecx, %r9d
addl %r9d, %esi
addl $0xeb86d391, %esi # imm = 0xEB86D391
movq -0x28(%rsp), %r9
movq (%rsp), %rdx
addl -0x3c(%rsp), %r10d
roll $0x15, %esi
addl %r8d, %r9d
addl %esi, %r9d
addl -0x10(%rsp), %r8d
addl -0x8(%rsp), %ecx
addq $0x40, %rax
addq $-0x40, %rdx
jne 0x63505
movq -0x60(%rsp), %rsi
movl %r10d, (%rsi)
movl %r9d, 0x4(%rsi)
movl %r8d, 0x8(%rsi)
movl %ecx, 0xc(%rsi)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/Support/MD5.cpp
|
writeWithCommas(llvm::raw_ostream&, llvm::ArrayRef<char>)
|
static void writeWithCommas(raw_ostream &S, ArrayRef<char> Buffer) {
assert(!Buffer.empty());
ArrayRef<char> ThisGroup;
int InitialDigits = ((Buffer.size() - 1) % 3) + 1;
ThisGroup = Buffer.take_front(InitialDigits);
S.write(ThisGroup.data(), ThisGroup.size());
Buffer = Buffer.drop_front(InitialDigits);
assert(Buffer.size() % 3 == 0);
while (!Buffer.empty()) {
S << ',';
ThisGroup = Buffer.take_front(3);
S.write(ThisGroup.data(), 3);
Buffer = Buffer.drop_front(3);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x1(%rdx), %r12
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
movq %r12, %rax
mulq %r13
shrq %rdx
leaq (%rdx,%rdx,2), %rax
negq %rax
leaq (%r15,%rax), %rbp
decq %rbp
incq %rbp
cmpq %rbp, %r15
movq %rbp, %rdx
cmovbq %r15, %rdx
callq 0x582a2
cmpq %rbp, %r15
je 0x64613
movq %r12, %rax
mulq %r13
shrq %rdx
leaq (%rdx,%rdx,2), %r12
negq %r12
addq %r15, %rbx
movq 0x20(%r14), %rax
cmpq 0x18(%r14), %rax
jae 0x645ef
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%r14)
movb $0x2c, (%rax)
jmp 0x645fc
movq %r14, %rdi
movl $0x2c, %esi
callq 0x5822c
leaq (%rbx,%r12), %rsi
movl $0x3, %edx
movq %r14, %rdi
callq 0x582a2
addq $0x3, %r12
jne 0x645d8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/Support/NativeFormatting.cpp
|
llvm::StringSaver::save(llvm::StringRef)
|
StringRef StringSaver::save(StringRef S) {
char *P = Alloc.Allocate<char>(S.size() + 1);
if (!S.empty())
memcpy(P, S.data(), S.size());
P[S.size()] = '\0';
return StringRef(P, S.size());
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq (%rdi), %rdi
leaq 0x1(%rdx), %rsi
xorl %edx, %edx
callq 0x6515a
movq %rax, %r15
testq %rbx, %rbx
je 0x65149
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3c370
movb $0x0, (%r15,%rbx)
movq %r15, %rax
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
retq
|
/Support/StringSaver.cpp
|
llvm::StringRef::find_first_of(llvm::StringRef, unsigned long) const
|
StringRef::size_type StringRef::find_first_of(StringRef Chars,
size_t From) const {
std::bitset<1 << CHAR_BIT> CharBits;
for (char C : Chars)
CharBits.set((unsigned char)C);
for (size_type i = std::min(From, Length), e = Length; i != e; ++i)
if (CharBits.test((unsigned char)Data[i]))
return i;
return npos;
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
testq %rdx, %rdx
je 0x656f5
xorl %eax, %eax
movzbl (%rsi,%rax), %ecx
movl $0x1, %edi
shlq %cl, %rdi
shrl $0x6, %ecx
orq %rdi, (%rsp,%rcx,8)
incq %rax
cmpq %rax, %rdx
jne 0x656da
movq 0x8(%r14), %r13
movq $-0x1, %r15
cmpq %rbx, %r13
jbe 0x65728
movq %rsp, %r12
movq (%r14), %rax
movzbl (%rax,%rbx), %esi
movq %r12, %rdi
callq 0x6573a
testb %al, %al
jne 0x65725
incq %rbx
cmpq %rbx, %r13
jne 0x65708
jmp 0x65728
movq %rbx, %r15
movq %r15, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/Support/StringRef.cpp
|
llvm::StringRef::split(llvm::SmallVectorImpl<llvm::StringRef>&, char, int, bool) const
|
void StringRef::split(SmallVectorImpl<StringRef> &A, char Separator,
int MaxSplit, bool KeepEmpty) const {
StringRef S = *this;
// Count down from MaxSplit. When MaxSplit is -1, this will just split
// "forever". This doesn't support splitting more than 2^31 times
// intentionally; if we ever want that we can make MaxSplit a 64-bit integer
// but that seems unlikely to be useful.
while (MaxSplit-- != 0) {
size_t Idx = S.find(Separator);
if (Idx == npos)
break;
// Push this split.
if (KeepEmpty || Idx > 0)
A.push_back(S.slice(0, Idx));
// Jump forward.
S = S.slice(Idx + 1, npos);
}
// Push the tail.
if (KeepEmpty || !S.empty())
A.push_back(S);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r12d
movl %edx, %r13d
movq %rsi, 0x10(%rsp)
movq (%rdi), %r15
movq 0x8(%rdi), %r14
incl %r12d
movl %r8d, 0xc(%rsp)
movl %r8d, %ebp
xorb $0x1, %bpl
decl %r12d
je 0x65aac
testq %r14, %r14
je 0x65a66
movq %r15, %rdi
movl %r13d, %esi
movq %r14, %rdx
callq 0x3c420
movq %rax, %rcx
subq %r15, %rcx
cmpq $0x1, %rax
movl $0x0, %ebx
sbbq %rbx, %rbx
orq %rcx, %rbx
jmp 0x65a6d
movq $-0x1, %rbx
cmpq $-0x1, %rbx
je 0x65aa6
testq %rbx, %rbx
sete %al
testb %bpl, %al
jne 0x65a95
cmpq %r14, %rbx
movq %r14, %rdx
cmovbq %rbx, %rdx
movq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x5a2a4
leaq 0x1(%rbx), %rax
cmpq %rax, %r14
cmovbq %r14, %rax
addq %rax, %r15
subq %rax, %r14
cmpq $-0x1, %rbx
jne 0x65a37
cmpb $0x0, 0xc(%rsp)
jne 0x65ac7
testq %r14, %r14
jne 0x65ac7
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5a2a4
|
/Support/StringRef.cpp
|
llvm::APInt::operator<<=(unsigned int)
|
APInt &operator<<=(unsigned ShiftAmt) {
assert(ShiftAmt <= BitWidth && "Invalid shift amount");
if (isSingleWord()) {
if (ShiftAmt == BitWidth)
U.VAL = 0;
else
U.VAL <<= ShiftAmt;
return clearUnusedBits();
}
shlSlowCase(ShiftAmt);
return *this;
}
|
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %eax
cmpl $0x40, %eax
ja 0x660aa
movq (%rbx), %rdx
movl %esi, %ecx
shlq %cl, %rdx
xorl %ecx, %ecx
cmpl %esi, %eax
cmovneq %rdx, %rcx
movq %rcx, (%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x661d4
movq %rbx, %rdi
callq 0x72674
movq %rbx, %rax
popq %rbx
retq
nop
|
/llvm/ADT/APInt.h
|
void llvm::SmallVectorImpl<unsigned int>::resizeImpl<false>(unsigned long)
|
size_t size() const { return Size; }
|
movl 0x8(%rdi), %eax
cmpq %rsi, %rax
je 0x664f7
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
ja 0x664ec
movl 0xc(%r14), %eax
cmpq %rbx, %rax
jae 0x664c7
leaq 0x10(%r14), %rsi
movl $0x4, %ecx
movq %r14, %rdi
movq %rbx, %rdx
callq 0x56f14
movl 0x8(%r14), %eax
cmpq %rbx, %rax
je 0x664ec
shlq $0x2, %rax
movq (%r14), %rdi
addq %rax, %rdi
leaq (,%rbx,4), %rdx
subq %rax, %rdx
xorl %esi, %esi
callq 0x3c160
movl %ebx, 0x8(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/llvm/ADT/SmallVector.h
|
llvm::TimerGroup::TimerGroup(llvm::StringRef, llvm::StringRef)
|
TimerGroup::TimerGroup(StringRef Name, StringRef Description)
: Name(Name.begin(), Name.end()),
Description(Description.begin(), Description.end()) {
// Add the group to TimerGroupList.
sys::SmartScopedLock<true> L(*TimerLock);
if (TimerGroupList)
TimerGroupList->Prev = &Next;
Next = TimerGroupList;
Prev = &TimerGroupList;
TimerGroupList = this;
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %rbx
addq %rsi, %rdx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
callq 0x56cf6
leaq 0x20(%rbx), %rdi
addq %r15, %r14
leaq 0x30(%rbx), %rax
movq %rax, 0x20(%rbx)
movq %r15, %rsi
movq %r14, %rdx
callq 0x56cf6
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x40(%rbx)
movq 0x4b0139(%rip), %rax # 0x516c18
testq %rax, %rax
jne 0x66afe
leaq 0x4b012d(%rip), %rdi # 0x516c18
leaq -0xa8e2(%rip), %rsi # 0x5c210
leaq -0xa8bf(%rip), %rdx # 0x5c23a
callq 0x63150
movq 0x4b0113(%rip), %r14 # 0x516c18
movq %r14, %rdi
callq 0x3c400
testl %eax, %eax
jne 0x66b48
movq 0x4b00b0(%rip), %rax # 0x516bc8
testq %rax, %rax
je 0x66b25
leaq 0x68(%rbx), %rcx
movq %rcx, 0x60(%rax)
movq %rax, 0x68(%rbx)
leaq 0x4b0098(%rip), %rax # 0x516bc8
movq %rax, 0x60(%rbx)
movq %rbx, 0x4b008d(%rip) # 0x516bc8
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3c3e0
movl %eax, %edi
callq 0x3c1b0
nop
|
/Support/Timer.cpp
|
llvm::TimerGroup::PrintRecord::PrintRecord(llvm::TimeRecord const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
PrintRecord(const TimeRecord &Time, const std::string &Name,
const std::string &Description)
: Time(Time), Name(Name), Description(Description) {}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
movq 0x20(%rsi), %rax
movq %rax, 0x20(%rdi)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
addq $0x28, %rdi
leaq 0x38(%r14), %rax
movq %rax, 0x28(%r14)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
callq 0x57bf6
leaq 0x48(%r14), %rdi
leaq 0x58(%r14), %rax
movq %rax, 0x48(%r14)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x57bf6
nop
|
/llvm/Support/Timer.h
|
llvm::detail::IEEEFloat::assign(llvm::detail::IEEEFloat const&)
|
void IEEEFloat::assign(const IEEEFloat &rhs) {
assert(semantics == rhs.semantics);
sign = rhs.sign;
category = rhs.category;
exponent = rhs.exponent;
if (isFiniteNonZero() || category == fcNaN)
copySignificand(rhs);
}
|
movb 0x14(%rsi), %al
andb $0x8, %al
movb 0x14(%rdi), %cl
andb $-0x9, %cl
orb %al, %cl
movb %cl, 0x14(%rdi)
movb 0x14(%rsi), %al
movl %eax, %edx
andb $0x7, %dl
andb $-0x8, %cl
orb %dl, %cl
movb %cl, 0x14(%rdi)
movl 0x10(%rsi), %ecx
movl %ecx, 0x10(%rdi)
testb $0x6, %al
setne %al
cmpb $0x3, %dl
setne %cl
cmpb $0x1, %dl
je 0x699bc
andb %cl, %al
jne 0x699bc
retq
nop
|
/Support/APFloat.cpp
|
llvm::detail::IEEEFloat::operator=(llvm::detail::IEEEFloat&&)
|
IEEEFloat &IEEEFloat::operator=(IEEEFloat &&rhs) {
freeSignificand();
semantics = rhs.semantics;
significand = rhs.significand;
exponent = rhs.exponent;
category = rhs.category;
sign = rhs.sign;
rhs.semantics = &semBogus;
return *this;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movl 0x8(%rax), %eax
addl $-0x40, %eax
cmpl $0xffffff7f, %eax # imm = 0xFFFFFF7F
ja 0x69c6c
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x69c6c
callq 0x3c180
movq (%r14), %rax
movq %rax, (%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx)
movl 0x10(%r14), %eax
movl %eax, 0x10(%rbx)
movb 0x14(%r14), %al
andb $0x7, %al
movb 0x14(%rbx), %cl
andb $-0x8, %cl
orb %al, %cl
movb %cl, 0x14(%rbx)
movb 0x14(%r14), %al
andb $0x8, %al
andb $-0x9, %cl
orb %al, %cl
movb %cl, 0x14(%rbx)
leaq 0x2ba8b5(%rip), %rax # 0x32455c
movq %rax, (%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/Support/APFloat.cpp
|
llvm::detail::IEEEFloat::shiftSignificandRight(unsigned int)
|
lostFraction IEEEFloat::shiftSignificandRight(unsigned int bits) {
/* Our exponent should not overflow. */
assert((ExponentType) (exponent + bits) >= exponent);
exponent += bits;
return shiftRight(significandParts(), partCount(), bits);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
addl %esi, 0x10(%rdi)
movq (%rdi), %rax
movl 0x8(%rax), %r15d
leal -0x40(%r15), %eax
cmpl $-0x80, %eax
jae 0x6abbf
movq 0x8(%r14), %r14
jmp 0x6abc3
addq $0x8, %r14
addl $0x40, %r15d
shrl $0x6, %r15d
movq %r14, %rdi
movl %r15d, %esi
movl %ebx, %edx
callq 0x6bc68
movl %eax, %ebp
movq %r14, %rdi
movl %r15d, %esi
movl %ebx, %edx
callq 0x725ca
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/Support/APFloat.cpp
|
llvm::detail::IEEEFloat::divideSpecials(llvm::detail::IEEEFloat const&)
|
IEEEFloat::opStatus IEEEFloat::divideSpecials(const IEEEFloat &rhs) {
switch (PackCategoriesIntoKey(category, rhs.category)) {
default:
llvm_unreachable(nullptr);
case PackCategoriesIntoKey(fcZero, fcNaN):
case PackCategoriesIntoKey(fcNormal, fcNaN):
case PackCategoriesIntoKey(fcInfinity, fcNaN):
assign(rhs);
sign = false;
[[fallthrough]];
case PackCategoriesIntoKey(fcNaN, fcZero):
case PackCategoriesIntoKey(fcNaN, fcNormal):
case PackCategoriesIntoKey(fcNaN, fcInfinity):
case PackCategoriesIntoKey(fcNaN, fcNaN):
sign ^= rhs.sign; // restore the original sign
if (isSignaling()) {
makeQuiet();
return opInvalidOp;
}
return rhs.isSignaling() ? opInvalidOp : opOK;
case PackCategoriesIntoKey(fcInfinity, fcZero):
case PackCategoriesIntoKey(fcInfinity, fcNormal):
case PackCategoriesIntoKey(fcZero, fcInfinity):
case PackCategoriesIntoKey(fcZero, fcNormal):
return opOK;
case PackCategoriesIntoKey(fcNormal, fcInfinity):
category = fcZero;
return opOK;
case PackCategoriesIntoKey(fcNormal, fcZero):
if (semantics->nonFiniteBehavior == fltNonfiniteBehavior::NanOnly)
makeNaN(false, sign);
else
category = fcInfinity;
return opDivByZero;
case PackCategoriesIntoKey(fcInfinity, fcInfinity):
case PackCategoriesIntoKey(fcZero, fcZero):
makeNaN();
return opInvalidOp;
case PackCategoriesIntoKey(fcNormal, fcNormal):
return opOK;
}
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x14(%rdi), %ecx
movl %ecx, %eax
andl $0x7, %eax
movzbl 0x14(%rsi), %edx
andl $0x7, %edx
leal (%rdx,%rax,4), %edx
xorl %eax, %eax
leaq 0x2b8eed(%rip), %rsi # 0x324384
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x69978
andb $-0x9, 0x14(%rbx)
movb 0x14(%r14), %al
andb $0x8, %al
xorb %al, 0x14(%rbx)
movq %rbx, %rdi
callq 0x6b374
testb %al, %al
je 0x6b4ce
movq %rbx, %rdi
callq 0x6b3b6
jmp 0x6b4e9
movq %r14, %rdi
callq 0x6b374
movzbl %al, %eax
jmp 0x6b4ee
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x699f8
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
andb $-0x8, %cl
orb $0x3, %cl
movb %cl, 0x14(%rbx)
jmp 0x6b4ee
movq (%rbx), %rax
cmpl $0x1, 0x10(%rax)
jne 0x6b521
andb $0x8, %cl
shrb $0x3, %cl
movzbl %cl, %edx
movq %rbx, %rdi
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x699f8
jmp 0x6b527
andb $-0x8, %cl
movb %cl, 0x14(%rbx)
movl $0x2, %eax
jmp 0x6b4ee
|
/Support/APFloat.cpp
|
llvm::detail::scalbn(llvm::detail::IEEEFloat, int, llvm::RoundingMode)
|
IEEEFloat scalbn(IEEEFloat X, int Exp, IEEEFloat::roundingMode RoundingMode) {
auto MaxExp = X.getSemantics().maxExponent;
auto MinExp = X.getSemantics().minExponent;
// If Exp is wildly out-of-scale, simply adding it to X.exponent will
// overflow; clamp it to a safe range before adding, but ensure that the range
// is large enough that the clamp does not change the result. The range we
// need to support is the difference between the largest possible exponent and
// the normalized exponent of half the smallest denormal.
int SignificandBits = X.getSemantics().precision - 1;
int MaxIncrement = MaxExp - (MinExp - SignificandBits) + 1;
// Clamp to one past the range ends to let normalize handle overlflow.
X.exponent += std::clamp(Exp, -MaxIncrement - 1, MaxIncrement);
X.normalize(RoundingMode, lfExactlyZero);
if (X.isNaN())
X.makeQuiet();
return X;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %rax
movl 0x4(%rax), %esi
notl %esi
addl (%rax), %esi
movl 0x8(%rax), %eax
leal (%rsi,%rax), %r8d
addl %esi, %eax
incl %eax
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
subl %r8d, %esi
cmpl %edx, %eax
cmovgel %edx, %eax
cmpl %edx, %esi
cmovgl %esi, %eax
movq %rdi, %r14
addl %eax, 0x10(%rbx)
movq %rbx, %rdi
movl %ecx, %esi
xorl %edx, %edx
callq 0x6a100
movb 0x14(%rbx), %al
andb $0x7, %al
cmpb $0x1, %al
jne 0x6b7b6
movq %rbx, %rdi
callq 0x6b3b6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6a424
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/Support/APFloat.cpp
|
llvm::detail::IEEEFloat::convertToInteger(llvm::MutableArrayRef<unsigned long>, unsigned int, bool, llvm::RoundingMode, bool*) const
|
IEEEFloat::opStatus
IEEEFloat::convertToInteger(MutableArrayRef<integerPart> parts,
unsigned int width, bool isSigned,
roundingMode rounding_mode, bool *isExact) const {
opStatus fs;
fs = convertToSignExtendedInteger(parts, width, isSigned, rounding_mode,
isExact);
if (fs == opInvalidOp) {
unsigned int bits, dstPartsCount;
dstPartsCount = partCountForBits(width);
assert(dstPartsCount <= parts.size() && "Integer too big");
if (category == fcNaN)
bits = 0;
else if (sign)
bits = isSigned;
else
bits = width - isSigned;
tcSetLeastSignificantBits(parts.data(), dstPartsCount, bits);
if (sign && isSigned)
APInt::tcShiftLeft(parts.data(), dstPartsCount, width - 1);
}
return fs;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movl %ecx, %ebx
movq %rsi, %r14
movq %rdi, %r12
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
callq 0x6ba42
movl %eax, %r15d
cmpl $0x1, %eax
jne 0x6bd37
leal 0x3f(%rbx), %r13d
shrl $0x6, %r13d
movb 0x14(%r12), %al
movl %eax, %ecx
andb $0x7, %cl
xorl %edx, %edx
cmpb $0x1, %cl
je 0x6bd0b
testb $0x8, %al
jne 0x6bd07
movzbl %bpl, %eax
movl %ebx, %edx
subl %eax, %edx
jmp 0x6bd0b
movzbl %bpl, %edx
movq %r14, %rdi
movl %r13d, %esi
callq 0x6b0c5
testb $0x8, 0x14(%r12)
sete %al
xorb $0x1, %bpl
orb %al, %bpl
jne 0x6bd37
decl %ebx
movq %r14, %rdi
movl %r13d, %esi
movl %ebx, %edx
callq 0x72696
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/Support/APFloat.cpp
|
llvm::detail::IEEEFloat::convertFromUnsignedParts(unsigned long const*, unsigned int, llvm::RoundingMode)
|
IEEEFloat::opStatus IEEEFloat::convertFromUnsignedParts(
const integerPart *src, unsigned int srcCount, roundingMode rounding_mode) {
unsigned int omsb, precision, dstCount;
integerPart *dst;
lostFraction lost_fraction;
category = fcNormal;
omsb = APInt::tcMSB(src, srcCount) + 1;
dst = significandParts();
dstCount = partCount();
precision = semantics->precision;
/* We want the most significant PRECISION bits of SRC. There may not
be that many; extract what we can. */
if (precision <= omsb) {
exponent = omsb - 1;
lost_fraction = lostFractionThroughTruncation(src, srcCount,
omsb - precision);
APInt::tcExtract(dst, dstCount, src, precision, omsb - precision);
} else {
exponent = precision - 1;
lost_fraction = lfExactlyZero;
APInt::tcExtract(dst, dstCount, src, omsb, 0);
}
return normalize(rounding_mode, lost_fraction);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, 0xc(%rsp)
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
movb 0x14(%rdi), %al
andb $-0x8, %al
orb $0x2, %al
movb %al, 0x14(%rdi)
movq %rsi, %rdi
movl %edx, %esi
callq 0x750d4
leal 0x1(%rax), %ecx
movq (%r14), %rdx
movl 0x8(%rdx), %r12d
leal -0x40(%r12), %edx
cmpl $-0x80, %edx
jae 0x6bd92
movq 0x8(%r14), %rdi
jmp 0x6bd96
leaq 0x8(%r14), %rdi
leal 0x40(%r12), %ebx
shrl $0x6, %ebx
movl %ecx, %r13d
subl %r12d, %r13d
jae 0x6bdb9
decl %r12d
movl %r12d, 0x10(%r14)
xorl %ebp, %ebp
movl %ebx, %esi
movq %r15, %rdx
xorl %r8d, %r8d
jmp 0x6bde1
movl %eax, 0x10(%r14)
movq %rdi, 0x10(%rsp)
movq %r15, %rdi
movl %ebp, %esi
movl %r13d, %edx
callq 0x6bc68
movl %eax, %ebp
movq 0x10(%rsp), %rdi
movl %ebx, %esi
movq %r15, %rdx
movl %r12d, %ecx
movl %r13d, %r8d
callq 0x75108
movsbl 0xc(%rsp), %esi
movq %r14, %rdi
movl %ebp, %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6a100
nop
|
/Support/APFloat.cpp
|
llvm::detail::IEEEFloat::convertFloat8E5M2APFloatToAPInt() const
|
APInt IEEEFloat::convertFloat8E5M2APFloatToAPInt() const {
assert(partCount() == 1);
return convertIEEEFloatToAPInt<semFloat8E5M2>();
}
|
pushq %rbx
movq %rdi, %rbx
movzbl 0x14(%rsi), %eax
testb $0x6, %al
sete %dl
movl %eax, %ecx
andl $0x7, %ecx
cmpl $0x3, %ecx
sete %dil
orb %dl, %dil
jne 0x6c4e2
movslq 0x10(%rsi), %rcx
addq $0xf, %rcx
movq (%rsi), %rdx
movl 0x8(%rdx), %edx
addl $-0x40, %edx
cmpl $-0x80, %edx
jae 0x6c4f4
movq 0x8(%rsi), %rsi
jmp 0x6c4f8
cmpl $0x3, %ecx
je 0x6c50a
testl %ecx, %ecx
jne 0x6c510
movl $0x1f, %ecx
xorl %edx, %edx
jmp 0x6c530
addq $0x8, %rsi
movq (%rsi), %rdx
cmpl $0x1, %ecx
jne 0x6c530
movl %edx, %ecx
shrl $0x2, %ecx
andl $0x1, %ecx
jmp 0x6c530
xorl %edx, %edx
xorl %ecx, %ecx
jmp 0x6c530
movq (%rsi), %rcx
movl 0x8(%rcx), %ecx
addl $-0x40, %ecx
cmpl $-0x80, %ecx
jae 0x6c524
movq 0x8(%rsi), %rsi
jmp 0x6c528
addq $0x8, %rsi
movq (%rsi), %rdx
movl $0x1f, %ecx
andl $0x3, %edx
andl $0x8, %eax
shll $0x4, %eax
orq %rdx, %rax
andl $0x1f, %ecx
leaq (%rax,%rcx,4), %rax
movl $0x8, 0x8(%rbx)
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x661d4
movq %rbx, %rax
popq %rbx
retq
|
/Support/APFloat.cpp
|
llvm::detail::IEEEFloat::initFromFloat6E2M3FNAPInt(llvm::APInt const&)
|
bool isSingleWord() const { return BitWidth <= APINT_BITS_PER_WORD; }
|
movl 0x8(%rsi), %ecx
cmpq $0x41, %rcx
jb 0x6d88c
movq (%rsi), %rsi
movq (%rsi), %rax
andl $0x7, %eax
addq $0x3f, %rcx
shrq $0x6, %rcx
decl %ecx
movq (%rsi,%rcx,8), %rdx
movl %edx, %ecx
shrl $0x3, %ecx
andl $0x3, %ecx
leaq 0x2b6c65(%rip), %rsi # 0x324514
movq %rsi, (%rdi)
movb 0x14(%rdi), %sil
shrb $0x2, %dl
andb $0x8, %dl
andb $-0x9, %sil
orb %dl, %sil
movb %sil, 0x14(%rdi)
movq %rcx, %r8
orq %rax, %r8
je 0x6d8f3
andb $-0x8, %sil
orb $0x2, %sil
leal -0x1(%rcx), %edx
movb %sil, 0x14(%rdi)
movl %edx, 0x10(%rdi)
movq %rax, 0x8(%rdi)
testq %rcx, %rcx
je 0x6d900
orq $0x8, %rax
movq %rax, 0x8(%rdi)
retq
xorl %esi, %esi
testb %dl, %dl
setne %sil
jmp 0x6a392
movl $0x0, 0x10(%rdi)
retq
|
/llvm/ADT/APInt.h
|
llvm::APFloat::makeSmallest(bool)
|
void makeSmallest(bool Neg) {
APFLOAT_DISPATCH_ON_SEMANTICS(makeSmallest(Neg));
}
|
pushq %rbx
movq %rdi, %rbx
leaq 0x2b47b7(%rip), %rax # 0x32443c
cmpq %rax, 0x8(%rdi)
je 0x6fc9c
addq $0x8, %rbx
movzbl %sil, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x6db14
movq 0x10(%rbx), %rdi
movzbl %sil, %esi
callq 0x6fc7a
movq 0x10(%rbx), %rdi
addq $0x20, %rdi
xorl %esi, %esi
popq %rbx
jmp 0x6ee40
nop
|
/llvm/ADT/APFloat.h
|
llvm::APInt::Profile(llvm::FoldingSetNodeID&) const
|
void APInt::Profile(FoldingSetNodeID& ID) const {
ID.AddInteger(BitWidth);
if (isSingleWord()) {
ID.AddInteger(U.VAL);
return;
}
unsigned NumWords = getNumWords();
for (unsigned i = 0; i < NumWords; ++i)
ID.AddInteger(U.pVal[i]);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %esi
movq %rbx, %rdi
callq 0x75350
movl 0x8(%r14), %r12d
cmpq $0x40, %r12
ja 0x70d92
movq (%r14), %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0x75350
shrq $0x20, %r14
movq %rbx, %rdi
movl %r14d, %esi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x75350
addq $0x3f, %r12
shrq $0x6, %r12
xorl %r13d, %r13d
movq (%r14), %rax
movq (%rax,%r13,8), %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x75350
shrq $0x20, %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x75350
incq %r13
cmpq %r13, %r12
jne 0x70d9d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/Support/APInt.cpp
|
llvm::APInt::operator-=(unsigned long)
|
bool isSingleWord() const { return BitWidth <= APINT_BITS_PER_WORD; }
|
movl 0x8(%rdi), %eax
cmpq $0x40, %rax
ja 0x7108f
subq %rsi, (%rdi)
jmp 0x661d4
movq (%rdi), %rcx
addq $0x3f, %rax
shrq $0x6, %rax
decq %rax
xorl %edx, %edx
subq %rsi, (%rcx,%rdx,8)
jae 0x661d4
leaq 0x1(%rdx), %r8
movl $0x1, %esi
cmpq %rdx, %rax
movq %r8, %rdx
je 0x661d4
jmp 0x7109f
|
/llvm/ADT/APInt.h
|
llvm::APInt::tcMultiplyPart(unsigned long*, unsigned long const*, unsigned long, unsigned long, unsigned int, unsigned int, bool)
|
int APInt::tcMultiplyPart(WordType *dst, const WordType *src,
WordType multiplier, WordType carry,
unsigned srcParts, unsigned dstParts,
bool add) {
// Otherwise our writes of DST kill our later reads of SRC.
assert(dst <= src || dst >= src + srcParts);
assert(dstParts <= srcParts + 1);
// N loops; minimum of dstParts and srcParts.
unsigned n = std::min(dstParts, srcParts);
for (unsigned i = 0; i < n; i++) {
// [LOW, HIGH] = MULTIPLIER * SRC[i] + DST[i] + CARRY.
// This cannot overflow, because:
// (n - 1) * (n - 1) + 2 (n - 1) = (n - 1) * (n + 1)
// which is less than n^2.
WordType srcPart = src[i];
WordType low, mid, high;
if (multiplier == 0 || srcPart == 0) {
low = carry;
high = 0;
} else {
low = lowHalf(srcPart) * lowHalf(multiplier);
high = highHalf(srcPart) * highHalf(multiplier);
mid = lowHalf(srcPart) * highHalf(multiplier);
high += highHalf(mid);
mid <<= APINT_BITS_PER_WORD / 2;
if (low + mid < low)
high++;
low += mid;
mid = highHalf(srcPart) * lowHalf(multiplier);
high += highHalf(mid);
mid <<= APINT_BITS_PER_WORD / 2;
if (low + mid < low)
high++;
low += mid;
// Now add carry.
if (low + carry < low)
high++;
low += carry;
}
if (add) {
// And now DST[i], and store the new low part there.
if (low + dst[i] < low)
high++;
dst[i] += low;
} else
dst[i] = low;
carry = high;
}
if (srcParts < dstParts) {
// Full multiplication, there is no overflow.
assert(srcParts + 1 == dstParts);
dst[srcParts] = carry;
return 0;
}
// We overflowed if there is carry.
if (carry)
return 1;
// We would overflow if any significant unwritten parts would be
// non-zero. This is true if any remaining src parts are non-zero
// and the multiplier is non-zero.
if (multiplier)
for (unsigned i = dstParts; i < srcParts; i++)
if (src[i])
return 1;
// We fitted in the narrow destination.
return 0;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpl %r9d, %r8d
movl %r9d, -0xc(%rsp)
movl %r9d, %ebx
movq %r8, -0x8(%rsp)
cmovbl %r8d, %ebx
testl %ebx, %ebx
je 0x71328
movb 0x38(%rsp), %r8b
movl %edx, %r10d
movq %rdx, %r11
shrq $0x20, %r11
movl %ebx, %ebx
xorl %r14d, %r14d
testq %rdx, %rdx
je 0x71303
movq (%rsi,%r14,8), %r15
testq %r15, %r15
je 0x71303
movl %r15d, %r12d
movq %r12, %r13
imulq %r10, %r13
shrq $0x20, %r15
movq %r15, %rbp
imulq %r11, %rbp
imulq %r11, %r12
movq %r12, %rax
shrq $0x20, %rax
addq %rbp, %rax
movq %r12, %rbp
shlq $0x20, %rbp
imulq %r10, %r15
movq %r15, %r9
shrq $0x20, %r9
addl %r15d, %r12d
shlq $0x20, %r12
addq %r13, %r12
addq %r13, %rbp
adcq %rax, %r9
xorl %r15d, %r15d
cmpq %rbp, %r12
setb %r15b
addq %r12, %rcx
adcq %r9, %r15
jmp 0x71306
xorl %r15d, %r15d
testb %r8b, %r8b
je 0x71313
addq (%rdi,%r14,8), %rcx
adcq $0x0, %r15
movq %rcx, (%rdi,%r14,8)
incq %r14
movq %r15, %rcx
cmpq %r14, %rbx
jne 0x7129e
jmp 0x7132b
movq %rcx, %r15
movq -0x8(%rsp), %r8
movl -0xc(%rsp), %r9d
cmpl %r9d, %r8d
jae 0x71345
movl %r8d, %eax
movq %r15, (%rdi,%rax,8)
xorl %eax, %eax
jmp 0x7134f
movl $0x1, %eax
testq %r15, %r15
je 0x7135a
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testq %rdx, %rdx
sete %cl
subl %r9d, %r8d
setbe %dl
orb %cl, %dl
jne 0x71341
movl %r9d, %ecx
leaq (%rsi,%rcx,8), %rcx
xorl %edx, %edx
cmpq $0x0, (%rcx,%rdx,8)
jne 0x7134f
incq %rdx
cmpl %edx, %r8d
jne 0x71373
jmp 0x71341
|
/Support/APInt.cpp
|
llvm::APInt::zext(unsigned int) const
|
APInt APInt::zext(unsigned width) const {
assert(width >= BitWidth && "Invalid APInt ZeroExtend request");
if (width <= APINT_BITS_PER_WORD)
return APInt(width, U.VAL);
if (width == BitWidth)
return *this;
APInt Result(getMemory(getNumWords(width)), width);
// Copy words.
std::memcpy(Result.U.pVal, getRawData(), getNumWords() * APINT_WORD_SIZE);
// Zero remaining words.
std::memset(Result.U.pVal + getNumWords(), 0,
(Result.getNumWords() - getNumWords()) * APINT_WORD_SIZE);
return Result;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x40, %edx
ja 0x71589
movq (%r14), %rdx
movq %rbx, %rdi
movl %ebp, %esi
xorl %ecx, %ecx
callq 0x66024
jmp 0x715fe
movl 0x8(%r14), %r13d
cmpl %ebp, %r13d
jne 0x7159f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7198a
jmp 0x715fe
movl %ebp, %r15d
addq $0x3f, %r15
shrq $0x6, %r15
leal (,%r15,8), %edi
callq 0x3c450
movq %rax, %r12
movl %ebp, 0x8(%rbx)
movq %rax, (%rbx)
cmpl $0x41, %r13d
jb 0x715c9
movq (%r14), %r14
addq $0x3f, %r13
shrq $0x6, %r13
leal (,%r13,8), %ebp
movq %r12, %rdi
movq %r14, %rsi
movq %rbp, %rdx
callq 0x3c370
addq %rbp, %r12
subl %r13d, %r15d
shll $0x3, %r15d
movq %r12, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x3c160
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/Support/APInt.cpp
|
llvm::APInt::countLeadingOnesSlowCase() const
|
unsigned APInt::countLeadingOnesSlowCase() const {
unsigned highWordBits = BitWidth % APINT_BITS_PER_WORD;
unsigned shift;
if (!highWordBits) {
highWordBits = APINT_BITS_PER_WORD;
shift = 0;
} else {
shift = APINT_BITS_PER_WORD - highWordBits;
}
int i = getNumWords() - 1;
unsigned Count = llvm::countl_one(U.pVal[i] << shift);
if (Count == highWordBits) {
for (i--; i >= 0; --i) {
if (U.pVal[i] == WORDTYPE_MAX)
Count += APINT_BITS_PER_WORD;
else {
Count += llvm::countl_one(U.pVal[i]);
break;
}
}
}
return Count;
}
|
movl 0x8(%rdi), %r8d
movl %r8d, %r10d
andl $0x3f, %r10d
movb $0x40, %cl
subb %r10b, %cl
movq %r8, %rdx
addq $0x3f, %rdx
shrq $0x6, %rdx
testl %r10d, %r10d
movl $0x40, %r9d
cmovnel %r10d, %r9d
movq (%rdi), %rsi
movq -0x8(%rsi,%rdx,8), %rax
movzbl %cl, %ecx
cmovel %r10d, %ecx
shlq %cl, %rax
xorq $-0x1, %rax
je 0x71c04
bsrq %rax, %rax
xorq $0x3f, %rax
jmp 0x71c09
movl $0x40, %eax
cmpl %eax, %r9d
setne %cl
cmpl $0x41, %r8d
setb %dil
orb %cl, %dil
jne 0x71c32
decl %edx
leal -0x1(%rdx), %ecx
movq (%rsi,%rcx,8), %rcx
cmpq $-0x1, %rcx
jne 0x71c33
addl $0x40, %eax
decl %edx
jg 0x71c1e
retq
xorq $-0x1, %rcx
je 0x71c43
bsrq %rcx, %rcx
xorq $0x3f, %rcx
jmp 0x71c48
movl $0x40, %ecx
addl %eax, %ecx
movl %ecx, %eax
retq
nop
|
/Support/APInt.cpp
|
llvm::APInt::urem(unsigned long) const
|
uint64_t APInt::urem(uint64_t RHS) const {
assert(RHS != 0 && "Remainder by zero?");
if (isSingleWord())
return U.VAL % RHS;
// Get some facts about the LHS
unsigned lhsWords = getNumWords(getActiveBits());
// Check the degenerate cases
if (lhsWords == 0)
// 0 % Y ===> 0
return 0;
if (RHS == 1)
// X % 1 ===> 0
return 0;
if (this->ult(RHS))
// X % Y ===> X, iff X < Y
return getZExtValue();
if (*this == RHS)
// X % X == 0;
return 0;
if (lhsWords == 1)
// All high words are zero, just use native remainder
return U.pVal[0] % RHS;
// We have to compute it the hard way. Invoke the Knuth divide algorithm.
uint64_t Remainder;
divide(U.pVal, lhsWords, &RHS, 1, nullptr, &Remainder);
return Remainder;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, 0x8(%rsp)
movl 0x8(%rdi), %ebp
cmpl $0x40, %ebp
ja 0x73450
movq (%r14), %rax
xorl %edx, %edx
divq %rbx
movq %rdx, %rax
jmp 0x7346e
movq %r14, %rdi
callq 0x71b6c
movl %ebp, %r15d
subl %eax, %r15d
sete %al
cmpq $0x1, %rbx
sete %cl
orb %al, %cl
je 0x73479
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x71b6c
movl %ebp, %ecx
subl %eax, %ecx
cmpl $0x40, %ecx
ja 0x7349a
movq (%r14), %rax
cmpq %rbx, (%rax)
jae 0x7349a
movq (%r14), %rax
movq (%rax), %rax
jmp 0x7346e
movq %r14, %rdi
callq 0x71b6c
subl %eax, %ebp
cmpl $0x40, %ebp
ja 0x734b1
movq (%r14), %rax
cmpq %rbx, (%rax)
je 0x7346c
addq $0x3f, %r15
shrq $0x6, %r15
cmpl $0x1, %r15d
jne 0x734ca
movq (%r14), %rax
movq (%rax), %rax
jmp 0x73446
movq (%r14), %rdi
leaq 0x8(%rsp), %rdx
leaq 0x10(%rsp), %rbx
movl %r15d, %esi
movl $0x1, %ecx
xorl %r8d, %r8d
movq %rbx, %r9
callq 0x729ba
movq (%rbx), %rax
jmp 0x7346e
|
/Support/APInt.cpp
|
llvm::APInt::setBits(unsigned int, unsigned int)
|
void setBits(unsigned loBit, unsigned hiBit) {
assert(hiBit <= BitWidth && "hiBit out of range");
assert(loBit <= BitWidth && "loBit out of range");
assert(loBit <= hiBit && "loBit greater than hiBit");
if (loBit == hiBit)
return;
if (loBit < APINT_BITS_PER_WORD && hiBit <= APINT_BITS_PER_WORD) {
uint64_t mask = WORDTYPE_MAX >> (APINT_BITS_PER_WORD - (hiBit - loBit));
mask <<= loBit;
if (isSingleWord())
U.VAL |= mask;
else
U.pVal[0] |= mask;
} else {
setBitsSlowCase(loBit, hiBit);
}
}
|
cmpl %edx, %esi
je 0x75326
cmpl $0x40, %esi
setae %al
cmpl $0x41, %edx
setae %cl
orb %al, %cl
jne 0x714d4
movl %esi, %ecx
orl $0x40, %ecx
subl %edx, %ecx
movq $-0x1, %rax
shrq %cl, %rax
movl %esi, %ecx
shlq %cl, %rax
cmpl $0x40, 0x8(%rdi)
ja 0x75320
orq %rax, (%rdi)
retq
movq (%rdi), %rcx
orq %rax, (%rcx)
retq
|
/llvm/ADT/APInt.h
|
llvm::StoreIntToMemory(llvm::APInt const&, unsigned char*, unsigned int)
|
void llvm::StoreIntToMemory(const APInt &IntVal, uint8_t *Dst,
unsigned StoreBytes) {
assert((IntVal.getBitWidth()+7)/8 >= StoreBytes && "Integer too small!");
const uint8_t *Src = (const uint8_t *)IntVal.getRawData();
if (sys::IsLittleEndianHost) {
// Little-endian host - the source is ordered from LSB to MSB. Order the
// destination from LSB to MSB: Do a straight copy.
memcpy(Dst, Src, StoreBytes);
} else {
// Big-endian host - the source is an array of 64 bit words ordered from
// LSW to MSW. Each word is ordered from MSB to LSB. Order the destination
// from MSB to LSB: Reverse the word order, but not the bytes in a word.
while (StoreBytes > sizeof(uint64_t)) {
StoreBytes -= sizeof(uint64_t);
// May not be aligned so use memcpy.
memcpy(Dst + StoreBytes, Src, sizeof(uint64_t));
Src += sizeof(uint64_t);
}
memcpy(Dst, Src + sizeof(uint64_t) - StoreBytes, StoreBytes);
}
}
|
movq %rdi, %rax
cmpl $0x41, 0x8(%rdi)
jb 0x75333
movq (%rax), %rax
movl %edx, %edx
movq %rsi, %rdi
movq %rax, %rsi
jmp 0x3c370
|
/Support/APInt.cpp
|
llvm::APInt::abs() const
|
APInt abs() const {
if (isNegative())
return -(*this);
return *this;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x8(%rsi), %r14d
leal -0x1(%r14), %eax
movl %eax, %ecx
shrl $0x6, %ecx
cmpq $0x41, %r14
movq (%rsi), %r15
leaq (%r15,%rcx,8), %rcx
cmovbq %rsi, %rcx
movq (%rcx), %rcx
btq %rax, %rcx
jae 0x7541b
movl %r14d, 0x8(%rsp)
cmpl $0x40, %r14d
ja 0x75425
movq (%rsi), %rax
movq %rax, (%rsp)
jmp 0x7544b
movq %rbx, %rdi
callq 0x7198a
jmp 0x75473
addq $0x3f, %r14
shrq $0x3, %r14
andl $-0x8, %r14d
movq %r14, %rdi
callq 0x3c450
movq %rax, (%rsp)
movq %rax, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x3c370
movq %rsp, %r14
movq %r14, %rdi
callq 0x7089e
movq %r14, %rdi
callq 0x70e2e
movl 0x8(%r14), %eax
movl %eax, 0x8(%rbx)
movq (%r14), %rax
movq %rax, (%rbx)
movl $0x0, 0x8(%r14)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/llvm/ADT/APInt.h
|
llvm::isLegalUTF8(unsigned char const*, int)
|
static Boolean isLegalUTF8(const UTF8 *source, int length) {
UTF8 a;
const UTF8 *srcptr = source+length;
switch (length) {
default: return false;
/* Everything else falls through when "true"... */
case 4: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return false;
case 3: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return false;
case 2: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return false;
switch (*source) {
/* no fall-through in this inner switch */
case 0xE0: if (a < 0xA0) return false; break;
case 0xED: if (a > 0x9F) return false; break;
case 0xF0: if (a < 0x90) return false; break;
case 0xF4: if (a > 0x8F) return false; break;
default: if (a < 0x80) return false;
}
case 1: if (*source >= 0x80 && *source < 0xC2) return false;
}
if (*source > 0xF4) return false;
return true;
}
|
leal -0x1(%rsi), %ecx
cmpl $0x3, %ecx
ja 0x75600
movslq %esi, %rax
addq %rdi, %rax
leaq 0x2af3ea(%rip), %rdx # 0x3249bc
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movb (%rdi), %al
cmpb $-0x3e, %al
jl 0x75600
cmpb $-0xb, %al
setb %al
retq
cmpb $-0x41, -0x1(%rax)
jg 0x75600
decq %rax
cmpb $-0x41, -0x1(%rax)
jg 0x75600
decq %rax
movb -0x1(%rax), %al
cmpb $-0x41, %al
jle 0x75603
xorl %eax, %eax
retq
movzbl (%rdi), %ecx
cmpl $0xef, %ecx
jg 0x75624
cmpl $0xe0, %ecx
je 0x7563a
cmpl $0xed, %ecx
jne 0x755db
cmpb $-0x61, %al
jbe 0x755db
jmp 0x75600
cmpl $0xf0, %ecx
je 0x75640
cmpl $0xf4, %ecx
jne 0x755db
cmpb $-0x71, %al
jbe 0x755db
jmp 0x75600
cmpb $-0x60, %al
jb 0x75600
jmp 0x755db
cmpb $-0x70, %al
jae 0x755db
jmp 0x75600
|
/Support/ConvertUTF.cpp
|
clang::AnalysisDeclContext::getUnoptimizedCFG()
|
CFG *AnalysisDeclContext::getUnoptimizedCFG() {
if (!builtCompleteCFG) {
SaveAndRestore NotPrune(cfgBuildOptions.PruneTriviallyFalseEdges, false);
completeCFG =
CFG::buildCFG(D, getBody(), &D->getASTContext(), cfgBuildOptions);
// Even when the cfg is not successfully built, we don't
// want to try building it again.
builtCompleteCFG = true;
if (PM)
addParentsForSyntheticStmts(completeCFG.get(), *PM);
// The Observer should only observe one build of the CFG.
getCFGBuildOptions().Observer = nullptr;
}
return completeCFG.get();
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x71(%rdi)
jne 0x760d9
leaq 0x28(%rbx), %r14
movb 0x58(%rbx), %bpl
movb $0x0, 0x58(%rbx)
movq 0x8(%rbx), %r15
leaq 0xf(%rsp), %rsi
movq %rbx, %rdi
callq 0x75de0
movq %rax, %r12
movq 0x8(%rbx), %rdi
callq 0xc0b9c
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rax, %rcx
movq %r14, %r8
callq 0x78d54
leaq 0x18(%rbx), %r14
movq (%r13), %rax
movq $0x0, (%r13)
movq 0x18(%rbx), %rsi
movq %rax, 0x18(%rbx)
testq %rsi, %rsi
je 0x760a4
movq %r14, %rdi
callq 0x762ec
movq 0x10(%rsp), %rsi
testq %rsi, %rsi
je 0x760b8
leaq 0x10(%rsp), %rdi
callq 0x762ec
movb $0x1, 0x71(%rbx)
movq 0x78(%rbx), %rsi
testq %rsi, %rsi
je 0x760cd
movq (%r14), %rdi
callq 0x760ec
movq $0x0, 0x50(%rbx)
movb %bpl, 0x58(%rbx)
movq 0x18(%rbx), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/Analysis/AnalysisDeclContext.cpp
|
addParentsForSyntheticStmts(clang::CFG const*, clang::ParentMap&)
|
static void addParentsForSyntheticStmts(const CFG *TheCFG, ParentMap &PM) {
if (!TheCFG)
return;
for (CFG::synthetic_stmt_iterator I = TheCFG->synthetic_stmt_begin(),
E = TheCFG->synthetic_stmt_end();
I != E; ++I) {
PM.setParent(I->first, PM.getParent(I->second));
}
}
|
testq %rdi, %rdi
je 0x7616c
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r12
callq 0x76360
movl 0x68(%r12), %r13d
shlq $0x4, %r13
addq 0x58(%r12), %r13
cmpq %r13, %rax
je 0x7615e
movq %rax, %r14
movq %rdx, %r15
movl $0x1000, %ebp # imm = 0x1000
movq (%r14), %r12
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x201524
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x2014fc
addq $0x10, %r14
cmpq %r15, %r14
je 0x76159
movq (%r14), %rax
orq %rbp, %rax
cmpq $-0x1000, %rax # imm = 0xF000
je 0x76142
cmpq %r13, %r14
jne 0x76125
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/Analysis/AnalysisDeclContext.cpp
|
clang::AnalysisDeclContext::getParentMap()
|
ParentMap &AnalysisDeclContext::getParentMap() {
if (!PM) {
PM.reset(new ParentMap(getBody()));
if (const auto *C = dyn_cast<CXXConstructorDecl>(getDecl())) {
for (const auto *I : C->inits()) {
PM->addStmt(I->getInit());
}
}
if (builtCFG)
addParentsForSyntheticStmts(getCFG(), *PM);
if (builtCompleteCFG)
addParentsForSyntheticStmts(getUnoptimizedCFG(), *PM);
}
return *PM;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x78(%rdi), %rbx
cmpq $0x0, 0x78(%rdi)
jne 0x76244
movq %rdi, %r14
movl $0x8, %edi
callq 0x3c390
movq %rax, %r15
leaq 0x7(%rsp), %rsi
movq %r14, %rdi
callq 0x75de0
movq %r15, %rdi
movq %rax, %rsi
callq 0x201044
movq %rbx, %rdi
movq %r15, %rsi
callq 0x765b4
movq 0x8(%r14), %r12
testq %r12, %r12
je 0x7620e
movl 0x1c(%r12), %eax
andl $0x7f, %eax
cmpl $0x23, %eax
jne 0x7620e
movq %r12, %rdi
callq 0xc7f6c
movq %rax, %r15
movq %r12, %rdi
callq 0xc7f6c
movq 0x50(%r12), %rcx
shrq $0x2c, %rcx
andl $0x1ffff, %ecx # imm = 0x1FFFF
leaq (%rax,%rcx,8), %r12
cmpq %r12, %r15
je 0x7620e
movq (%r15), %rax
movq (%rbx), %rdi
movq 0x8(%rax), %rsi
callq 0x2014ec
addq $0x8, %r15
jmp 0x761f4
cmpb $0x1, 0x70(%r14)
jne 0x76229
movq %r14, %rdi
callq 0x75f46
movq 0x78(%r14), %rsi
movq %rax, %rdi
callq 0x760ec
cmpb $0x1, 0x71(%r14)
jne 0x76244
movq %r14, %rdi
callq 0x76022
movq 0x78(%r14), %rsi
movq %rax, %rdi
callq 0x760ec
movq (%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/Analysis/AnalysisDeclContext.cpp
|
clang::StmtIteratorImpl<clang::StmtIterator, clang::Stmt*&>::operator++()
|
DERIVED& operator++() {
if (inStmt())
++stmt;
else if (getVAPtr())
NextVA();
else
NextDecl();
return static_cast<DERIVED&>(*this);
}
|
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
testb $0x3, %al
je 0x763c7
movq %rbx, %rdi
cmpq $0x4, %rax
jae 0x763cd
movl $0x1, %esi
callq 0x21023a
jmp 0x763d2
addq $0x8, (%rbx)
jmp 0x763d2
callq 0x21016c
movq %rbx, %rax
popq %rbx
retq
nop
|
/clang/AST/StmtIterator.h
|
(anonymous namespace)::ASTMaker::findMemberField(clang::RecordDecl const*, llvm::StringRef)
|
ValueDecl *ASTMaker::findMemberField(const RecordDecl *RD, StringRef Name) {
CXXBasePaths Paths(
/* FindAmbiguities=*/false,
/* RecordPaths=*/false,
/* DetectVirtual=*/ false);
const IdentifierInfo &II = C.Idents.get(Name);
DeclarationName DeclName = C.DeclarationNames.getIdentifier(&II);
DeclContextLookupResult Decls = RD->lookup(DeclName);
for (NamedDecl *FoundDecl : Decls)
if (!FoundDecl->getDeclContext()->isFunctionOrMethod())
return cast<ValueDecl>(FoundDecl);
return nullptr;
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x180, %rsp # imm = 0x180
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
leaq 0x8(%rsp), %rdi
xorl %ebx, %ebx
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x781e6
movq (%r13), %rax
movq 0x4380(%rax), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x78292
addq $0x40, %r12
movq %r12, %rdi
movq %rax, %rsi
callq 0xc2caa
testq %rax, %rax
je 0x77e5e
movl $0x4061, %ecx # imm = 0x4061
testb $0x4, %al
sete %sil
andq $-0x8, %rax
sete %dl
orb %sil, %dl
movq %rax, %rsi
jne 0x77e05
movq (%rax), %rsi
movq 0x10(%rsi), %r8
movq %r8, %rdi
andq $-0x8, %rdi
testb $0x4, %r8b
je 0x77e19
movq (%rdi), %rdi
movzwl 0x8(%rdi), %edi
andl $0x7f, %edi
leal -0x1(%rdi), %r9d
cmpw $0xf, %r9w
jae 0x77e34
movb $0x1, %r8b
btl %r9d, %ecx
jb 0x77e42
movzwl %di, %edi
addl $-0x1f, %edi
cmpw $0x6, %di
setb %r8b
testb %r8b, %r8b
cmoveq %rsi, %rbx
je 0x77e5e
testb %dl, %dl
je 0x77e53
xorl %eax, %eax
jmp 0x77e57
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x77ded
xorl %ebx, %ebx
leaq 0x108(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x77e74
callq 0x3c3a0
movq 0xb8(%rsp), %rdi
cmpq 0xb0(%rsp), %rdi
je 0x77e8b
callq 0x3c3a0
testb $0x1, 0x28(%rsp)
jne 0x77ea9
movq 0x30(%rsp), %rdi
movl 0x38(%rsp), %esi
shlq $0x4, %rsi
movl $0x8, %edx
callq 0x56dc8
leaq 0x10(%rsp), %rdi
callq 0x78520
movq %rbx, %rax
addq $0x180, %rsp # imm = 0x180
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/Analysis/BodyFarm.cpp
|
llvm::SmallVectorTemplateBase<clang::Expr*, true>::push_back(clang::Expr*)
|
void push_back(ValueParamT Elt) {
const T *EltPtr = reserveForParamAndGetAddress(Elt);
memcpy(reinterpret_cast<void *>(this->end()), EltPtr, sizeof(T));
this->set_size(this->size() + 1);
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %edx
cmpl 0xc(%rdi), %edx
jae 0x77eef
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
movq %r14, (%rax,%rcx,8)
incl 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
incq %rdx
leaq 0x10(%rbx), %rsi
movl $0x8, %ecx
movq %rbx, %rdi
callq 0x56f14
jmp 0x77eda
nop
|
/llvm/ADT/SmallVector.h
|
create_call_once_funcptr_call(clang::ASTContext&, (anonymous namespace)::ASTMaker, clang::ParmVarDecl const*, llvm::ArrayRef<clang::Expr*>)
|
static CallExpr *create_call_once_funcptr_call(ASTContext &C, ASTMaker M,
const ParmVarDecl *Callback,
ArrayRef<Expr *> CallArgs) {
QualType Ty = Callback->getType();
DeclRefExpr *Call = M.makeDeclRefExpr(Callback);
Expr *SubExpr;
if (Ty->isRValueReferenceType()) {
SubExpr = M.makeImplicitCast(
Call, Ty.getNonReferenceType(), CK_LValueToRValue);
} else if (Ty->isLValueReferenceType() &&
Call->getType()->isFunctionType()) {
Ty = C.getPointerType(Ty.getNonReferenceType());
SubExpr = M.makeImplicitCast(Call, Ty, CK_FunctionToPointerDecay);
} else if (Ty->isLValueReferenceType()
&& Call->getType()->isPointerType()
&& Call->getType()->getPointeeType()->isFunctionType()){
SubExpr = Call;
} else {
llvm_unreachable("Unexpected state");
}
return CallExpr::Create(C, SubExpr, CallArgs, C.VoidTy, VK_PRValue,
SourceLocation(), FPOptionsOverride());
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %r13
movq %rdi, %r15
movq %rsp, %rdi
movq %rsi, (%rdi)
movq 0x30(%rdx), %rbp
movq %rdx, %rsi
xorl %edx, %edx
callq 0x77c0a
movq %rax, %r12
movq %rbp, %rax
andq $-0x10, %rax
movq (%rax), %rdi
movq 0x8(%rdi), %rax
andq $-0x10, %rax
movq (%rax), %rax
movb 0x10(%rax), %al
cmpb $0x2a, %al
jne 0x7803c
callq 0x77c7e
testq %rax, %rax
je 0x78014
movq %rax, %rdi
callq 0x77caa
movq %rax, %rbp
subq $0x8, %rsp
movq %r13, %rdi
movq %rbp, %rsi
movl $0x4, %edx
movq %r12, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq $0x0
callq 0xd7aae
addq $0x10, %rsp
movq %rax, %r12
jmp 0x780a2
cmpb $0x29, %al
jne 0x78091
movq 0x8(%r12), %rax
andq $-0x10, %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
andq $-0x10, %rax
movq (%rax), %rax
movb 0x10(%rax), %al
addb $-0x19, %al
cmpb $0x1, %al
ja 0x78091
callq 0x77c7e
testq %rax, %rax
je 0x78075
movq %rax, %rdi
callq 0x77caa
movq %rax, %rbp
movq %r15, %rdi
movq %rbp, %rsi
callq 0x8a9e4
subq $0x8, %rsp
movq %r13, %rdi
movq %rax, %rsi
movl $0xc, %edx
jmp 0x78023
movq 0x8(%r12), %rax
andq $-0x10, %rax
movq (%rax), %rdi
callq 0x224ac4
movq 0x47e8(%r15), %r8
xorl %eax, %eax
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
xorl %r9d, %r9d
pushq %rax
pushq %rax
pushq $0x0
pushq %rax
callq 0xd7074
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/Analysis/BodyFarm.cpp
|
llvm::SmallDenseMap<clang::QualType, clang::CXXBasePaths::IsVirtBaseAndNumberNonVirtBases, 8u, llvm::DenseMapInfo<clang::QualType, void>, llvm::detail::DenseMapPair<clang::QualType, clang::CXXBasePaths::IsVirtBaseAndNumberNonVirtBases>>::init(unsigned int)
|
void init(unsigned InitBuckets) {
Small = true;
if (InitBuckets > InlineBuckets) {
Small = false;
new (getLargeRep()) LargeRep(allocateBuckets(InitBuckets));
}
this->BaseT::initEmpty();
}
|
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
movl %eax, %ecx
orl $0x1, %ecx
movl %ecx, (%rdi)
cmpl $0x9, %esi
jb 0x78378
movl %esi, %ebp
andl $-0x2, %eax
movl %eax, (%rbx)
movl %esi, %edi
shlq $0x4, %rdi
movl $0x8, %esi
callq 0x56dc3
movq %rax, 0x8(%rbx)
movl %ebp, 0x10(%rbx)
leaq 0x8(%rbx), %rax
andl $0x1, (%rbx)
movl $0x0, 0x4(%rbx)
cmoveq 0x8(%rbx), %rax
movl $0x8, %ecx
cmovel 0x10(%rbx), %ecx
testl %ecx, %ecx
je 0x7844a
movl %ecx, %ecx
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x1, %ecx
negq %rcx
addq %rdx, %rcx
addq $0x2, %rcx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
addq $0x10, %rax
xorl %edx, %edx
movdqa 0x2a9c2d(%rip), %xmm1 # 0x322000
movdqa 0x2a9c35(%rip), %xmm2 # 0x322010
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movq %rdx, %xmm4
pshufd $0x44, %xmm4, %xmm4 # xmm4 = xmm4[0,1,0,1]
por %xmm1, %xmm4
pxor %xmm2, %xmm4
movdqa %xmm4, %xmm5
pcmpgtd %xmm0, %xmm5
pcmpeqd %xmm0, %xmm4
pshufd $0xf5, %xmm4, %xmm6 # xmm6 = xmm4[1,1,3,3]
pand %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm4 # xmm4 = xmm5[1,1,3,3]
por %xmm6, %xmm4
movd %xmm4, %esi
notl %esi
testb $0x1, %sil
je 0x78427
movq $0x0, -0x10(%rax)
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %esi
testb $0x1, %sil
je 0x7843d
movq $0x0, (%rax)
addq $0x2, %rdx
addq $0x20, %rax
cmpq %rdx, %rcx
jne 0x783e3
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
|
/llvm/ADT/DenseMap.h
|
clang::CFGBlock::addSuccessor(clang::CFGBlock::AdjacentBlock, clang::BumpVectorContext&)
|
void CFGBlock::addSuccessor(AdjacentBlock Succ,
BumpVectorContext &C) {
if (CFGBlock *B = Succ.getReachableBlock())
B->Preds.push_back(AdjacentBlock(this, Succ.isReachable()), C);
if (CFGBlock *UnreachableB = Succ.getPossiblyUnreachableBlock())
UnreachableB->Preds.push_back(AdjacentBlock(this, false), C);
Succs.push_back(Succ, C);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
testq %rsi, %rsi
je 0x79910
xorl %edx, %edx
testb $0x2, %bl
sete %dl
movq %rsp, %rdi
movq %r14, %rsi
callq 0x7985e
movq 0x40(%r15), %rax
cmpq 0x48(%r15), %rax
jb 0x79900
leaq 0x38(%r15), %rdi
movl $0x1, %edx
movq %r12, %rsi
callq 0x79b80
movq 0x40(%r15), %rax
movups (%rsp), %xmm0
movups %xmm0, (%rax)
addq $0x10, 0x40(%r15)
movq %rbx, %r13
andq $-0x8, %r13
je 0x79951
movq %rsp, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x7985e
movq 0x40(%r13), %rax
cmpq 0x48(%r13), %rax
jb 0x79941
leaq 0x38(%r13), %rdi
movl $0x1, %edx
movq %r12, %rsi
callq 0x79b80
movq 0x40(%r13), %rax
movups (%rsp), %xmm0
movups %xmm0, (%rax)
addq $0x10, 0x40(%r13)
movq 0x58(%r14), %rax
cmpq 0x60(%r14), %rax
jb 0x7996c
leaq 0x50(%r14), %rdi
movl $0x1, %edx
movq %r12, %rsi
callq 0x79b80
movq 0x58(%r14), %rax
movq %r15, (%rax)
movq %rbx, 0x8(%rax)
addq $0x10, 0x58(%r14)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/Analysis/CFG.cpp
|
clang::BumpVector<clang::CFGBlock*>::grow(clang::BumpVectorContext&, unsigned long)
|
void BumpVector<T>::grow(BumpVectorContext &C, size_t MinSize) {
size_t CurCapacity = Capacity-Begin;
size_t CurSize = size();
size_t NewCapacity = 2*CurCapacity;
if (NewCapacity < MinSize)
NewCapacity = MinSize;
// Allocate the memory from the BumpPtrAllocator.
T *NewElts = C.getAllocator().template Allocate<T>(NewCapacity);
// Copy the elements over.
if (Begin != End) {
if (std::is_class<T>::value) {
std::uninitialized_copy(Begin, End, NewElts);
// Destroy the original elements.
destroy_range(Begin, End);
} else {
// Use memcpy for PODs (std::uninitialized_copy optimizes to memmove).
memcpy(NewElts, Begin, CurSize * sizeof(T));
}
}
// For now, leak 'Begin'. We can add it back to a freelist in
// BumpVectorContext.
Begin = NewElts;
End = NewElts+CurSize;
Capacity = Begin+NewCapacity;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %r12
movq (%rdi), %rax
movq 0x8(%rdi), %r14
subq %rax, %r12
subq %rax, %r14
sarq $0x2, %r12
cmpq %rdx, %r12
cmovbeq %rdx, %r12
movq (%rsi), %rdi
andq $-0x8, %rdi
leaq (,%r12,8), %rsi
movl $0x3, %edx
callq 0x6515a
movq %rax, %r15
movq (%rbx), %rsi
cmpq 0x8(%rbx), %rsi
je 0x79cf5
movq %r15, %rdi
movq %r14, %rdx
callq 0x3c370
movq %r15, (%rbx)
addq %r15, %r14
movq %r14, 0x8(%rbx)
leaq (%r15,%r12,8), %rax
movq %rax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/clang/Analysis/Support/BumpVector.h
|
clang::CXXRecordDecl::bases() const
|
base_class_const_range bases() const {
return base_class_const_range(bases_begin(), bases_end());
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x79f9a
movq %rax, %r14
movq %rbx, %rdi
callq 0x79f9a
movq %rax, %r15
movq 0x68(%rbx), %rsi
leaq 0x60(%rsi), %rdi
callq 0x79ef0
movq 0x80(%rbx), %rax
movl 0x10(%rax), %eax
leaq (%rax,%rax,2), %rax
leaq (%r15,%rax,8), %rdx
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
|
/clang/AST/DeclCXX.h
|
(anonymous namespace)::CFGBuilder::VisitAttributedStmt(clang::AttributedStmt*, (anonymous namespace)::AddStmtChoice)
|
CFGBlock *CFGBuilder::VisitAttributedStmt(AttributedStmt *A,
AddStmtChoice asc) {
// AttributedStmts for [[likely]] can have arbitrary statements as children,
// and the current visitation order here would add the AttributedStmts
// for [[likely]] after the child nodes, which is undesirable: For example,
// if the child contains an unconditional return, the [[likely]] would be
// considered unreachable.
// So only add the AttributedStmt for FallThrough, which has CFG effects and
// also no children, and omit the others. None of the other current StmtAttrs
// have semantic meaning for the CFG.
if (isFallthroughStatement(A) && asc.alwaysAdd(*this, A)) {
autoCreateBlock();
appendStmt(Block, A);
}
return VisitChildren(A);
}
|
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsi), %rax
movl (%rsi), %esi
movl %esi, %edx
shrl $0x8, %edx
leaq (%rbx,%rdx,8), %rcx
addq $0x10, %rcx
cmpl $0x100, %esi # imm = 0x100
jb 0x7aba2
shll $0x3, %edx
movq (%rax), %rsi
cmpw $0x26, 0x20(%rsi)
je 0x7aba2
addq $0x8, %rax
addq $-0x8, %rdx
jne 0x7ab8e
cmpq %rcx, %rax
je 0x7abe6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7ec82
cmpl $0x1, %ebp
sete %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x7abe6
cmpq $0x0, 0x10(%r14)
jne 0x7abd7
movq %r14, %rdi
movl $0x1, %esi
callq 0x79d14
movq %rax, 0x10(%r14)
movq 0x10(%r14), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x7ebf8
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x7fd02
nop
|
/Analysis/CFG.cpp
|
(anonymous namespace)::CFGBuilder::VisitCXXBindTemporaryExpr(clang::CXXBindTemporaryExpr*, (anonymous namespace)::AddStmtChoice)
|
CFGBlock *CFGBuilder::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E,
AddStmtChoice asc) {
if (asc.alwaysAdd(*this, E)) {
autoCreateBlock();
appendStmt(Block, E);
findConstructionContexts(
ConstructionContextLayer::create(cfg->getBumpVectorContext(), E),
E->getSubExpr());
// We do not want to propagate the AlwaysAdd property.
asc = asc.withAlwaysAdd(false);
}
return Visit(E->getSubExpr(), asc);
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
callq 0x7ec82
cmpl $0x1, %r15d
sete %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x7b803
cmpq $0x0, 0x10(%rbx)
jne 0x7b7c5
movq %rbx, %rdi
movl $0x1, %esi
callq 0x79d14
movq %rax, 0x10(%rbx)
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x7ebf8
movq 0x8(%rbx), %rdi
addq $0x20, %rdi
movq %rsp, %rsi
movq %r14, (%rsi)
movq $0x4, 0x8(%rsi)
xorl %r15d, %r15d
xorl %edx, %edx
callq 0x85a02
movq 0x18(%r14), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x82a9c
movq 0x18(%r14), %rsi
movq %rbx, %rdi
movl %r15d, %edx
xorl %ecx, %ecx
callq 0x7a00a
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/Analysis/CFG.cpp
|
(anonymous namespace)::CFGBuilder::VisitCXXDeleteExpr(clang::CXXDeleteExpr*, (anonymous namespace)::AddStmtChoice)
|
CFGBlock *CFGBuilder::VisitCXXDeleteExpr(CXXDeleteExpr *DE,
AddStmtChoice asc) {
autoCreateBlock();
appendStmt(Block, DE);
QualType DTy = DE->getDestroyedType();
if (!DTy.isNull()) {
DTy = DTy.getNonReferenceType();
CXXRecordDecl *RD = Context->getBaseElementType(DTy)->getAsCXXRecordDecl();
if (RD) {
if (RD->isCompleteDefinition() && !RD->hasTrivialDestructor())
appendDeleteDtor(Block, RD, DE);
}
}
return VisitChildren(DE);
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
jne 0x7ba83
movq %r14, %rdi
movl $0x1, %esi
callq 0x79d14
movq %rax, 0x10(%r14)
movq 0x10(%r14), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x7ebf8
movq %rbx, %rdi
callq 0x12e5d6
cmpq $0x10, %rax
jb 0x7bb15
movq %rax, %r15
andq $-0x10, %rax
movq (%rax), %rdi
callq 0x77c7e
testq %rax, %rax
je 0x7babf
movq %rax, %rdi
callq 0x77caa
movq %rax, %r15
movq (%r14), %rdi
movq %r15, %rsi
callq 0x8ab56
andq $-0x10, %rax
movq (%rax), %rdi
callq 0x224c70
testq %rax, %rax
je 0x7bb15
movq %rax, %r15
testb $0x1, 0x4a(%rax)
je 0x7bb15
movq 0x68(%r15), %rsi
leaq 0x60(%rsi), %rdi
callq 0x79ef0
movq 0x80(%r15), %rax
testb $0x10, 0x5(%rax)
jne 0x7bb15
movq 0x8(%r14), %rcx
movq 0x10(%r14), %rdi
addq $0x20, %rcx
movq %r15, %rsi
movq %rbx, %rdx
callq 0x83c40
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x7fd02
nop
|
/Analysis/CFG.cpp
|
(anonymous namespace)::CFGBuilder::VisitDeclStmt(clang::DeclStmt*)
|
CFGBlock *CFGBuilder::VisitDeclStmt(DeclStmt *DS) {
// Check if the Decl is for an __label__. If so, elide it from the
// CFG entirely.
if (isa<LabelDecl>(*DS->decl_begin()))
return Block;
// This case also handles static_asserts.
if (DS->isSingleDecl())
return VisitDeclSubExpr(DS);
CFGBlock *B = nullptr;
// Build an individual DeclStmt for each decl.
for (DeclStmt::reverse_decl_iterator I = DS->decl_rbegin(),
E = DS->decl_rend();
I != E; ++I) {
// Allocate the DeclStmt using the BumpPtrAllocator. It will get
// automatically freed with the CFG.
DeclGroupRef DG(*I);
Decl *D = *I;
DeclStmt *DSNew = new (Context) DeclStmt(DG, D->getLocation(), GetEndLoc(D));
cfg->addSyntheticDeclStmt(DSNew, DS);
// Append the fake DeclStmt to block.
B = VisitDeclSubExpr(DSNew);
}
return B;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x8(%rsi), %rcx
movq %rsi, 0x8(%rsp)
movq 0x8(%rsi), %rax
testq %rax, %rax
cmoveq %rax, %rcx
movq %rax, %rdx
andq $-0x2, %rdx
movq %rdx, (%rsp)
addq $0x8, %rdx
testb $0x1, %al
cmoveq %rcx, %rdx
movq (%rdx), %rcx
movl 0x1c(%rcx), %ecx
andl $0x7f, %ecx
cmpl $0x4b, %ecx
jne 0x7c2df
movq 0x10(%r14), %rax
jmp 0x7c39f
testb $0x1, %al
jne 0x7c2fe
movq %r14, %rdi
movq 0x8(%rsp), %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x83e00
movq (%rsp), %rax
movl (%rax), %ebx
testq %rbx, %rbx
je 0x7c39d
shlq $0x3, %rbx
movq (%rsp), %rax
movq (%rax,%rbx), %r13
movq (%r14), %rsi
movl $0x18, %edi
movl $0x8, %edx
callq 0x20d126
movq %rax, %r12
movl 0x18(%r13), %r15d
movq %r13, %rdi
callq 0x84286
movl %eax, %ebp
movb $-0x1b, (%r12)
leaq 0x49b9e8(%rip), %rax # 0x517d30
cmpb $0x1, (%rax)
jne 0x7c357
movl $0xe5, %edi
callq 0x20e4ba
movq %r13, 0x8(%r12)
movl %r15d, 0x10(%r12)
movl %ebp, 0x14(%r12)
movq 0x8(%r14), %rdi
movq %r12, 0x10(%rsp)
addq $0x58, %rdi
leaq 0x10(%rsp), %rsi
callq 0x843e0
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq %r14, %rdi
movq %r12, %rsi
callq 0x83e00
addq $-0x8, %rbx
jne 0x7c311
jmp 0x7c39f
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/Analysis/CFG.cpp
|
(anonymous namespace)::CFGBuilder::VisitDefaultStmt(clang::DefaultStmt*)
|
CFGBlock *CFGBuilder::VisitDefaultStmt(DefaultStmt *Terminator) {
if (Terminator->getSubStmt())
addStmt(Terminator->getSubStmt());
DefaultCaseBlock = Block;
if (!DefaultCaseBlock)
DefaultCaseBlock = createBlock();
// Default statements partition blocks, so this is the top of the basic block
// we were processing (the "default:" is the label).
DefaultCaseBlock->setLabel(Terminator);
if (badCFG)
return nullptr;
// Unlike case statements, we don't add the default block to the successors
// for the switch statement immediately. This is done when we finish
// processing the switch statement. This allows for the default case
// (including a fall-through to the code after the switch statement) to always
// be the last successor of a switch-terminated block.
// We set Block to NULL to allow lazy creation of a new block (if necessary).
Block = nullptr;
// This block is now the implicit successor of other blocks.
Succ = DefaultCaseBlock;
return DefaultCaseBlock;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %rsi
testq %rsi, %rsi
je 0x7c3d0
movq %rbx, %rdi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x7a00a
movq 0x10(%rbx), %rax
movq %rax, 0x70(%rbx)
testq %rax, %rax
jne 0x7c3ee
movq %rbx, %rdi
movl $0x1, %esi
callq 0x79d14
movq %rax, 0x70(%rbx)
movq 0x70(%rbx), %rax
movq %r14, 0x18(%rax)
cmpb $0x0, 0x140(%rbx)
je 0x7c403
xorl %eax, %eax
jmp 0x7c40f
movq $0x0, 0x10(%rbx)
movq %rax, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/Analysis/CFG.cpp
|
(anonymous namespace)::CFGBuilder::VisitSwitchStmt(clang::SwitchStmt*)
|
CFGBlock *CFGBuilder::VisitSwitchStmt(SwitchStmt *Terminator) {
// "switch" is a control-flow statement. Thus we stop processing the current
// block.
CFGBlock *SwitchSuccessor = nullptr;
// Save local scope position because in case of condition variable ScopePos
// won't be restored when traversing AST.
SaveAndRestore save_scope_pos(ScopePos);
// Create local scope for C++17 switch init-stmt if one exists.
if (Stmt *Init = Terminator->getInit())
addLocalScopeForStmt(Init);
// Create local scope for possible condition variable.
// Store scope position. Add implicit destructor.
if (VarDecl *VD = Terminator->getConditionVariable())
addLocalScopeForVarDecl(VD);
addAutomaticObjHandling(ScopePos, save_scope_pos.get(), Terminator);
if (Block) {
if (badCFG)
return nullptr;
SwitchSuccessor = Block;
} else SwitchSuccessor = Succ;
// Save the current "switch" context.
SaveAndRestore save_switch(SwitchTerminatedBlock),
save_default(DefaultCaseBlock);
SaveAndRestore save_break(BreakJumpTarget);
// Set the "default" case to be the block after the switch statement. If the
// switch statement contains a "default:", this value will be overwritten with
// the block for that code.
DefaultCaseBlock = SwitchSuccessor;
// Create a new block that will contain the switch statement.
SwitchTerminatedBlock = createBlock(false);
// Now process the switch body. The code after the switch is the implicit
// successor.
Succ = SwitchSuccessor;
BreakJumpTarget = JumpTarget(SwitchSuccessor, ScopePos);
// When visiting the body, the case statements should automatically get linked
// up to the switch. We also don't keep a pointer to the body, since all
// control-flow from the switch goes to case/default statements.
assert(Terminator->getBody() && "switch must contain a non-NULL body");
Block = nullptr;
// For pruning unreachable case statements, save the current state
// for tracking the condition value.
SaveAndRestore save_switchExclusivelyCovered(switchExclusivelyCovered, false);
// Determine if the switch condition can be explicitly evaluated.
assert(Terminator->getCond() && "switch condition must be non-NULL");
Expr::EvalResult result;
bool b = tryEvaluate(Terminator->getCond(), result);
SaveAndRestore save_switchCond(switchCond, b ? &result : nullptr);
// If body is not a compound statement create implicit scope
// and add destructors.
if (!isa<CompoundStmt>(Terminator->getBody()))
addLocalScopeAndDtors(Terminator->getBody());
addStmt(Terminator->getBody());
if (Block) {
if (badCFG)
return nullptr;
}
// If we have no "default:" case, the default transition is to the code
// following the switch body. Moreover, take into account if all the
// cases of a switch are covered (e.g., switching on an enum value).
//
// Note: We add a successor to a switch that is considered covered yet has no
// case statements if the enumeration has no enumerators.
bool SwitchAlwaysHasSuccessor = false;
SwitchAlwaysHasSuccessor |= switchExclusivelyCovered;
SwitchAlwaysHasSuccessor |= Terminator->isAllEnumCasesCovered() &&
Terminator->getSwitchCaseList();
addSuccessor(SwitchTerminatedBlock, DefaultCaseBlock,
!SwitchAlwaysHasSuccessor);
// Add the terminator and condition in the switch block.
SwitchTerminatedBlock->setTerminator(Terminator);
Block = SwitchTerminatedBlock;
CFGBlock *LastBlock = addStmt(Terminator->getCond());
// If the SwitchStmt contains a condition variable, add both the
// SwitchStmt and the condition variable initialization to the CFG.
if (VarDecl *VD = Terminator->getConditionVariable()) {
if (Expr *Init = VD->getInit()) {
autoCreateBlock();
appendStmt(Block, Terminator->getConditionVariableDeclStmt());
LastBlock = addStmt(Init);
maybeAddScopeBeginForVarDecl(LastBlock, VD, Init);
}
}
// Finally, if the SwitchStmt contains a C++17 init-stmt, add it to the CFG.
if (Stmt *Init = Terminator->getInit()) {
autoCreateBlock();
LastBlock = addStmt(Init);
}
return LastBlock;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r15
movq %rdi, %rbx
testb $0x1, 0x1(%rsi)
jne 0x7e33d
xorl %esi, %esi
jmp 0x7e341
movq 0x18(%r15), %rsi
movq 0x80(%rbx), %r14
movl 0x88(%rbx), %ebp
testq %rsi, %rsi
je 0x7e35b
movq %rbx, %rdi
callq 0x7f060
movq %r15, %rdi
callq 0x21004c
testq %rax, %rax
je 0x7e375
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x7f55c
movq 0x80(%rbx), %rsi
movl 0x88(%rbx), %edx
movq %rbx, %rdi
movq %r14, 0x18(%rsp)
movq %r14, %rcx
movl %ebp, %r8d
movq %r15, %r9
callq 0x7f0fa
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0x7e3b2
cmpb $0x0, 0x140(%rbx)
je 0x7e3b6
xorl %r12d, %r12d
jmp 0x7e6ab
movq 0x18(%rbx), %r14
movups 0x68(%rbx), %xmm0
movaps %xmm0, 0x40(%rsp)
movq 0x48(%rbx), %rax
movq %rax, 0x30(%rsp)
movups 0x38(%rbx), %xmm0
movaps %xmm0, 0x20(%rsp)
movq %r14, 0x70(%rbx)
movq 0x8(%rbx), %rdi
callq 0x78c38
movq %rax, 0x68(%rbx)
movq %r14, 0x18(%rbx)
movq 0x80(%rbx), %rax
movl 0x88(%rbx), %ecx
movq %r14, 0x38(%rbx)
movq %rax, 0x40(%rbx)
movl %ecx, 0x48(%rbx)
xorl %r12d, %r12d
movq %r12, 0x10(%rbx)
movb 0x150(%rbx), %al
movb %al, 0xf(%rsp)
movb $0x0, 0x150(%rbx)
movw $0x0, 0x50(%rsp)
movq %r12, 0x58(%rsp)
movl $0x0, 0x60(%rsp)
movzwl (%r15), %ecx
movl %ecx, %eax
shrl $0x8, %eax
andl $0x1, %eax
btl $0x9, %ecx
adcl $0x0, %eax
movq 0x148(%rbx), %rcx
cmpb $0x1, 0x30(%rcx)
movl $0x0, %r13d
jne 0x7e483
shll $0x3, %eax
movq 0x18(%r15,%rax), %rdi
movzwl 0x1(%rdi), %eax
testl $0x180, %eax # imm = 0x180
je 0x7e468
xorl %r13d, %r13d
jmp 0x7e483
movq (%rbx), %rdx
leaq 0x50(%rsp), %r14
xorl %r13d, %r13d
movq %r14, %rsi
xorl %ecx, %ecx
callq 0xde39e
testb %al, %al
cmovneq %r14, %r13
movq 0x158(%rbx), %rax
movq %rax, 0x10(%rsp)
movq %r13, 0x158(%rbx)
movzwl (%r15), %eax
btl $0x9, %eax
adcl $0x1, %r12d
btl $0x8, %eax
adcl $0x0, %r12d
shll $0x3, %r12d
movq 0x18(%r15,%r12), %rsi
cmpb $-0x17, (%rsi)
je 0x7e4c0
movq %rbx, %rdi
callq 0x7ec3a
movzwl (%r15), %eax
xorl %r14d, %r14d
btl $0x9, %eax
movl $0x0, %ecx
adcl $0x1, %ecx
btl $0x8, %eax
adcl $0x0, %ecx
shll $0x3, %ecx
movq 0x18(%r15,%rcx), %rsi
movq %rbx, %rdi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x7a00a
cmpq $0x0, 0x10(%rbx)
je 0x7e509
cmpb $0x0, 0x140(%rbx)
je 0x7e509
xorl %r12d, %r12d
jmp 0x7e665
movzbl 0x150(%rbx), %eax
testb $0x4, 0x1(%r15)
je 0x7e523
xorl %r14d, %r14d
cmpq $0x0, 0x8(%r15)
setne %r14b
xorl %edx, %edx
orl %eax, %r14d
sete %dl
movq 0x68(%rbx), %r14
movq 0x70(%rbx), %rsi
leaq 0xa8(%rsp), %r12
movq %r12, %rdi
callq 0x7985e
movq 0x8(%rbx), %rcx
addq $0x20, %rcx
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r14, %rdi
callq 0x798b4
movq 0x68(%rbx), %rax
movq %r15, %rcx
andq $-0x7, %rcx
movq %rcx, 0x20(%rax)
movq 0x68(%rbx), %rax
movq %rax, 0x10(%rbx)
movzwl (%r15), %eax
movl %eax, %ecx
shrl $0x8, %ecx
andl $0x1, %ecx
btl $0x9, %eax
adcl $0x0, %ecx
shll $0x3, %ecx
movq 0x18(%r15,%rcx), %rsi
movq %rbx, %rdi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x7a00a
movq %rax, %r12
movq %r15, %rdi
callq 0x21004c
testq %rax, %rax
je 0x7e623
movq %rax, %r13
movq %rax, %rdi
callq 0xbbd6c
testq %rax, %rax
je 0x7e623
movq %rax, %r14
cmpq $0x0, 0x10(%rbx)
jne 0x7e5d8
movq %rbx, %rdi
movl $0x1, %esi
callq 0x79d14
movq %rax, 0x10(%rbx)
movq 0x10(%rbx), %rsi
movzwl (%r15), %eax
btl $0x9, %eax
jb 0x7e5ea
xorl %edx, %edx
jmp 0x7e5f5
shrl $0x5, %eax
andl $0x8, %eax
movq 0x18(%r15,%rax), %rdx
movq %rbx, %rdi
callq 0x7ebf8
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x7a00a
movq %rax, %r12
movq %rbx, %rdi
movq %rax, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0x84350
testb $0x1, 0x1(%r15)
jne 0x7e62f
xorl %r14d, %r14d
jmp 0x7e633
movq 0x18(%r15), %r14
testq %r14, %r14
je 0x7e665
cmpq $0x0, 0x10(%rbx)
jne 0x7e650
movq %rbx, %rdi
movl $0x1, %esi
callq 0x79d14
movq %rax, 0x10(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x7a00a
movq %rax, %r12
leaq 0x38(%rbx), %r14
movq 0x10(%rsp), %rax
movq %rax, 0x158(%rbx)
cmpl $0x2, 0x60(%rsp)
jb 0x7e686
leaq 0x60(%rsp), %rdi
callq 0x86f80
movb 0xf(%rsp), %al
movb %al, 0x150(%rbx)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%r14)
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%r14)
movaps 0x40(%rsp), %xmm0
movups %xmm0, 0x68(%rbx)
movq 0x18(%rsp), %rax
movq %rax, 0x80(%rbx)
movl %ebp, 0x88(%rbx)
movq %r12, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/Analysis/CFG.cpp
|
(anonymous namespace)::CFGBuilder::addLocalScopeForDeclStmt(clang::DeclStmt*, (anonymous namespace)::LocalScope*)
|
LocalScope* CFGBuilder::addLocalScopeForDeclStmt(DeclStmt *DS,
LocalScope* Scope) {
if (!BuildOpts.AddImplicitDtors && !BuildOpts.AddLifetime &&
!BuildOpts.AddScopes)
return Scope;
for (auto *DI : DS->decls())
if (VarDecl *VD = dyn_cast<VarDecl>(DI))
Scope = addLocalScopeForVarDecl(VD, Scope);
return Scope;
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x148(%rdi), %rcx
cmpb $0x0, 0x33(%rcx)
jne 0x7f4f9
cmpb $0x0, 0x34(%rcx)
jne 0x7f4f9
cmpb $0x1, 0x37(%rcx)
jne 0x7f555
movq 0x8(%r14), %rcx
testb $0x1, %cl
jne 0x7f517
leaq 0x8(%r14), %r15
addq $0x10, %r14
testq %rcx, %rcx
cmoveq %rcx, %r15
cmoveq %rcx, %r14
jmp 0x7f550
andq $-0x2, %rcx
leaq 0x8(%rcx), %r15
movl (%rcx), %edx
leaq (%rcx,%rdx,8), %r14
addq $0x8, %r14
jmp 0x7f550
movq (%r15), %rsi
testq %rsi, %rsi
je 0x7f54c
movl 0x1c(%rsi), %ecx
andl $0x7f, %ecx
addl $-0x2c, %ecx
cmpl $-0x7, %ecx
jb 0x7f54c
movq %rbx, %rdi
movq %rax, %rdx
callq 0x7f55c
addq $0x8, %r15
cmpq %r14, %r15
jne 0x7f52b
popq %rbx
popq %r14
popq %r15
retq
nop
|
/Analysis/CFG.cpp
|
(anonymous namespace)::CFGBuilder::addLocalScopeForVarDecl(clang::VarDecl*, (anonymous namespace)::LocalScope*)
|
LocalScope* CFGBuilder::addLocalScopeForVarDecl(VarDecl *VD,
LocalScope* Scope) {
if (!BuildOpts.AddImplicitDtors && !BuildOpts.AddLifetime &&
!BuildOpts.AddScopes)
return Scope;
// Check if variable is local.
if (!VD->hasLocalStorage())
return Scope;
if (!BuildOpts.AddLifetime && !BuildOpts.AddScopes &&
!needsAutomaticDestruction(VD)) {
assert(BuildOpts.AddImplicitDtors);
return Scope;
}
// Add the variable to scope
Scope = createOrReuseLocalScope(Scope);
Scope->addVar(VD);
ScopePos = Scope->begin();
return Scope;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x148(%rdi), %rax
cmpb $0x0, 0x33(%rax)
jne 0x7f58d
cmpb $0x0, 0x34(%rax)
jne 0x7f58d
cmpb $0x1, 0x37(%rax)
jne 0x7f695
movq %r15, %rdi
callq 0x763d8
testb %al, %al
je 0x7f695
movq 0x148(%r14), %rax
cmpb $0x0, 0x34(%rax)
jne 0x7f5cf
cmpb $0x0, 0x37(%rax)
jne 0x7f5cf
movq %r14, %rdi
movq %r15, %rsi
callq 0x7f6a8
testb %al, %al
je 0x7f5cf
movq %r15, %rdi
callq 0x7f7be
testb %al, %al
je 0x7f695
testq %rbx, %rbx
jne 0x7f643
movq 0x8(%r14), %rax
movq 0x20(%rax), %r12
andq $-0x8, %r12
movl $0x30, %esi
movq %r12, %rdi
movl $0x4, %edx
callq 0x6515a
movq %rax, %rbx
movq %rsp, %rax
movq %r12, (%rax)
movq 0x80(%r14), %rbp
movl 0x88(%r14), %r13d
movq %r12, (%rbx)
andq $0x3, (%rax)
movq %rax, %r12
leaq 0x8(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq $0x0, 0x18(%rbx)
movl $0x4, %edx
movq %rbx, %rsi
callq 0x7f800
movq %rbp, 0x20(%rbx)
movl %r13d, 0x28(%rbx)
movq %r12, %rdi
callq 0x76338
movq 0x10(%rbx), %rax
cmpq 0x18(%rbx), %rax
jb 0x7f65e
leaq 0x8(%rbx), %rdi
movl $0x1, %edx
movq %rbx, %rsi
callq 0x7f800
movq 0x10(%rbx), %rax
movq %r15, (%rax)
movq 0x10(%rbx), %rax
addq $0x8, %rax
movq %rax, 0x10(%rbx)
subq 0x8(%rbx), %rax
shrq $0x3, %rax
movq %rbx, %rcx
testl %eax, %eax
jne 0x7f687
movl 0x28(%rbx), %eax
movq 0x20(%rbx), %rcx
movq %rcx, 0x80(%r14)
movl %eax, 0x88(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/Analysis/CFG.cpp
|
llvm::DenseMapBase<llvm::DenseMap<clang::LabelDecl*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<clang::LabelDecl*, void>, llvm::detail::DenseSetPair<clang::LabelDecl*>>, clang::LabelDecl*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<clang::LabelDecl*, void>, llvm::detail::DenseSetPair<clang::LabelDecl*>>::moveFromOldBuckets(llvm::detail::DenseSetPair<clang::LabelDecl*>*, llvm::detail::DenseSetPair<clang::LabelDecl*>*)
|
void moveFromOldBuckets(BucketT *OldBucketsBegin, BucketT *OldBucketsEnd) {
initEmpty();
// Insert all the old elements.
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
for (BucketT *B = OldBucketsBegin, *E = OldBucketsEnd; B != E; ++B) {
if (!KeyInfoT::isEqual(B->getFirst(), EmptyKey) &&
!KeyInfoT::isEqual(B->getFirst(), TombstoneKey)) {
// Insert the key/value into the new table.
BucketT *DestBucket;
bool FoundVal = LookupBucketFor(B->getFirst(), DestBucket);
(void)FoundVal; // silence warning.
assert(!FoundVal && "Key already in new map?");
DestBucket->getFirst() = std::move(B->getFirst());
::new (&DestBucket->getSecond()) ValueT(std::move(B->getSecond()));
incrementNumEntries();
// Free the value.
B->getSecond().~ValueT();
}
B->getFirst().~KeyT();
}
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq $0x0, 0x8(%rdi)
movl 0x10(%rdi), %ecx
testq %rcx, %rcx
je 0x807d9
movq (%r15), %rax
movabsq $0x1fffffffffffffff, %rdx # imm = 0x1FFFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x1, %ecx
negq %rcx
addq %rdx, %rcx
addq $0x2, %rcx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
xorl %edx, %edx
movdqa 0x2a189c(%rip), %xmm1 # 0x322000
movdqa 0x2a18a4(%rip), %xmm2 # 0x322010
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movq %rdx, %xmm4
pshufd $0x44, %xmm4, %xmm4 # xmm4 = xmm4[0,1,0,1]
por %xmm1, %xmm4
pxor %xmm2, %xmm4
movdqa %xmm4, %xmm5
pcmpgtd %xmm0, %xmm5
pcmpeqd %xmm0, %xmm4
pshufd $0xf5, %xmm4, %xmm6 # xmm6 = xmm4[1,1,3,3]
pand %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm4 # xmm4 = xmm5[1,1,3,3]
por %xmm6, %xmm4
movd %xmm4, %esi
notl %esi
testb $0x1, %sil
je 0x807b8
movq $-0x1000, (%rax,%rdx,8) # imm = 0xF000
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %esi
testb $0x1, %sil
je 0x807d0
movq $-0x1000, 0x8(%rax,%rdx,8) # imm = 0xF000
addq $0x2, %rdx
cmpq %rdx, %rcx
jne 0x80774
cmpq %rbx, %r14
je 0x8081d
movl $0x1000, %r13d # imm = 0x1000
leaq 0x8(%rsp), %r12
movq (%r14), %rax
orq %r13, %rax
cmpq $-0x1000, %rax # imm = 0xF000
je 0x80814
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x804c4
movq 0x8(%rsp), %rax
movq (%r14), %rcx
movq %rcx, (%rax)
incl 0x8(%r15)
addq $0x8, %r14
cmpq %rbx, %r14
jne 0x807e9
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/llvm/ADT/DenseMap.h
|
(anonymous namespace)::CFGBuilder::VisitLogicalOperator(clang::BinaryOperator*, clang::Stmt*, clang::CFGBlock*, clang::CFGBlock*)
|
std::pair<CFGBlock*, CFGBlock*>
CFGBuilder::VisitLogicalOperator(BinaryOperator *B,
Stmt *Term,
CFGBlock *TrueBlock,
CFGBlock *FalseBlock) {
// Introspect the RHS. If it is a nested logical operation, we recursively
// build the CFG using this function. Otherwise, resort to default
// CFG construction behavior.
Expr *RHS = B->getRHS()->IgnoreParens();
CFGBlock *RHSBlock, *ExitBlock;
do {
if (BinaryOperator *B_RHS = dyn_cast<BinaryOperator>(RHS))
if (B_RHS->isLogicalOp()) {
std::tie(RHSBlock, ExitBlock) =
VisitLogicalOperator(B_RHS, Term, TrueBlock, FalseBlock);
break;
}
// The RHS is not a nested logical operation. Don't push the terminator
// down further, but instead visit RHS and construct the respective
// pieces of the CFG, and link up the RHSBlock with the terminator
// we have been provided.
ExitBlock = RHSBlock = createBlock(false);
// Even though KnownVal is only used in the else branch of the next
// conditional, tryEvaluateBool performs additional checking on the
// Expr, so it should be called unconditionally.
TryResult KnownVal = tryEvaluateBool(RHS);
if (!KnownVal.isKnown())
KnownVal = tryEvaluateBool(B);
if (!Term) {
assert(TrueBlock == FalseBlock);
addSuccessor(RHSBlock, TrueBlock);
}
else {
RHSBlock->setTerminator(Term);
addSuccessor(RHSBlock, TrueBlock, !KnownVal.isFalse());
addSuccessor(RHSBlock, FalseBlock, !KnownVal.isTrue());
}
Block = RHSBlock;
RHSBlock = addStmt(RHS);
}
while (false);
if (badCFG)
return std::make_pair(nullptr, nullptr);
// Generate the blocks for evaluating the LHS.
Expr *LHS = B->getLHS()->IgnoreParens();
if (BinaryOperator *B_LHS = dyn_cast<BinaryOperator>(LHS))
if (B_LHS->isLogicalOp()) {
if (B->getOpcode() == BO_LOr)
FalseBlock = RHSBlock;
else
TrueBlock = RHSBlock;
// For the LHS, treat 'B' as the terminator that we want to sink
// into the nested branch. The RHS always gets the top-most
// terminator.
return VisitLogicalOperator(B_LHS, B, TrueBlock, FalseBlock);
}
// Create the block evaluating the LHS.
// This contains the '&&' or '||' as the terminator.
CFGBlock *LHSBlock = createBlock(false);
LHSBlock->setTerminator(B);
Block = LHSBlock;
CFGBlock *EntryLHSBlock = addStmt(LHS);
if (badCFG)
return std::make_pair(nullptr, nullptr);
// See if this is a known constant.
TryResult KnownVal = tryEvaluateBool(LHS);
// Now link the LHSBlock with RHSBlock.
if (B->getOpcode() == BO_LOr) {
addSuccessor(LHSBlock, TrueBlock, !KnownVal.isFalse());
addSuccessor(LHSBlock, RHSBlock, !KnownVal.isTrue());
} else {
assert(B->getOpcode() == BO_LAnd);
addSuccessor(LHSBlock, RHSBlock, !KnownVal.isFalse());
addSuccessor(LHSBlock, FalseBlock, !KnownVal.isTrue());
}
return std::make_pair(EntryLHSBlock, ExitBlock);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
movq 0x18(%rsi), %rdi
callq 0xd90f0
movq %rax, %rbp
movb (%rax), %cl
addb $-0x77, %cl
movb $0x1, %al
cmpb $-0x2, %cl
jae 0x80867
jmp 0x80898
movl (%rbp), %ecx
shrl $0x12, %ecx
andl $0x3f, %ecx
addl $-0x13, %ecx
cmpl $0x1, %ecx
ja 0x80898
movq %rbx, %rdi
movq %rbp, %rsi
movq %r15, %rdx
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %r8
callq 0x8082c
movq %rax, %r14
movq %rdx, %r12
xorl %eax, %eax
testb %al, %al
je 0x8096a
movq 0x8(%rbx), %rdi
callq 0x78c38
movq %rax, %r12
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x80b24
movl %eax, %r14d
testl %eax, %eax
jns 0x808cc
movq %rbx, %rdi
movq %r13, %rsi
callq 0x80b24
movl %eax, %r14d
testq %r15, %r15
je 0x80923
andq $-0x7, %r15
movq %r15, 0x20(%r12)
xorl %edx, %edx
testl %r14d, %r14d
setne %dl
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq 0x8(%rsp), %rsi
callq 0x7985e
movq 0x8(%rbx), %rcx
addq $0x20, %rcx
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r12, %rdi
callq 0x798b4
xorl %edx, %edx
cmpl $0x1, %r14d
setne %dl
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq 0x10(%rsp), %rsi
jmp 0x80935
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq 0x8(%rsp), %rsi
movl $0x1, %edx
callq 0x7985e
movq 0x8(%rbx), %rcx
addq $0x20, %rcx
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r12, %rdi
callq 0x798b4
movq %r12, 0x10(%rbx)
movq %rbx, %rdi
movq %rbp, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x7a00a
movq %rax, %r14
cmpb $0x0, 0x140(%rbx)
je 0x8097d
xorl %r14d, %r14d
xorl %ebp, %ebp
jmp 0x80b0e
movq %r12, 0x30(%rsp)
movq 0x10(%r13), %rdi
callq 0xd90f0
movq %rax, %r12
movb (%rax), %cl
addb $-0x77, %cl
movb $0x1, %al
cmpb $-0x2, %cl
movq %r14, 0x28(%rsp)
jb 0x809f3
movl (%r12), %ecx
shrl $0x12, %ecx
andl $0x3f, %ecx
addl $-0x13, %ecx
cmpl $0x1, %ecx
ja 0x809f3
movl $0xfc0000, %eax # imm = 0xFC0000
andl (%r13), %eax
cmpl $0x500000, %eax # imm = 0x500000
movq 0x10(%rsp), %r8
cmoveq %r14, %r8
movq 0x8(%rsp), %rcx
cmovneq %r14, %rcx
movq %rbx, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rcx, 0x8(%rsp)
movq %r8, 0x10(%rsp)
callq 0x8082c
movq %rax, %rbp
movq %rdx, %r14
xorl %eax, %eax
jmp 0x809f3
testb %al, %al
je 0x80b0e
movq 0x8(%rbx), %rdi
callq 0x78c38
movq %rax, %r15
movq %r13, %rax
andq $-0x7, %rax
movq %rax, 0x20(%r15)
movq %r15, 0x10(%rbx)
xorl %r14d, %r14d
movq %rbx, %rdi
movq %r12, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x7a00a
cmpb $0x0, 0x140(%rbx)
jne 0x80976
movq %rax, %rbp
movq %rbx, %rdi
movq %r12, %rsi
callq 0x80b24
movl $0xfc0000, %ecx # imm = 0xFC0000
andl (%r13), %ecx
xorl %r14d, %r14d
cmpl $0x500000, %ecx # imm = 0x500000
jne 0x80aa2
cmpl $0x1, %eax
setne %r14b
xorl %edx, %edx
testl %eax, %eax
setne %dl
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movq 0x8(%rsp), %rsi
callq 0x7985e
movq 0x8(%rbx), %rcx
addq $0x20, %rcx
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r15, %rdi
callq 0x798b4
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movq 0x28(%rsp), %rsi
jmp 0x80ae8
cmpl $0x1, %eax
setne %r14b
xorl %edx, %edx
testl %eax, %eax
setne %dl
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movq 0x28(%rsp), %rsi
callq 0x7985e
movq 0x8(%rbx), %rcx
addq $0x20, %rcx
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r15, %rdi
callq 0x798b4
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movq 0x10(%rsp), %rsi
movl %r14d, %edx
callq 0x7985e
movq 0x8(%rbx), %rcx
addq $0x20, %rcx
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r15, %rdi
callq 0x798b4
movq 0x30(%rsp), %r14
movq %rbp, %rax
movq %r14, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/Analysis/CFG.cpp
|
(anonymous namespace)::CFGBuilder::tryEvaluateBool(clang::Expr*)
|
TryResult tryEvaluateBool(Expr *S) {
if (!BuildOpts.PruneTriviallyFalseEdges ||
S->isTypeDependent() || S->isValueDependent())
return {};
if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(S)) {
if (Bop->isLogicalOp() || Bop->isEqualityOp()) {
// Check the cache first.
CachedBoolEvalsTy::iterator I = CachedBoolEvals.find(S);
if (I != CachedBoolEvals.end())
return I->second; // already in map;
// Retrieve result at first, or the map might be updated.
TryResult Result = evaluateAsBooleanConditionNoCache(S);
CachedBoolEvals[S] = Result; // update or insert
return Result;
}
else {
switch (Bop->getOpcode()) {
default: break;
// For 'x & 0' and 'x * 0', we can determine that
// the value is always false.
case BO_Mul:
case BO_And: {
// If either operand is zero, we know the value
// must be false.
Expr::EvalResult LHSResult;
if (Bop->getLHS()->EvaluateAsInt(LHSResult, *Context)) {
llvm::APSInt IntVal = LHSResult.Val.getInt();
if (!IntVal.getBoolValue()) {
return TryResult(false);
}
}
Expr::EvalResult RHSResult;
if (Bop->getRHS()->EvaluateAsInt(RHSResult, *Context)) {
llvm::APSInt IntVal = RHSResult.Val.getInt();
if (!IntVal.getBoolValue()) {
return TryResult(false);
}
}
}
break;
}
}
}
return evaluateAsBooleanConditionNoCache(S);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, 0x10(%rsp)
movq 0x148(%rdi), %rax
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
cmpb $0x1, 0x30(%rax)
jne 0x80ea2
movq %rsi, %r14
movzwl 0x1(%rsi), %eax
testl $0x180, %eax # imm = 0x180
jne 0x80ea2
movq %rdi, %rbx
movb (%r14), %al
addb $-0x77, %al
movb $0x1, %r13b
cmpb $-0x2, %al
jae 0x80b76
jmp 0x80e8e
movl (%r14), %ecx
movl %ecx, %eax
shrl $0x12, %eax
andl $0x3f, %eax
leal -0x13(%rax), %edx
cmpl $0x2, %edx
setae %dl
andl $0xf80000, %ecx # imm = 0xF80000
cmpl $0x380000, %ecx # imm = 0x380000
setne %cl
testb %dl, %cl
jne 0x80c2d
movq 0x170(%rbx), %rax
movl 0x180(%rbx), %ecx
testq %rcx, %rcx
je 0x80c9d
movl %r14d, %esi
shrl $0x4, %esi
movl %r14d, %edx
shrl $0x9, %edx
xorl %esi, %edx
leal -0x1(%rcx), %esi
andl %esi, %edx
movl $0x1, %r9d
xorl %edi, %edi
movl %edx, %r15d
shlq $0x4, %r15
leaq (%rax,%r15), %r8
movq (%rax,%r15), %r15
cmpq %r14, %r15
jne 0x80bf8
movb $0x1, %r10b
xorl %ebp, %ebp
movq %r8, %r11
testb %bpl, %bpl
jne 0x80bd2
jmp 0x80ca3
cmpq $-0x1000, %r15 # imm = 0xF000
jne 0x80c0f
testq %rdi, %rdi
cmovneq %rdi, %r8
xorl %ebp, %ebp
xorl %r10d, %r10d
jmp 0x80beb
xorq $-0x2000, %r15 # imm = 0xE000
orq %rdi, %r15
cmoveq %r8, %rdi
addl %r9d, %edx
incl %r9d
andl %esi, %edx
movb $0x1, %bpl
movq %r11, %r8
jmp 0x80beb
cmpl $0x10, %eax
je 0x80c3b
cmpl $0x2, %eax
jne 0x80b71
leaq 0x80(%rsp), %r15
movw $0x0, -0x10(%r15)
movq $0x0, -0x8(%r15)
movl $0x0, (%r15)
movq 0x10(%r14), %rdi
movq (%rbx), %rdx
leaq 0x70(%rsp), %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xde934
testb %al, %al
je 0x80dcb
movl 0x90(%rsp), %eax
movl %eax, 0x20(%rsp)
cmpl $0x40, %eax
ja 0x80d55
movq 0x88(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x80d67
xorl %r8d, %r8d
xorl %r10d, %r10d
testb $0x1, %r10b
je 0x80cbe
shlq $0x4, %rcx
addq %rcx, %rax
cmpq %rax, %r8
je 0x80cbe
movl 0x8(%r8), %ebp
jmp 0x80e8b
leaq 0x170(%rbx), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x80f14
movl %eax, %ebp
leaq 0x10(%rsp), %rsi
leaq 0x18(%rsp), %r12
movq %r15, %rdi
movq %r12, %rdx
callq 0x8259c
movq (%r12), %rcx
testb %al, %al
jne 0x80d4d
movq %rcx, 0x70(%rsp)
movl 0x178(%rbx), %eax
movl 0x180(%rbx), %esi
leal 0x4(,%rax,4), %ecx
leal (%rsi,%rsi,2), %edx
cmpl %edx, %ecx
jae 0x80ef3
notl %eax
addl %esi, %eax
subl 0x17c(%rbx), %eax
movl %esi, %ecx
shrl $0x3, %ecx
cmpl %ecx, %eax
jbe 0x80ef5
incl 0x178(%rbx)
movq 0x70(%rsp), %rcx
cmpq $-0x1000, (%rcx) # imm = 0xF000
je 0x80d43
decl 0x17c(%rbx)
movq %r14, (%rcx)
movl $0xffffffff, 0x8(%rcx) # imm = 0xFFFFFFFF
movl %ebp, 0x8(%rcx)
jmp 0x80e8b
leaq 0x88(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x70bce
movb 0x94(%rsp), %al
movb %al, 0x24(%rsp)
movl 0x20(%rsp), %ebp
cmpl $0x40, %ebp
ja 0x80d83
cmpq $0x0, 0x18(%rsp)
jmp 0x80d8f
leaq 0x18(%rsp), %rdi
callq 0x71b6c
cmpl %ebp, %eax
sete %al
testb %al, %al
je 0x80db7
cmpl $0x41, %ebp
jb 0x80e77
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x80e77
callq 0x3c180
jmp 0x80e77
cmpl $0x41, %ebp
jb 0x80dcb
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x80dcb
callq 0x3c180
leaq 0x28(%rsp), %r12
movw $0x0, -0x10(%r12)
movq $0x0, -0x8(%r12)
movl $0x0, (%r12)
movq 0x18(%r14), %rdi
movq (%rbx), %rdx
leaq 0x18(%rsp), %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xde934
testb %al, %al
je 0x80ec9
movl 0x38(%rsp), %eax
movl %eax, 0x8(%rsp)
cmpl $0x40, %eax
ja 0x80e1f
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
jmp 0x80e2c
leaq 0x30(%rsp), %rsi
movq %rsp, %rdi
callq 0x70bce
movb 0x3c(%rsp), %al
movb %al, 0xc(%rsp)
movl 0x8(%rsp), %ebp
cmpl $0x40, %ebp
ja 0x80e44
cmpq $0x0, (%rsp)
jmp 0x80e4e
movq %rsp, %rdi
callq 0x71b6c
cmpl %ebp, %eax
sete %al
testb %al, %al
je 0x80eb6
cmpl $0x41, %ebp
jb 0x80e68
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x80e68
callq 0x3c180
cmpl $0x2, 0x28(%rsp)
jb 0x80e77
movq %r12, %rdi
callq 0x86f80
cmpl $0x2, 0x80(%rsp)
jb 0x80e89
movq %r15, %rdi
callq 0x86f80
xorl %ebp, %ebp
xorl %r13d, %r13d
testb %r13b, %r13b
je 0x80ea2
movq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x80f14
movl %eax, %ebp
movl %ebp, %eax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x41, %ebp
jb 0x80ec9
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x80ec9
callq 0x3c180
cmpl $0x2, 0x28(%rsp)
jb 0x80ed8
movq %r12, %rdi
callq 0x86f80
cmpl $0x2, 0x80(%rsp)
jb 0x80b71
movq %r15, %rdi
callq 0x86f80
jmp 0x80b71
addl %esi, %esi
movq %r15, %rdi
callq 0x82636
leaq 0x10(%rsp), %rsi
leaq 0x70(%rsp), %rdx
movq %r15, %rdi
callq 0x8259c
jmp 0x80d29
|
/Analysis/CFG.cpp
|
tryNormalizeBinaryOperator(clang::BinaryOperator const*)
|
static std::tuple<const Expr *, BinaryOperatorKind, const Expr *>
tryNormalizeBinaryOperator(const BinaryOperator *B) {
BinaryOperatorKind Op = B->getOpcode();
const Expr *MaybeDecl = B->getLHS();
const Expr *Constant = tryTransformToIntOrEnumConstant(B->getRHS());
// Expr looked like `0 == Foo` instead of `Foo == 0`
if (Constant == nullptr) {
// Flip the operator
if (Op == BO_GT)
Op = BO_LT;
else if (Op == BO_GE)
Op = BO_LE;
else if (Op == BO_LT)
Op = BO_GT;
else if (Op == BO_LE)
Op = BO_GE;
MaybeDecl = B->getRHS();
Constant = tryTransformToIntOrEnumConstant(B->getLHS());
}
return std::make_tuple(MaybeDecl, Op, Constant);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rsi), %r12d
shrl $0x12, %r12d
andl $0x3f, %r12d
movq 0x10(%rsi), %r15
movq 0x18(%rsi), %r14
movq %r14, %rdi
callq 0x820b8
testq %rax, %rax
je 0x81de4
movq %r15, %r14
jmp 0x81e03
leal -0xa(%r12), %eax
cmpl $0x3, %eax
ja 0x81dfb
movl %eax, %eax
leaq 0x2a2f89(%rip), %rcx # 0x324d80
movl (%rcx,%rax,4), %r12d
movq %r15, %rdi
callq 0x820b8
movq %rax, (%rbx)
movl %r12d, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/Analysis/CFG.cpp
|
bool clang::Decl::hasAttr<clang::NoThrowAttr>() const
|
bool hasAttrs() const { return HasAttrs; }
|
testb $0x1, 0x1d(%rdi)
jne 0x829d5
xorl %eax, %eax
retq
pushq %rax
callq 0xc136a
movq (%rax), %rcx
movl 0x8(%rax), %edx
leaq (%rcx,%rdx,8), %rax
testq %rdx, %rdx
je 0x82a03
shlq $0x3, %rdx
movq (%rcx), %rsi
cmpw $0x106, 0x20(%rsi) # imm = 0x106
je 0x82a03
addq $0x8, %rcx
addq $-0x8, %rdx
jne 0x829ee
cmpq %rax, %rcx
setne %al
addq $0x8, %rsp
retq
|
/clang/AST/DeclBase.h
|
(anonymous namespace)::CFGBuilder::appendCall(clang::CFGBlock*, clang::CallExpr*)
|
void appendCall(CFGBlock *B, CallExpr *CE) {
if (alwaysAdd(CE) && cachedEntry)
cachedEntry->second = B;
if (const ConstructionContext *CC =
retrieveAndCleanupConstructionContext(CE)) {
B->appendCXXRecordTypedCall(CE, CC, cfg->getBumpVectorContext());
return;
}
// No valid construction context found. Fall back to statement.
B->appendStmt(CE, cfg->getBumpVectorContext());
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rsi
callq 0x7ec82
testb %al, %al
je 0x82a38
movq 0x160(%r15), %rax
testq %rax, %rax
je 0x82a38
movq %r14, 0x8(%rax)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x8317e
movq 0x8(%r15), %rcx
addq $0x20, %rcx
movq %r14, %rdi
movq %rbx, %rsi
testq %rax, %rax
je 0x82a63
movq %rax, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x83200
movq %rcx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x7ed0a
|
/Analysis/CFG.cpp
|
(anonymous namespace)::CFGBuilder::findConstructionContexts(clang::ConstructionContextLayer const*, clang::Stmt*)
|
void CFGBuilder::findConstructionContexts(
const ConstructionContextLayer *Layer, Stmt *Child) {
if (!BuildOpts.AddRichCXXConstructors)
return;
if (!Child)
return;
auto withExtraLayer = [this, Layer](const ConstructionContextItem &Item) {
return ConstructionContextLayer::create(cfg->getBumpVectorContext(), Item,
Layer);
};
switch(Child->getStmtClass()) {
case Stmt::CXXConstructExprClass:
case Stmt::CXXTemporaryObjectExprClass: {
// Support pre-C++17 copy elision AST.
auto *CE = cast<CXXConstructExpr>(Child);
if (BuildOpts.MarkElidedCXXConstructors && CE->isElidable()) {
findConstructionContexts(withExtraLayer(CE), CE->getArg(0));
}
consumeConstructionContext(Layer, CE);
break;
}
// FIXME: This, like the main visit, doesn't support CUDAKernelCallExpr.
// FIXME: An isa<> would look much better but this whole switch is a
// workaround for an internal compiler error in MSVC 2015 (see r326021).
case Stmt::CallExprClass:
case Stmt::CXXMemberCallExprClass:
case Stmt::CXXOperatorCallExprClass:
case Stmt::UserDefinedLiteralClass:
case Stmt::ObjCMessageExprClass: {
auto *E = cast<Expr>(Child);
if (CFGCXXRecordTypedCall::isCXXRecordTypedCall(E))
consumeConstructionContext(Layer, E);
break;
}
case Stmt::ExprWithCleanupsClass: {
auto *Cleanups = cast<ExprWithCleanups>(Child);
findConstructionContexts(Layer, Cleanups->getSubExpr());
break;
}
case Stmt::CXXFunctionalCastExprClass: {
auto *Cast = cast<CXXFunctionalCastExpr>(Child);
findConstructionContexts(Layer, Cast->getSubExpr());
break;
}
case Stmt::ImplicitCastExprClass: {
auto *Cast = cast<ImplicitCastExpr>(Child);
// Should we support other implicit cast kinds?
switch (Cast->getCastKind()) {
case CK_NoOp:
case CK_ConstructorConversion:
findConstructionContexts(Layer, Cast->getSubExpr());
break;
default:
break;
}
break;
}
case Stmt::CXXBindTemporaryExprClass: {
auto *BTE = cast<CXXBindTemporaryExpr>(Child);
findConstructionContexts(withExtraLayer(BTE), BTE->getSubExpr());
break;
}
case Stmt::MaterializeTemporaryExprClass: {
// Normally we don't want to search in MaterializeTemporaryExpr because
// it indicates the beginning of a temporary object construction context,
// so it shouldn't be found in the middle. However, if it is the beginning
// of an elidable copy or move construction context, we need to include it.
if (Layer->getItem().getKind() ==
ConstructionContextItem::ElidableConstructorKind) {
auto *MTE = cast<MaterializeTemporaryExpr>(Child);
findConstructionContexts(withExtraLayer(MTE), MTE->getSubExpr());
}
break;
}
case Stmt::ConditionalOperatorClass: {
auto *CO = cast<ConditionalOperator>(Child);
if (Layer->getItem().getKind() !=
ConstructionContextItem::MaterializationKind) {
// If the object returned by the conditional operator is not going to be a
// temporary object that needs to be immediately materialized, then
// it must be C++17 with its mandatory copy elision. Do not yet promise
// to support this case.
assert(!CO->getType()->getAsCXXRecordDecl() || CO->isGLValue() ||
Context->getLangOpts().CPlusPlus17);
break;
}
findConstructionContexts(Layer, CO->getLHS());
findConstructionContexts(Layer, CO->getRHS());
break;
}
case Stmt::InitListExprClass: {
auto *ILE = cast<InitListExpr>(Child);
if (ILE->isTransparent()) {
findConstructionContexts(Layer, ILE->getInit(0));
break;
}
// TODO: Handle other cases. For now, fail to find construction contexts.
break;
}
case Stmt::ParenExprClass: {
// If expression is placed into parenthesis we should propagate the parent
// construction context to subexpressions.
auto *PE = cast<ParenExpr>(Child);
findConstructionContexts(Layer, PE->getSubExpr());
break;
}
default:
break;
}
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testq %r14, %r14
je 0x82c8f
movq 0x148(%rbx), %rcx
cmpb $0x0, 0x3c(%rcx)
je 0x82c8f
movzbl (%r14), %eax
cmpl $0x4d, %eax
jle 0x82ae5
cmpl $0x57, %eax
jg 0x82af9
cmpl $0x4e, %eax
je 0x82b39
cmpl $0x55, %eax
je 0x82b50
jmp 0x82c8f
cmpl $0x34, %eax
jle 0x82b27
cmpl $0x35, %eax
je 0x82b59
cmpl $0x3b, %eax
je 0x82b50
jmp 0x82c8f
cmpl $0x7e, %eax
jle 0x82b75
cmpl $0x7f, %eax
jne 0x82c8f
cmpl $0x3, 0x10(%r15)
jne 0x82c8f
movq 0x20(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x82a9c
movq 0x28(%r14), %r14
jmp 0x82aae
cmpl $0x15, %eax
jne 0x82c14
movq 0x18(%r14), %r14
jmp 0x82aae
movl (%r14), %eax
shrl $0x12, %eax
andl $0x7f, %eax
cmpl $0x14, %eax
je 0x82b50
cmpl $0x5, %eax
jne 0x82c8f
movq 0x10(%r14), %r14
jmp 0x82aae
movq %r14, %rdi
callq 0xd8f44
testb %al, %al
je 0x82c8f
movq 0x10(%r14), %rax
movq (%rax), %r14
jmp 0x82aae
leal -0x58(%rax), %edx
cmpl $0x4, %edx
jae 0x82ba4
movq %r14, %rdi
callq 0x82cee
testb %al, %al
je 0x82c8f
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x82c9a
leal -0x70(%rax), %edx
cmpl $0x2, %edx
jae 0x82c5d
cmpb $0x1, 0x3d(%rcx)
jne 0x82c04
testb $0x4, 0x2(%r14)
je 0x82c04
movq %rsp, %rsi
movq %r14, (%rsi)
movq $0x6, 0x8(%rsi)
movq 0x8(%rbx), %rdi
addq $0x20, %rdi
movq %r15, %rdx
callq 0x85a02
movb (%r14), %cl
xorl %edx, %edx
cmpb $0x71, %cl
cmoveq %r14, %rdx
addq $0x30, %rdx
leaq 0x28(%r14), %rsi
cmpb $0x71, %cl
cmoveq %rdx, %rsi
movq (%rsi), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x82a9c
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x82c9a
jmp 0x82c8f
cmpl $0x21, %eax
je 0x82b7d
cmpl $0x30, %eax
jne 0x82c8f
cmpl $0x6, 0x10(%r15)
jne 0x82c8f
movq %rsp, %rsi
movq %r14, (%rsi)
movq $0x3, 0x8(%rsi)
movq 0x8(%rbx), %rdi
addq $0x20, %rdi
movq %r15, %rdx
callq 0x85a02
movq 0x10(%r14), %rcx
movq %rcx, %rdx
andq $-0x8, %rdx
testb $0x4, %cl
je 0x82c84
movq 0x28(%rdx), %rdx
jmp 0x82c84
cmpl $0x73, %eax
jne 0x82c8f
movq %rsp, %rsi
movq %r14, (%rsi)
movq $0x4, 0x8(%rsi)
movq 0x8(%rbx), %rdi
addq $0x20, %rdi
movq %r15, %rdx
callq 0x85a02
movq 0x18(%r14), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x82a9c
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
|
/Analysis/CFG.cpp
|
llvm::DenseMapBase<llvm::DenseMap<clang::Expr*, clang::ConstructionContextLayer const*, llvm::DenseMapInfo<clang::Expr*, void>, llvm::detail::DenseMapPair<clang::Expr*, clang::ConstructionContextLayer const*>>, clang::Expr*, clang::ConstructionContextLayer const*, llvm::DenseMapInfo<clang::Expr*, void>, llvm::detail::DenseMapPair<clang::Expr*, clang::ConstructionContextLayer const*>>::FindAndConstruct(clang::Expr* const&)
|
value_type& FindAndConstruct(const KeyT &Key) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return *TheBucket;
return *InsertIntoBucket(TheBucket, Key);
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x82dfc
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x82df2
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x82e8e
movq (%rbx), %rcx
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/llvm/ADT/DenseMap.h
|
(anonymous namespace)::CFGBuilder::VisitForTemporaryDtors(clang::Stmt*, bool, (anonymous namespace)::CFGBuilder::TempDtorContext&)
|
CFGBlock *CFGBuilder::VisitForTemporaryDtors(Stmt *E, bool ExternallyDestructed,
TempDtorContext &Context) {
assert(BuildOpts.AddImplicitDtors && BuildOpts.AddTemporaryDtors);
tryAgain:
if (!E) {
badCFG = true;
return nullptr;
}
switch (E->getStmtClass()) {
default:
return VisitChildrenForTemporaryDtors(E, false, Context);
case Stmt::InitListExprClass:
return VisitChildrenForTemporaryDtors(E, ExternallyDestructed, Context);
case Stmt::BinaryOperatorClass:
return VisitBinaryOperatorForTemporaryDtors(cast<BinaryOperator>(E),
ExternallyDestructed,
Context);
case Stmt::CXXBindTemporaryExprClass:
return VisitCXXBindTemporaryExprForTemporaryDtors(
cast<CXXBindTemporaryExpr>(E), ExternallyDestructed, Context);
case Stmt::BinaryConditionalOperatorClass:
case Stmt::ConditionalOperatorClass:
return VisitConditionalOperatorForTemporaryDtors(
cast<AbstractConditionalOperator>(E), ExternallyDestructed, Context);
case Stmt::ImplicitCastExprClass:
// For implicit cast we want ExternallyDestructed to be passed further.
E = cast<CastExpr>(E)->getSubExpr();
goto tryAgain;
case Stmt::CXXFunctionalCastExprClass:
// For functional cast we want ExternallyDestructed to be passed further.
E = cast<CXXFunctionalCastExpr>(E)->getSubExpr();
goto tryAgain;
case Stmt::ConstantExprClass:
E = cast<ConstantExpr>(E)->getSubExpr();
goto tryAgain;
case Stmt::ParenExprClass:
E = cast<ParenExpr>(E)->getSubExpr();
goto tryAgain;
case Stmt::MaterializeTemporaryExprClass: {
const MaterializeTemporaryExpr* MTE = cast<MaterializeTemporaryExpr>(E);
ExternallyDestructed = (MTE->getStorageDuration() != SD_FullExpression);
SmallVector<const Expr *, 2> CommaLHSs;
SmallVector<SubobjectAdjustment, 2> Adjustments;
// Find the expression whose lifetime needs to be extended.
E = const_cast<Expr *>(
cast<MaterializeTemporaryExpr>(E)
->getSubExpr()
->skipRValueSubobjectAdjustments(CommaLHSs, Adjustments));
// Visit the skipped comma operator left-hand sides for other temporaries.
for (const Expr *CommaLHS : CommaLHSs) {
VisitForTemporaryDtors(const_cast<Expr *>(CommaLHS),
/*ExternallyDestructed=*/false, Context);
}
goto tryAgain;
}
case Stmt::BlockExprClass:
// Don't recurse into blocks; their subexpressions don't get evaluated
// here.
return Block;
case Stmt::LambdaExprClass: {
// For lambda expressions, only recurse into the capture initializers,
// and not the body.
auto *LE = cast<LambdaExpr>(E);
CFGBlock *B = Block;
for (Expr *Init : LE->capture_inits()) {
if (Init) {
if (CFGBlock *R = VisitForTemporaryDtors(
Init, /*ExternallyDestructed=*/true, Context))
B = R;
}
}
return B;
}
case Stmt::StmtExprClass:
// Don't recurse into statement expressions; any cleanups inside them
// will be wrapped in their own ExprWithCleanups.
return Block;
case Stmt::CXXDefaultArgExprClass:
E = cast<CXXDefaultArgExpr>(E)->getExpr();
goto tryAgain;
case Stmt::CXXDefaultInitExprClass:
E = cast<CXXDefaultInitExpr>(E)->getExpr();
goto tryAgain;
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x8354d
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r14
leaq 0x18(%rsp), %r12
leaq 0x58(%rsp), %r13
movb (%r14), %cl
movzbl %cl, %eax
cmpl $0x54, %eax
jle 0x8341e
leal -0x6e(%rax), %edx
cmpl $0x7, %edx
ja 0x83446
leaq 0x2a1bed(%rip), %rcx # 0x324ff8
movslq (%rcx,%rdx,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, %rdi
callq 0x12ed5a
jmp 0x8345d
cmpl $0x34, %eax
jle 0x83432
cmpl $0x3c, %eax
je 0x8344f
cmpl $0x4e, %eax
je 0x8344f
jmp 0x836a8
cmpl $0x2f, %eax
jg 0x8346a
cmpl $0x15, %eax
jne 0x83708
movq 0x18(%r14), %r14
jmp 0x83460
cmpl $0x55, %eax
jne 0x8355c
movq 0x10(%r14), %r14
jmp 0x83460
movq %r14, %rdi
callq 0x12ed12
movq %rax, %r14
testq %r14, %r14
jne 0x833f1
jmp 0x8354d
cmpl $0x30, %eax
jne 0x836bc
movq 0x10(%r14), %rdi
testb $0x4, %dil
jne 0x83481
xorl %ecx, %ecx
jmp 0x8348f
andq $-0x8, %rdi
callq 0xc827a
testl %eax, %eax
setne %cl
movq %r12, 0x8(%rsp)
movabsq $0x200000000, %rax # imm = 0x200000000
movq %rax, 0x10(%rsp)
movq %r13, 0x48(%rsp)
movq %rax, 0x50(%rsp)
movq 0x10(%r14), %rax
movq %rax, %rdi
andq $-0x8, %rdi
testb $0x4, %al
movl %ecx, 0x30(%rsp)
movq %rbx, %r13
movq %r15, %rbx
je 0x834ca
movq 0x28(%rdi), %rdi
leaq 0x8(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0xd4020
movq %rax, %r14
movl 0x10(%rsp), %r12d
testq %r12, %r12
je 0x8350d
movq 0x8(%rsp), %rbp
shlq $0x3, %r12
xorl %r15d, %r15d
movq (%rbp,%r15), %rsi
movq %r13, %rdi
xorl %edx, %edx
movq %rbx, %rcx
callq 0x833c2
addq $0x8, %r15
cmpq %r15, %r12
jne 0x834f2
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x83521
callq 0x3c3a0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %r12
cmpq %r12, %rdi
movq %rbx, %r15
movq %r13, %rbx
movl 0x30(%rsp), %ebp
je 0x8353f
callq 0x3c3a0
testq %r14, %r14
leaq 0x58(%rsp), %r13
jne 0x833f1
movb $0x1, 0x140(%rbx)
xorl %r12d, %r12d
jmp 0x838e0
addl $-0x7f, %eax
cmpl $0x2, %eax
jae 0x83711
cmpb $0x7f, %cl
jne 0x83571
movq 0x18(%r14), %rsi
cmpb $0x7f, %cl
je 0x8357a
movq 0x20(%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
movq %r15, %rcx
callq 0x833c2
movb (%r14), %al
cmpb $0x7f, %al
jne 0x83592
movq 0x18(%r14), %rsi
cmpb $0x7f, %al
je 0x8359a
movq 0x20(%r14), %rsi
movups 0x10(%rbx), %xmm0
movaps %xmm0, 0x30(%rsp)
movq %rbx, %rdi
callq 0x80b24
movl %eax, %r13d
movl %eax, %r12d
notl %r12d
shrl $0x1f, %r12d
movl 0x4(%r15), %eax
movl %eax, %ecx
xorl $0x1, %ecx
movl %r13d, %edx
xorl $0x1, %edx
xorl %esi, %esi
orl %ecx, %edx
sete %sil
orl %r13d, %eax
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmovnsl %esi, %eax
movb $0x1, 0x48(%rsp)
movl %eax, 0x4c(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rsp)
movb (%r14), %al
cmpb $0x7f, %al
jne 0x835f6
movq 0x20(%r14), %rsi
xorl %r13d, %r12d
cmpb $0x7f, %al
je 0x83601
movq 0x28(%r14), %rsi
movzbl %bpl, %ebp
andl $0x1, %ebp
leaq 0x48(%rsp), %rcx
movq %rbx, %rdi
movl %ebp, %edx
callq 0x833c2
movq 0x10(%rbx), %rax
movq %rax, 0x28(%rsp)
movaps 0x30(%rsp), %xmm0
movups %xmm0, 0x10(%rbx)
movl 0x4(%r15), %eax
movl %eax, %ecx
xorl $0x1, %ecx
xorl $0x1, %r12d
xorl %edx, %edx
orl %ecx, %r12d
sete %dl
orl %eax, %r13d
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmovnsl %edx, %eax
movb $0x1, 0x8(%rsp)
movl %eax, 0xc(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rsp)
movb (%r14), %al
cmpb $0x7f, %al
jne 0x83665
movq 0x28(%r14), %rsi
cmpb $0x7f, %al
je 0x8366d
movq 0x30(%r14), %rsi
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
movl %ebp, %edx
callq 0x833c2
movq 0x58(%rsp), %rax
testq %rax, %rax
je 0x8381b
cmpq $0x0, 0x18(%rsp)
je 0x8381b
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq 0x28(%rsp), %rdx
jmp 0x838d7
cmpl $0x35, %eax
jne 0x83711
movzbl %bpl, %edx
andl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x83719
cmpl $0x33, %eax
jne 0x83711
movq 0x10(%rbx), %r12
movzwl 0x4(%r14), %r13d
testl %r13d, %r13d
je 0x838e0
shll $0x3, %r13d
xorl %ebp, %ebp
movq 0x20(%r14,%rbp), %rsi
testq %rsi, %rsi
je 0x836fa
movq %rbx, %rdi
movl $0x1, %edx
movq %r15, %rcx
callq 0x833c2
testq %rax, %rax
cmovneq %rax, %r12
addq $0x8, %rbp
cmpq %rbp, %r13
jne 0x836d9
jmp 0x838e0
cmpl $0xb, %eax
je 0x838dc
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %r15, %rcx
callq 0x8398a
movq %rax, %r12
jmp 0x838e0
movl (%r14), %eax
movl %eax, %ecx
andl $0xfc0000, %ecx # imm = 0xFC0000
cmpl $0x800000, %ecx # imm = 0x800000
jne 0x83837
movq 0x10(%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
movq %r15, %rcx
callq 0x833c2
movq %rax, %r12
movq 0x18(%r14), %rsi
movzbl %bpl, %edx
andl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rcx
callq 0x833c2
testq %rax, %rax
cmovneq %rax, %r12
jmp 0x838e0
movq 0x18(%r14), %rsi
movq %rbx, %rdi
movl $0x1, %edx
movq %r15, %rcx
callq 0x833c2
movq %rax, %r12
testb $0x1, %bpl
jne 0x838e0
movq %rbx, %r13
movq 0x10(%r14), %rax
movq (%rax), %rdi
addq $0x48, %rdi
callq 0xc1de2
movq 0x10(%rax), %rcx
movq %rcx, %rax
andq $-0x8, %rax
movq %r15, %rbx
testb $0x4, %cl
je 0x837c0
movq (%rax), %rax
leaq -0x40(%rax), %r15
testq %rax, %rax
cmoveq %rax, %r15
movq 0x68(%r15), %rsi
leaq 0x60(%rsi), %rdi
callq 0x79ef0
movq 0x80(%r15), %rax
testb $0x8, 0xa(%rax)
jne 0x83923
cmpb $0x1, (%rbx)
jne 0x83970
cmpq $0x0, 0x10(%rbx)
jne 0x83970
testq %r12, %r12
movq %r13, %r15
je 0x83809
movq %r12, 0x18(%r15)
movq %r15, %rdi
movl $0x1, %esi
callq 0x79d14
jmp 0x83937
testq %rax, %rax
je 0x838cd
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rbx)
leaq 0x48(%rsp), %rsi
jmp 0x838d2
shrl $0x12, %eax
andl $0x3f, %eax
leal -0x13(%rax), %ecx
cmpl $0x1, %ecx
ja 0x838f5
movq 0x10(%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
movq %r15, %rcx
callq 0x833c2
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x80b24
testl %eax, %eax
js 0x8387f
movl $0xfc0000, %ecx # imm = 0xFC0000
andl (%r14), %ecx
xorl %edx, %edx
cmpl $0x500000, %ecx # imm = 0x500000
sete %dl
xorl %edx, %eax
movl 0x4(%r15), %ecx
movl %ecx, %edx
xorl $0x1, %edx
movl %eax, %esi
xorl $0x1, %esi
xorl %edi, %edi
orl %edx, %esi
sete %dil
orl %eax, %ecx
movl $0xffffffff, %eax # imm = 0xFFFFFFFF
cmovnsl %edi, %eax
leaq 0x48(%rsp), %r15
movb $0x1, (%r15)
movl %eax, 0x4(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r15)
movq 0x18(%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
movq %r15, %rcx
callq 0x833c2
movq %rbx, %rdi
movq %r15, %rsi
jmp 0x838d5
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x83a5a
movq 0x10(%rbx), %r12
movq %r12, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addl $-0x15, %eax
cmpl $0xa, %eax
ja 0x836ad
movq 0x18(%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
movq %r15, %rcx
callq 0x833c2
movq %rax, %r12
movq 0x10(%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
jmp 0x83762
testq %r12, %r12
movq %r13, %r15
je 0x8392f
movq %r12, 0x18(%r15)
movq %r15, %rdi
callq 0x7fb70
movq %rax, 0x10(%r15)
cmpb $0x1, (%rbx)
jne 0x83953
cmpq $0x0, 0x10(%rbx)
jne 0x83953
movq 0x18(%r13), %rax
movq %rax, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movq 0x8(%r13), %rdx
movq 0x10(%r13), %rdi
addq $0x20, %rdx
movq %r14, %rsi
callq 0x83b18
movq 0x10(%r13), %r12
jmp 0x838e0
cmpq $0x0, 0x10(%r13)
jne 0x8393b
movq %r13, %rdi
movl $0x1, %esi
callq 0x79d14
movq %rax, 0x10(%r13)
jmp 0x8393b
|
/Analysis/CFG.cpp
|
(anonymous namespace)::CFGBuilder::InsertTempDtorDecisionBlock((anonymous namespace)::CFGBuilder::TempDtorContext const&, clang::CFGBlock*)
|
void CFGBuilder::InsertTempDtorDecisionBlock(const TempDtorContext &Context,
CFGBlock *FalseSucc) {
if (!Context.TerminatorExpr) {
// If no temporary was found, we do not need to insert a decision point.
return;
}
assert(Context.TerminatorExpr);
CFGBlock *Decision = createBlock(false);
Decision->setTerminator(CFGTerminator(Context.TerminatorExpr,
CFGTerminator::TemporaryDtorsBranch));
addSuccessor(Decision, Block, !Context.KnownExecuted.isFalse());
addSuccessor(Decision, FalseSucc ? FalseSucc : Context.Succ,
!Context.KnownExecuted.isTrue());
Block = Decision;
}
|
cmpq $0x0, 0x10(%rsi)
je 0x83b17
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x78c38
movq %rax, %r14
movq 0x10(%r12), %rax
andq $-0x7, %rax
orq $0x2, %rax
movq %rax, 0x20(%r14)
movq 0x10(%rbx), %rsi
xorl %edx, %edx
cmpl $0x0, 0x4(%r12)
setne %dl
movq %rsp, %r13
movq %r13, %rdi
callq 0x7985e
movq 0x8(%rbx), %rcx
addq $0x20, %rcx
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %r14, %rdi
callq 0x798b4
testq %r15, %r15
jne 0x83ad4
movq 0x8(%r12), %r15
xorl %edx, %edx
cmpl $0x1, 0x4(%r12)
setne %dl
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x7985e
movq 0x8(%rbx), %rcx
addq $0x20, %rcx
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r14, %rdi
callq 0x798b4
movq %r14, 0x10(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/Analysis/CFG.cpp
|
llvm::DenseMapBase<llvm::DenseMap<clang::DeclStmt const*, clang::DeclStmt const*, llvm::DenseMapInfo<clang::DeclStmt const*, void>, llvm::detail::DenseMapPair<clang::DeclStmt const*, clang::DeclStmt const*>>, clang::DeclStmt const*, clang::DeclStmt const*, llvm::DenseMapInfo<clang::DeclStmt const*, void>, llvm::detail::DenseMapPair<clang::DeclStmt const*, clang::DeclStmt const*>>::FindAndConstruct(clang::DeclStmt const* const&)
|
value_type& FindAndConstruct(const KeyT &Key) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return *TheBucket;
return *InsertIntoBucket(TheBucket, Key);
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x8442e
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x84424
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x844c0
movq (%rbx), %rcx
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/llvm/ADT/DenseMap.h
|
clang::hash_value(clang::APValue::LValueBase const&)
|
llvm::hash_code hash_value(const APValue::LValueBase &Base) {
if (Base.is<TypeInfoLValue>() || Base.is<DynamicAllocLValue>())
return llvm::hash_value(Base.getOpaqueValue());
return llvm::hash_combine(Base.getOpaqueValue(), Base.getCallIndex(),
Base.getVersion());
}
|
movabsq $-0xae502812aa7333, %rax # imm = 0xFF51AFD7ED558CCD
movq (%rdi), %rsi
testb $0x2, %sil
jne 0x86294
subq $0x98, %rsp
movl 0x8(%rdi), %ecx
leaq 0xc(%rsp), %r8
movl %ecx, (%r8)
movl 0xc(%rdi), %ecx
leaq 0x8(%rsp), %r9
movl %ecx, (%r9)
leaq 0x50(%rsp), %rcx
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rcx)
movaps %xmm0, 0x20(%rcx)
movaps %xmm0, 0x10(%rcx)
movaps %xmm0, (%rcx)
movaps %xmm0, -0x10(%rcx)
movaps %xmm0, -0x20(%rcx)
movaps %xmm0, -0x30(%rcx)
movq $0x0, 0x30(%rcx)
movq %rax, 0x38(%rcx)
leaq 0x18(%rsp), %rdx
movq %rsi, -0x8(%rdx)
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x895ca
addq $0x98, %rsp
retq
movq %rsi, %rcx
shrq $0x20, %rcx
movl %esi, %edx
leaq (%rax,%rdx,8), %rdx
xorq %rcx, %rdx
movabsq $-0x622015f714c7d297, %rsi # imm = 0x9DDFEA08EB382D69
imulq %rsi, %rdx
xorq %rdx, %rcx
shrq $0x2f, %rdx
xorq %rcx, %rdx
imulq %rsi, %rdx
movq %rdx, %rax
shrq $0x2f, %rax
xorq %rdx, %rax
imulq %rsi, %rax
retq
nop
|
/AST/APValue.cpp
|
clang::APValue::printPretty(llvm::raw_ostream&, clang::PrintingPolicy const&, clang::QualType, clang::ASTContext const*) const
|
void APValue::printPretty(raw_ostream &Out, const PrintingPolicy &Policy,
QualType Ty, const ASTContext *Ctx) const {
// There are no objects of type 'void', but values of this type can be
// returned from functions.
if (Ty->isVoidType()) {
Out << "void()";
return;
}
if (const auto *AT = Ty->getAs<AtomicType>())
Ty = AT->getValueType();
switch (getKind()) {
case APValue::None:
Out << "<out of lifetime>";
return;
case APValue::Indeterminate:
Out << "<uninitialized>";
return;
case APValue::Int:
if (Ty->isBooleanType())
Out << (getInt().getBoolValue() ? "true" : "false");
else
Out << getInt();
return;
case APValue::Float:
Out << GetApproxValue(getFloat());
return;
case APValue::FixedPoint:
Out << getFixedPoint();
return;
case APValue::Vector: {
Out << '{';
QualType ElemTy = Ty->castAs<VectorType>()->getElementType();
getVectorElt(0).printPretty(Out, Policy, ElemTy, Ctx);
for (unsigned i = 1; i != getVectorLength(); ++i) {
Out << ", ";
getVectorElt(i).printPretty(Out, Policy, ElemTy, Ctx);
}
Out << '}';
return;
}
case APValue::ComplexInt:
Out << getComplexIntReal() << "+" << getComplexIntImag() << "i";
return;
case APValue::ComplexFloat:
Out << GetApproxValue(getComplexFloatReal()) << "+"
<< GetApproxValue(getComplexFloatImag()) << "i";
return;
case APValue::LValue: {
bool IsReference = Ty->isReferenceType();
QualType InnerTy
= IsReference ? Ty.getNonReferenceType() : Ty->getPointeeType();
if (InnerTy.isNull())
InnerTy = Ty;
LValueBase Base = getLValueBase();
if (!Base) {
if (isNullPointer()) {
Out << (Policy.Nullptr ? "nullptr" : "0");
} else if (IsReference) {
Out << "*(" << InnerTy.stream(Policy) << "*)"
<< getLValueOffset().getQuantity();
} else {
Out << "(" << Ty.stream(Policy) << ")"
<< getLValueOffset().getQuantity();
}
return;
}
if (!hasLValuePath()) {
// No lvalue path: just print the offset.
CharUnits O = getLValueOffset();
CharUnits S = Ctx ? Ctx->getTypeSizeInCharsIfKnown(InnerTy).value_or(
CharUnits::Zero())
: CharUnits::Zero();
if (!O.isZero()) {
if (IsReference)
Out << "*(";
if (S.isZero() || O % S) {
Out << "(char*)";
S = CharUnits::One();
}
Out << '&';
} else if (!IsReference) {
Out << '&';
}
if (const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>())
Out << *VD;
else if (TypeInfoLValue TI = Base.dyn_cast<TypeInfoLValue>()) {
TI.print(Out, Policy);
} else if (DynamicAllocLValue DA = Base.dyn_cast<DynamicAllocLValue>()) {
Out << "{*new "
<< Base.getDynamicAllocType().stream(Policy) << "#"
<< DA.getIndex() << "}";
} else {
assert(Base.get<const Expr *>() != nullptr &&
"Expecting non-null Expr");
Base.get<const Expr*>()->printPretty(Out, nullptr, Policy);
}
if (!O.isZero()) {
Out << " + " << (O / S);
if (IsReference)
Out << ')';
}
return;
}
// We have an lvalue path. Print it out nicely.
if (!IsReference)
Out << '&';
else if (isLValueOnePastTheEnd())
Out << "*(&";
QualType ElemTy = Base.getType();
if (const ValueDecl *VD = Base.dyn_cast<const ValueDecl*>()) {
Out << *VD;
} else if (TypeInfoLValue TI = Base.dyn_cast<TypeInfoLValue>()) {
TI.print(Out, Policy);
} else if (DynamicAllocLValue DA = Base.dyn_cast<DynamicAllocLValue>()) {
Out << "{*new " << Base.getDynamicAllocType().stream(Policy) << "#"
<< DA.getIndex() << "}";
} else {
const Expr *E = Base.get<const Expr*>();
assert(E != nullptr && "Expecting non-null Expr");
E->printPretty(Out, nullptr, Policy);
}
ArrayRef<LValuePathEntry> Path = getLValuePath();
const CXXRecordDecl *CastToBase = nullptr;
for (unsigned I = 0, N = Path.size(); I != N; ++I) {
if (ElemTy->isRecordType()) {
// The lvalue refers to a class type, so the next path entry is a base
// or member.
const Decl *BaseOrMember = Path[I].getAsBaseOrMember().getPointer();
if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(BaseOrMember)) {
CastToBase = RD;
// Leave ElemTy referring to the most-derived class. The actual type
// doesn't matter except for array types.
} else {
const ValueDecl *VD = cast<ValueDecl>(BaseOrMember);
Out << ".";
if (CastToBase)
Out << *CastToBase << "::";
Out << *VD;
ElemTy = VD->getType();
}
} else if (ElemTy->isAnyComplexType()) {
// The lvalue refers to a complex type
Out << (Path[I].getAsArrayIndex() == 0 ? ".real" : ".imag");
ElemTy = ElemTy->castAs<ComplexType>()->getElementType();
} else {
// The lvalue must refer to an array.
Out << '[' << Path[I].getAsArrayIndex() << ']';
ElemTy = ElemTy->castAsArrayTypeUnsafe()->getElementType();
}
}
// Handle formatting of one-past-the-end lvalues.
if (isLValueOnePastTheEnd()) {
// FIXME: If CastToBase is non-0, we should prefix the output with
// "(CastToBase*)".
Out << " + 1";
if (IsReference)
Out << ')';
}
return;
}
case APValue::Array: {
const ArrayType *AT = Ty->castAsArrayTypeUnsafe();
unsigned N = getArrayInitializedElts();
if (N != 0 && TryPrintAsStringLiteral(Out, Policy, AT,
{&getArrayInitializedElt(0), N}))
return;
QualType ElemTy = AT->getElementType();
Out << '{';
unsigned I = 0;
switch (N) {
case 0:
for (; I != N; ++I) {
Out << ", ";
if (I == 10 && !Policy.EntireContentsOfLargeArray) {
Out << "...}";
return;
}
[[fallthrough]];
default:
getArrayInitializedElt(I).printPretty(Out, Policy, ElemTy, Ctx);
}
}
Out << '}';
return;
}
case APValue::Struct: {
Out << '{';
const RecordDecl *RD = Ty->castAs<RecordType>()->getDecl();
bool First = true;
if (unsigned N = getStructNumBases()) {
const CXXRecordDecl *CD = cast<CXXRecordDecl>(RD);
CXXRecordDecl::base_class_const_iterator BI = CD->bases_begin();
for (unsigned I = 0; I != N; ++I, ++BI) {
assert(BI != CD->bases_end());
if (!First)
Out << ", ";
getStructBase(I).printPretty(Out, Policy, BI->getType(), Ctx);
First = false;
}
}
for (const auto *FI : RD->fields()) {
if (!First)
Out << ", ";
if (FI->isUnnamedBitField())
continue;
getStructField(FI->getFieldIndex()).
printPretty(Out, Policy, FI->getType(), Ctx);
First = false;
}
Out << '}';
return;
}
case APValue::Union:
Out << '{';
if (const FieldDecl *FD = getUnionField()) {
Out << "." << *FD << " = ";
getUnionValue().printPretty(Out, Policy, FD->getType(), Ctx);
}
Out << '}';
return;
case APValue::MemberPointer:
// FIXME: This is not enough to unambiguously identify the member in a
// multiple-inheritance scenario.
if (const ValueDecl *VD = getMemberPointerDecl()) {
Out << '&' << *cast<CXXRecordDecl>(VD->getDeclContext()) << "::" << *VD;
return;
}
Out << "0";
return;
case APValue::AddrLabelDiff:
Out << "&&" << getAddrLabelDiffLHS()->getLabel()->getName();
Out << " - ";
Out << "&&" << getAddrLabelDiffRHS()->getLabel()->getName();
return;
}
llvm_unreachable("Unknown APValue kind!");
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %r8, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
movq %rcx, 0x20(%rsp)
andq $-0x10, %rcx
movq (%rcx), %rdi
movq 0x8(%rdi), %rax
andq $-0x10, %rax
movq (%rax), %rax
testq %rax, %rax
je 0x87814
cmpb $0xd, 0x10(%rax)
jne 0x87814
movl $0xff80000, %ecx # imm = 0xFF80000
andl 0x10(%rax), %ecx
cmpl $0xd580000, %ecx # imm = 0xD580000
jne 0x87814
leaq 0x29ddfa(%rip), %rsi # 0x325604
movl $0x6, %edx
jmp 0x87ff1
callq 0x88af4
testq %rax, %rax
je 0x87827
movq 0x20(%rax), %rax
movq %rax, 0x20(%rsp)
movl (%r12), %eax
leaq 0x29dd5a(%rip), %rcx # 0x32558c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x29ddc9(%rip), %rsi # 0x32560b
movl $0x11, %edx
jmp 0x87ff1
movq 0x20(%rbx), %rax
cmpq 0x18(%rbx), %rax
jae 0x87ba8
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%rbx)
movb $0x7b, (%rax)
jmp 0x87bb5
addq $0x8, %r12
leaq 0x78(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x8943c
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x582a2
movq (%r15), %rdi
leaq 0x88(%rsp), %rax
cmpq %rax, %rdi
je 0x88ae1
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x3c080
jmp 0x88ae1
movq 0x8(%r12), %r14
andq $-0x8, %r14
je 0x87fe5
movq %rbx, %r15
movq 0x20(%rbx), %rax
cmpq 0x18(%rbx), %rax
jae 0x87f87
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%r15)
movb $0x26, (%rax)
jmp 0x87f97
movq 0x20(%rsp), %rax
andq $-0x10, %rax
movq (%rax), %rdi
movzbl 0x10(%rdi), %eax
addl $-0x7, %eax
xorl %esi, %esi
cmpl $-0x5, %eax
cmovaeq %rdi, %rsi
jae 0x8790c
callq 0x22549c
movq %rax, %rsi
movq %r12, 0x28(%rsp)
movl 0x10(%r12), %r12d
testq %r12, %r12
je 0x889fb
movq 0x28(%rsp), %rax
movq 0x8(%rax), %r13
movq 0x20(%rsi), %rax
andq $-0x10, %rax
movq %rax, 0x18(%rsp)
movq (%rax), %rdi
movq %rsi, 0x10(%rsp)
callq 0x226f3e
movq 0x10(%rsp), %rsi
testb %al, %al
je 0x889fb
leaq (%r12,%r12,8), %rax
cmpl $0x2, -0x48(%r13,%rax,8)
jne 0x889fb
movq %r14, 0x30(%rsp)
leaq (,%rax,8), %rdi
addq %r13, %rdi
movl -0x38(%rdi), %r14d
addq $-0x40, %rdi
cmpl $0x40, %r14d
ja 0x8812e
cmpq $0x0, (%rdi)
jmp 0x8813b
movq 0x20(%rsp), %rax
andq $-0x10, %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
andq $-0x10, %rax
movq (%rax), %rax
testq %rax, %rax
je 0x87b7f
cmpb $0xd, 0x10(%rax)
jne 0x87b7f
movl $0xff80000, %ecx # imm = 0xFF80000
andl 0x10(%rax), %ecx
cmpl $0xd600000, %ecx # imm = 0xD600000
jne 0x87b7f
movl 0x10(%r12), %ebp
addq $0x8, %r12
cmpl $0x40, %ebp
ja 0x880a6
cmpq $0x0, (%r12)
jmp 0x880b0
addq $0x8, %r12
movq %r12, %rdi
callq 0x88b18
movq %rbx, %rdi
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x58202
movq 0x20(%rsp), %rax
andq $-0x10, %rax
movq (%rax), %rcx
movq 0x8(%rcx), %rcx
andq $-0x10, %rcx
movq (%rcx), %rcx
movb 0x10(%rcx), %cl
addb $-0x29, %cl
movb %cl, 0x18(%rsp)
cmpb $0x1, %cl
ja 0x87c15
leaq 0x20(%rsp), %rdi
callq 0x88b74
jmp 0x87c1d
leaq 0x29dbd4(%rip), %rsi # 0x32561d
movl $0xf, %edx
jmp 0x87ff1
leaq 0x8(%r12), %rdi
movzbl 0x14(%r12), %edx
xorl $0x1, %edx
movq %rbx, %rsi
callq 0x74f9e
leaq 0x2c18bc(%rip), %rsi # 0x34932c
movl $0x1, %edx
movq %rbx, %rdi
callq 0x577a6
movq %rax, %rbx
movzbl 0x24(%r12), %edx
addq $0x18, %r12
xorl $0x1, %edx
movq %r12, %rdi
movq %rax, %rsi
callq 0x74f9e
leaq 0x2d8e7e(%rip), %rsi # 0x36091d
jmp 0x87fec
leaq 0x2a6e02(%rip), %rsi # 0x32e8ad
movl $0x2, %edx
movq %rbx, %rdi
callq 0x577a6
movq 0x8(%r12), %rcx
movq 0x18(%rcx), %rcx
movq 0x28(%rcx), %rcx
testb $0x7, %cl
setne %dl
andq $-0x8, %rcx
sete %sil
orb %dl, %sil
leaq 0x307e07(%rip), %r15 # 0x38f8e4
je 0x87cc1
xorl %edx, %edx
movq %r15, %rsi
jmp 0x87ccb
leaq 0x8(%r12), %rdi
callq 0x88b18
movq %rbx, %rdi
callq 0x58202
leaq 0x2c1826(%rip), %rsi # 0x34932c
movl $0x1, %edx
movq %rax, %rdi
callq 0x577a6
movq %rax, %rbx
addq $0x28, %r12
movq %r12, %rdi
callq 0x88b18
movq %rbx, %rdi
callq 0x58202
leaq 0x2d8dec(%rip), %rsi # 0x36091d
movl $0x1, %edx
movq %rax, %rdi
jmp 0x87ff4
movq 0x20(%rbx), %rax
cmpq 0x18(%rbx), %rax
movq %r14, 0x30(%rsp)
jae 0x87d35
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%rbx)
movb $0x7b, (%rax)
jmp 0x87d42
movq 0x20(%rbx), %rax
cmpq 0x18(%rbx), %rax
jae 0x87e18
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%rbx)
movb $0x7b, (%rax)
jmp 0x87e25
movzbl 0x14(%r12), %edx
addq $0x8, %r12
xorl $0x1, %edx
movq %r12, %rdi
movq %rbx, %rsi
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x74f9e
movq %rbx, %rdi
movl $0x7b, %esi
callq 0x5822c
movq 0x8(%r12), %r13
testq %r13, %r13
je 0x87f4f
leaq 0x29a8f3(%rip), %rsi # 0x3224bd
movl $0x1, %edx
movq %rbx, %rdi
callq 0x577a6
movq %rax, %rbp
movq %r13, %rdi
movq %rax, %rsi
callq 0xbaa18
leaq 0x2fe09a(%rip), %rsi # 0x385c86
movl $0x3, %edx
movq %rbp, %rdi
callq 0x577a6
movq 0x10(%r12), %rdi
movq 0x30(%r13), %rcx
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %r8
callq 0x877b4
jmp 0x87f4f
movq (%rax), %rdi
callq 0x224ac4
movq %rax, 0x48(%rsp)
cmpq $0xf, %rax
ja 0x87c32
movq 0x20(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x8(%r12), %r13
movq 0x10(%r12), %rbp
movq %r13, 0x50(%rsp)
movq %rbp, 0x58(%rsp)
cmpq $0x3, %r13
jbe 0x87c8b
cmpl $-0x1, 0x20(%r12)
je 0x8805b
cmpb $0x2, 0x18(%rsp)
jae 0x88085
movq %r12, %r14
testb $0x2, 0x24(%r12)
je 0x881c8
leaq 0x29d9ca(%rip), %rsi # 0x325643
movl $0x3, %edx
movq %rbx, %rdi
callq 0x577a6
jmp 0x881c8
testb $0x1, 0x24(%r12)
je 0x8800a
btl $0x17, (%r15)
leaq 0x2a6c28(%rip), %rax # 0x32e8cb
leaq 0x2d1392(%rip), %rsi # 0x35903c
cmovaeq %rax, %rsi
movl $0x1, %eax
movl $0x7, %edx
cmovaeq %rax, %rdx
jmp 0x88ad9
movq 0x10(%rcx), %rsi
movl (%rsi), %edx
addq $0x10, %rsi
movq %rax, %rdi
callq 0x577a6
leaq 0x3014a7(%rip), %rsi # 0x389181
movl $0x3, %edx
movq %rbx, %rdi
callq 0x577a6
leaq 0x2a6bbf(%rip), %rsi # 0x32e8ad
movl $0x2, %edx
movq %rbx, %rdi
callq 0x577a6
movq 0x10(%r12), %rcx
movq 0x18(%rcx), %rcx
movq 0x28(%rcx), %rcx
testb $0x7, %cl
setne %dl
andq $-0x8, %rcx
sete %sil
orb %dl, %sil
je 0x87d1f
xorl %edx, %edx
jmp 0x87d2a
movq 0x10(%rcx), %r15
movl (%r15), %edx
addq $0x10, %r15
movq %rax, %rdi
movq %r15, %rsi
jmp 0x87ff4
movq %rbx, %rdi
movl $0x7b, %esi
callq 0x5822c
movq %r15, 0x10(%rsp)
movq 0x20(%rsp), %rax
andq $-0x10, %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
andq $-0x10, %rax
movq (%rax), %rdi
callq 0x226c68
movl 0x10(%r12), %r14d
testq %r14, %r14
je 0x87ebd
movq %r12, 0x28(%rsp)
movq %rax, 0x18(%rsp)
movq %rax, %rdi
callq 0x79f9a
movq %rax, %rbp
shlq $0x3, %r14
leaq (%r14,%r14,8), %r12
addq $0x10, %rbp
movb $0x1, %r15b
xorl %r14d, %r14d
testb $0x1, %r15b
jne 0x87db2
movl $0x2, %edx
movq %rbx, %rdi
leaq 0x29d27e(%rip), %rsi # 0x32502b
callq 0x577a6
movq 0x28(%rsp), %rax
movq 0x8(%rax), %r13
addq %r14, %r13
movq (%rbp), %rax
movq (%rax), %rdi
movq %rdi, %rax
andq $-0x10, %rax
movq (%rax), %rcx
testb $0xf, 0x8(%rcx)
movq 0x10(%rsp), %r15
je 0x87de2
callq 0x225b78
movq %rax, %rcx
andq $-0x10, %rcx
movq %r13, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq 0x30(%rsp), %r8
callq 0x877b4
addq $0x48, %r14
addq $0x18, %rbp
xorl %r15d, %r15d
cmpq %r14, %r12
jne 0x87d98
movq 0x28(%rsp), %r12
movq 0x18(%rsp), %rax
jmp 0x87ec0
movq %rbx, %rdi
movl $0x7b, %esi
callq 0x5822c
movq 0x20(%rsp), %rax
andq $-0x10, %rax
movq (%rax), %rdi
movb 0x10(%rdi), %cl
addb $-0x39, %cl
xorl %eax, %eax
cmpb $-0x2, %cl
cmovaeq %rdi, %rax
jae 0x87e47
callq 0x22549c
movq 0x20(%rax), %r13
movq 0x8(%r12), %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r13, %rcx
movq %r14, %r8
callq 0x877b4
cmpl $0x1, 0x10(%r12)
je 0x87f4f
movq %r15, %rbp
movq %r14, %r15
movl $0x1, %r14d
movl $0x2, %edx
movq %rbx, %rdi
leaq 0x29d1a3(%rip), %rsi # 0x32502b
callq 0x577a6
movl %r14d, %eax
leaq (%rax,%rax,8), %rdi
shlq $0x3, %rdi
addq 0x8(%r12), %rdi
movq %rbx, %rsi
movq %rbp, %rdx
movq %r13, %rcx
movq %r15, %r8
callq 0x877b4
incl %r14d
cmpl 0x10(%r12), %r14d
jne 0x87e79
jmp 0x87f4f
movb $0x1, %r15b
movq %rax, %rdi
callq 0xbeaf4
testq %rax, %rax
movq 0x30(%rsp), %r14
je 0x87f4f
movq %rax, %r13
leaq 0x29d14f(%rip), %rbp # 0x32502b
testb $0x1, %r15b
jne 0x87ef2
movl $0x2, %edx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x577a6
testb $0x1, 0x44(%r13)
je 0x87f00
cmpq $0x0, 0x28(%r13)
je 0x87f31
movq %r13, %rdi
callq 0xbe310
addl 0x10(%r12), %eax
leaq (%rax,%rax,8), %rdi
shlq $0x3, %rdi
addq 0x8(%r12), %rdi
movq 0x30(%r13), %rcx
movq %rbx, %rsi
movq 0x10(%rsp), %rdx
movq %r14, %r8
callq 0x877b4
xorl %r15d, %r15d
movq 0x8(%r13), %r13
andq $-0x8, %r13
je 0x87f4a
movl 0x1c(%r13), %eax
andl $0x7f, %eax
addl $-0x2e, %eax
cmpl $0x3, %eax
jae 0x87f31
testq %r13, %r13
jne 0x87edc
movq 0x20(%rbx), %rax
cmpq 0x18(%rbx), %rax
jae 0x87f69
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%rbx)
movb $0x7d, (%rax)
jmp 0x88ae1
movq %rbx, %rdi
movl $0x7d, %esi
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x5822c
movq %r15, %rdi
movl $0x26, %esi
callq 0x5822c
movq %rax, %r15
movq 0x10(%r14), %rcx
movq %rcx, %rax
andq $-0x8, %rax
testb $0x4, %cl
je 0x87faa
movq (%rax), %rax
leaq -0x40(%rax), %rdi
testq %rax, %rax
cmoveq %rax, %rdi
movq %r15, %rsi
callq 0xbaa18
leaq 0x2bb62f(%rip), %rsi # 0x3435f3
movl $0x2, %edx
movq %r15, %rdi
callq 0x577a6
movq %r14, %rdi
movq %rax, %rsi
callq 0xbaa18
testq %r14, %r14
jne 0x88ae1
leaq 0x2a68df(%rip), %rsi # 0x32e8cb
movl $0x1, %edx
movq %rbx, %rdi
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x577a6
cmpb $0x1, 0x18(%rsp)
ja 0x880d3
leaq 0x29d611(%rip), %rsi # 0x32562d
movl $0x2, %edx
movq %rbx, %rdi
callq 0x577a6
movq %rax, %rbx
leaq 0x78(%rsp), %rcx
movw $0x101, 0x20(%rcx) # imm = 0x101
leaq 0x48(%rsp), %rdi
movq %rax, %rsi
movq %r15, %rdx
xorl %r8d, %r8d
callq 0x22ef24
leaq 0x29d5e4(%rip), %rsi # 0x325635
movl $0x2, %edx
jmp 0x88114
movq %r14, %rdi
movq 0x18(%r12), %r14
testq %rdi, %rdi
je 0x883ee
movq 0x48(%rsp), %rsi
callq 0x88b9a
xorl %r12d, %r12d
testb $0x1, %dl
cmovneq %rax, %r12
jmp 0x883f1
movq 0x20(%rbx), %rax
cmpq 0x18(%rbx), %rax
jae 0x881b8
movq %r12, %r14
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%rbx)
movb $0x26, (%rax)
jmp 0x881c8
movq %r12, %rdi
callq 0x71b6c
cmpl %ebp, %eax
sete %al
leaq 0x29ab59(%rip), %rcx # 0x322c13
leaq 0x3080e9(%rip), %rsi # 0x3901aa
testb %al, %al
cmovneq %rcx, %rsi
movzbl %al, %edx
orq $0x4, %rdx
jmp 0x87ff1
leaq 0x2bba9d(%rip), %rsi # 0x343b77
movl $0x1, %edx
movq %rbx, %rdi
callq 0x577a6
movq %rax, %rbx
leaq 0x78(%rsp), %rcx
movw $0x101, 0x20(%rcx) # imm = 0x101
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
movq %r15, %rdx
xorl %r8d, %r8d
callq 0x22ef24
leaq 0x29d18a(%rip), %rsi # 0x325299
movl $0x1, %edx
movq %rbx, %rdi
callq 0x577a6
movq 0x18(%r12), %rsi
movq %rax, %rdi
callq 0x57d6c
jmp 0x88ae1
callq 0x71b6c
movq 0x10(%rsp), %rsi
cmpl %r14d, %eax
sete %al
testb %al, %al
movq 0x30(%rsp), %r14
je 0x889fb
leaq -0x1(%r12), %r14
leaq 0x90(%rsp), %rax
movq %rax, -0x18(%rax)
movq $0x0, -0x10(%rax)
movq $0x28, -0x8(%rax)
leaq 0x78(%rsp), %rdi
movl $0x22, %esi
callq 0x57aa0
xorl %ecx, %ecx
cmpq $0x25, %r14
jb 0x8856c
xorl %ecx, %ecx
movl $0x0, %edx
movabsq $0x100000000000, %rax # imm = 0x100000000000
testq %rax, (%r15)
jne 0x8856e
movl $0x22, %r14d
leaq 0x29d4af(%rip), %rdx # 0x32565d
movl $0x5, %ecx
jmp 0x8856e
movq %r12, %r14
movq %rbx, %rdi
movl $0x26, %esi
callq 0x5822c
leaq 0x50(%rsp), %rdi
callq 0x85fd8
movq %rax, %r12
movq %r13, %rax
andq $0x3, %rax
setne %cl
movq %r13, %rdi
andq $-0x4, %rdi
sete %dl
orb %cl, %dl
je 0x88216
xorl %ecx, %ecx
cmpl $0x2, %eax
cmoveq %rdi, %rcx
movq %rcx, 0x40(%rsp)
testq %rcx, %rcx
je 0x88515
leaq 0x40(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x85f10
jmp 0x8821e
movq %rbx, %rsi
callq 0xbaa18
movq %r14, %rcx
movl 0x20(%r14), %eax
movq %rax, %r14
addl $-0x5, %eax
cmpl $-0x6, %eax
movq %rcx, 0x28(%rsp)
jae 0x8823b
movq 0x28(%rcx), %rax
jmp 0x8823f
leaq 0x28(%rcx), %rax
movq %rax, 0x10(%rsp)
testq %r14, %r14
je 0x883c6
xorl %r15d, %r15d
xorl %ebp, %ebp
movq %r12, %r13
andq $-0x10, %r13
movq (%r13), %rax
movq 0x8(%rax), %rax
andq $-0x10, %rax
movq (%rax), %rax
movzbl 0x10(%rax), %eax
cmpl $0xe, %eax
je 0x882ef
cmpl $0x2e, %eax
jne 0x88348
movq 0x10(%rsp), %rax
movq (%rax,%r15,8), %r13
andq $-0x8, %r13
movl 0x1c(%r13), %eax
andl $0x7f, %eax
addl $-0x38, %eax
cmpl $0x3, %eax
movl $0x0, %eax
cmovbq %r13, %rax
testq %rax, %rax
jne 0x88337
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x29a208(%rip), %rsi # 0x3224bd
callq 0x577a6
testq %rbp, %rbp
je 0x882de
movq %rbp, %rdi
movq %rbx, %rsi
callq 0xbaa18
movl $0x2, %edx
movq %rbx, %rdi
leaq 0x2bb31a(%rip), %rsi # 0x3435f3
callq 0x577a6
movq %r13, %rdi
movq %rbx, %rsi
callq 0xbaa18
movq 0x30(%r13), %r12
jmp 0x88334
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax,%r15,8)
leaq 0x29d34d(%rip), %rsi # 0x32564d
leaq 0x29d340(%rip), %rax # 0x325647
cmoveq %rax, %rsi
movl $0x5, %edx
movq %rbx, %rdi
callq 0x577a6
movq (%r13), %rdi
cmpb $0xe, 0x10(%rdi)
movl $0x0, %eax
cmoveq %rdi, %rax
je 0x88330
callq 0x22549c
movq 0x20(%rax), %r12
movq %rbp, %rax
incq %r15
movq %rax, %rbp
cmpq %r15, %r14
jne 0x88252
jmp 0x883c6
movq 0x20(%rbx), %rax
cmpq 0x18(%rbx), %rax
jae 0x88362
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%rbx)
movb $0x5b, (%rax)
movq %rbx, %rdi
jmp 0x88372
movq %rbx, %rdi
movl $0x5b, %esi
callq 0x5822c
movq %rax, %rdi
movq 0x10(%rsp), %rax
movq (%rax,%r15,8), %rsi
callq 0x57d5a
movq 0x20(%rax), %rcx
cmpq 0x18(%rax), %rcx
jae 0x88397
leaq 0x1(%rcx), %rdx
movq %rdx, 0x20(%rax)
movb $0x5d, (%rcx)
jmp 0x883a4
movq %rax, %rdi
movl $0x5d, %esi
callq 0x5822c
movq (%r13), %rdi
movzbl 0x10(%rdi), %ecx
addl $-0x7, %ecx
movl $0x0, %eax
cmpl $-0x5, %ecx
cmovaeq %rdi, %rax
jb 0x8832b
jmp 0x88330
movq 0x28(%rsp), %rax
testb $0x2, 0x24(%rax)
je 0x88ae1
leaq 0x29d277(%rip), %rsi # 0x325653
movl $0x4, %edx
movq %rbx, %rdi
callq 0x577a6
jmp 0x884e3
xorl %r12d, %r12d
testq %r14, %r14
je 0x8843f
cmpb $0x1, 0x18(%rsp)
ja 0x88411
leaq 0x29d229(%rip), %rsi # 0x32562d
movl $0x2, %edx
movq %rbx, %rdi
callq 0x577a6
testq %r12, %r12
je 0x88423
movq %r14, %rax
cqto
idivq %r12
testq %rdx, %rdx
je 0x88446
leaq 0x29d206(%rip), %rsi # 0x325630
movl $0x7, %edx
movq %rbx, %rdi
callq 0x577a6
movl $0x1, %r12d
jmp 0x88446
cmpb $0x2, 0x18(%rsp)
jb 0x8846a
movq 0x20(%rbx), %rax
cmpq 0x18(%rbx), %rax
jae 0x8845d
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%rbx)
movb $0x26, (%rax)
jmp 0x8846a
movq %rbx, %rdi
movl $0x26, %esi
callq 0x5822c
movq %r13, %rax
andq $0x3, %rax
setne %cl
movq %r13, %rdi
andq $-0x4, %rdi
sete %dl
orb %cl, %dl
je 0x884ab
xorl %ecx, %ecx
cmpl $0x2, %eax
cmoveq %rdi, %rcx
movq %rcx, 0x40(%rsp)
testq %rcx, %rcx
je 0x88749
leaq 0x40(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x85f10
jmp 0x884b3
movq %rbx, %rsi
callq 0xbaa18
testq %r14, %r14
je 0x88ae1
leaq 0x29d17c(%rip), %rsi # 0x32563f
movl $0x3, %edx
movq %rbx, %rdi
callq 0x577a6
movq %rax, %rdi
movq %r14, %rax
cqto
idivq %r12
movq %rax, %rsi
callq 0x57d6c
cmpb $0x1, 0x18(%rsp)
ja 0x88ae1
movq 0x20(%rbx), %rax
cmpq 0x18(%rbx), %rax
jae 0x88508
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%rbx)
movb $0x29, (%rax)
jmp 0x88ae1
movq %rbx, %rdi
movl $0x29, %esi
jmp 0x88a4d
cmpl $0x3, %eax
setne %al
shrq $0x3, %r13
testl %r13d, %r13d
sete %cl
orb %al, %cl
je 0x88808
leaq 0x2c8a1c(%rip), %rax # 0x350f50
movq %rax, 0xb8(%rsp)
movq $0x1, 0xc0(%rsp)
movups 0xb8(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rsi
xorl %edx, %edx
movq %r15, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2104a0
jmp 0x8821e
xorl %edx, %edx
movq %rdx, 0x60(%rsp)
movq %rcx, 0x68(%rsp)
testq %r14, %r14
sete %r8b
movq 0x10(%rsp), %rsi
je 0x887a0
leaq (%r14,%r14,8), %rax
leaq (,%rax,8), %rax
addq %r13, %rax
movq %rax, 0x38(%rsp)
addq $0x8, %r13
movq 0x30(%rsp), %r14
cmpl $0x2, -0x8(%r13)
jne 0x889cf
leaq -0x8(%r13), %rbp
movl 0x10(%rbp), %eax
cmpb $0x0, 0x14(%rbp)
je 0x885d0
movq %r13, %rcx
cmpl $0x41, %eax
jb 0x885cb
movq (%r13), %rcx
movq (%rcx), %rax
jmp 0x885f7
cmpl $0x40, %eax
ja 0x885f0
movq (%r13), %rdx
movl %eax, %ecx
negb %cl
shlq %cl, %rdx
sarq %cl, %rdx
testl %eax, %eax
movl $0x0, %eax
cmovneq %rdx, %rax
jmp 0x885f7
movq (%r13), %rax
movq (%rax), %rax
cmpq $0x7f, %rax
ja 0x889cf
movb %al, 0x50(%rsp)
movzbl %al, %edi
movb $0x1, %cl
cmpl $0x21, %edi
jg 0x88648
addl $-0x7, %edi
movl $0x0, %esi
movl $0x0, %edx
cmpl $0x6, %edi
ja 0x886f3
leaq 0x29cf98(%rip), %rdx # 0x3255c4
movslq (%rdx,%rdi,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl $0x2, %edx
xorl %ecx, %ecx
leaq 0x29d023(%rip), %rsi # 0x325666
jmp 0x886f3
cmpl $0x22, %edi
je 0x88675
cmpl $0x27, %edi
je 0x886a5
movl $0x0, %esi
movl $0x0, %edx
cmpl $0x5c, %edi
jne 0x886f3
movl $0x2, %edx
xorl %ecx, %ecx
leaq 0x29cc8c(%rip), %rsi # 0x3252ff
jmp 0x886f3
movl $0x2, %edx
xorl %ecx, %ecx
leaq 0x29cc7f(%rip), %rsi # 0x325302
jmp 0x886f3
movl $0x2, %edx
xorl %ecx, %ecx
leaq 0x29cfe5(%rip), %rsi # 0x325678
jmp 0x886f3
movl $0x2, %edx
xorl %ecx, %ecx
leaq 0x29cfd2(%rip), %rsi # 0x325675
jmp 0x886f3
movl $0x2, %edx
xorl %ecx, %ecx
leaq 0x29cfb0(%rip), %rsi # 0x325663
jmp 0x886f3
movl $0x2, %edx
xorl %ecx, %ecx
leaq 0x29cfac(%rip), %rsi # 0x32566f
jmp 0x886f3
movl $0x2, %edx
xorl %ecx, %ecx
leaq 0x29cf96(%rip), %rsi # 0x325669
jmp 0x886f3
movl $0x2, %edx
xorl %ecx, %ecx
leaq 0x29cf89(%rip), %rsi # 0x32566c
jmp 0x886f3
movl $0x2, %edx
xorl %ecx, %ecx
leaq 0x29cf7f(%rip), %rsi # 0x325672
testb %cl, %cl
je 0x8871e
leaq 0x2d94f2(%rip), %rcx # 0x361bf0
movzwl (%rcx,%rax,2), %eax
testl $0x3ec, %eax # imm = 0x3EC
je 0x88974
leaq 0x78(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x894a2
jmp 0x8872b
addq %rsi, %rdx
leaq 0x78(%rsp), %rdi
callq 0x58ba4
addq $0x48, %r13
addq $0x48, %rbp
cmpq 0x38(%rsp), %rbp
sete %r8b
movq 0x10(%rsp), %rsi
jne 0x885a7
jmp 0x887a5
cmpl $0x3, %eax
setne %al
shrq $0x3, %r13
testl %r13d, %r13d
sete %cl
orb %al, %cl
je 0x888c2
leaq 0x2c87e8(%rip), %rax # 0x350f50
movq %rax, 0xc8(%rsp)
movq $0x1, 0xd0(%rsp)
movups 0xc8(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rsi
xorl %edx, %edx
movq %r15, %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x2104a0
jmp 0x884b3
movq 0x30(%rsp), %r14
movb %r8b, 0x38(%rsp)
movq 0x68(%rsp), %rdx
movq 0x60(%rsp), %rsi
addq %rsi, %rdx
leaq 0x78(%rsp), %r13
movq %r13, %rdi
callq 0x58ba4
movq %r13, %rdi
movl $0x22, %esi
callq 0x57aa0
movq 0x18(%rsp), %r13
movq (%r13), %rdi
callq 0x226e8a
testb %al, %al
je 0x88880
movq %rbx, %r13
movq 0x20(%rbx), %rax
cmpq 0x18(%rbx), %rax
jae 0x8893a
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%r13)
movb $0x4c, (%rax)
jmp 0x889b0
leaq 0x29ce29(%rip), %rsi # 0x325638
movl $0x6, %edx
movq %rbx, %rdi
callq 0x577a6
leaq 0x70(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x78(%rsp), %rcx
movw $0x101, 0x20(%rcx) # imm = 0x101
movq %rax, %rsi
movq %rax, %rbp
movq %r15, %rdx
xorl %r8d, %r8d
callq 0x22ef24
leaq 0x2bd98d(%rip), %rsi # 0x3461d4
movl $0x1, %edx
movq %rbp, %rdi
callq 0x577a6
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
addl %ecx, %r13d
movq %rax, %rdi
movq %r13, %rsi
callq 0x57d5a
leaq 0x2b6b4b(%rip), %rsi # 0x33f3b9
movl $0x1, %edx
movq %rax, %rdi
callq 0x577a6
jmp 0x8821e
movq (%r13), %rdi
callq 0x226ec0
testb %al, %al
je 0x88949
movq %rbx, %r13
movq 0x18(%rbx), %rcx
movq 0x20(%rbx), %rax
subq %rax, %rcx
cmpq $0x1, %rcx
ja 0x8897b
leaq 0x326531(%rip), %rsi # 0x3aede1
movl $0x2, %edx
movq %r13, %rdi
callq 0x582a2
jmp 0x889b0
leaq 0x29cd6f(%rip), %rsi # 0x325638
movl $0x6, %edx
movq %rbx, %rdi
callq 0x577a6
leaq 0x70(%rsp), %rdi
movq %rbp, (%rdi)
leaq 0x78(%rsp), %rcx
movw $0x101, 0x20(%rcx) # imm = 0x101
movq %rax, %rsi
movq %rax, %rbp
movq %r15, %rdx
xorl %r8d, %r8d
callq 0x22ef24
leaq 0x2bd8d3(%rip), %rsi # 0x3461d4
movl $0x1, %edx
movq %rbp, %rdi
callq 0x577a6
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
addl %ecx, %r13d
movq %rax, %rdi
movq %r13, %rsi
callq 0x57d5a
leaq 0x2b6a91(%rip), %rsi # 0x33f3b9
movl $0x1, %edx
movq %rax, %rdi
callq 0x577a6
jmp 0x884b3
movq %r13, %rdi
movl $0x4c, %esi
callq 0x5822c
jmp 0x889b0
movq (%r13), %rdi
callq 0x226eea
testb %al, %al
je 0x88987
movq %rbx, %r13
movq 0x20(%rbx), %rax
cmpq 0x18(%rbx), %rax
jae 0x88a33
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%r13)
movb $0x75, (%rax)
jmp 0x889b0
movq 0x10(%rsp), %rsi
jmp 0x889cf
movw $0x3875, (%rax) # imm = 0x3875
addq $0x2, 0x20(%r13)
jmp 0x889b0
movq (%r13), %rdi
callq 0x226f14
testb %al, %al
movq %rbx, %r13
je 0x889b0
movq 0x20(%r13), %rax
cmpq 0x18(%r13), %rax
jae 0x88a40
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%r13)
movb $0x55, (%rax)
movq 0x78(%rsp), %rsi
movq 0x80(%rsp), %rdx
movq %r13, %rdi
callq 0x582a2
movq 0x10(%rsp), %rsi
movb 0x38(%rsp), %r8b
movq 0x78(%rsp), %rdi
leaq 0x90(%rsp), %rax
cmpq %rax, %rdi
je 0x889f1
movl %r8d, %r13d
callq 0x3c3a0
movl %r13d, %r8d
movq 0x10(%rsp), %rsi
testb $0x1, %r8b
jne 0x88ae1
movq 0x20(%rsi), %r13
movq %rbx, %rdi
movq 0x20(%rbx), %rax
cmpq 0x18(%rbx), %rax
jae 0x88a1c
movq %r14, %rbp
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%rdi)
movb $0x7b, (%rax)
jmp 0x88a29
movq %r14, %rbp
movl $0x7b, %esi
callq 0x5822c
xorl %r14d, %r14d
testq %r12, %r12
jne 0x88a8b
jmp 0x88a57
movq %r13, %rdi
movl $0x75, %esi
jmp 0x88942
movq %r13, %rdi
movl $0x55, %esi
jmp 0x88942
callq 0x5822c
jmp 0x88ae1
cmpl %r12d, %r14d
je 0x88ab5
leaq 0x29c5c8(%rip), %rsi # 0x32502b
movl $0x2, %edx
movq %rbx, %rdi
callq 0x577a6
cmpl $0xa, %r14d
jne 0x88a8b
movl $0xa, %r14d
movabsq $0x100000000000, %rax # imm = 0x100000000000
testq %rax, (%r15)
je 0x88acd
movl %r14d, %eax
leaq (%rax,%rax,8), %rdi
shlq $0x3, %rdi
movq 0x28(%rsp), %rax
addq 0x8(%rax), %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r13, %rcx
movq %rbp, %r8
callq 0x877b4
incl %r14d
jmp 0x88a57
movq 0x20(%rbx), %rax
cmpq 0x18(%rbx), %rax
jb 0x87f59
movq %rbx, %rdi
movl $0x7d, %esi
jmp 0x88a4d
leaq 0x29cb84(%rip), %rsi # 0x325658
movl $0x4, %edx
movq %rbx, %rdi
callq 0x577a6
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/AST/APValue.cpp
|
clang::APValue::LV::resizePath(unsigned int)
|
void resizePath(unsigned Length) {
if (Length == PathLength)
return;
if (hasPathPtr())
delete [] PathPtr;
PathLength = Length;
if (hasPathPtr())
PathPtr = new LValuePathEntry[Length];
}
|
movl 0x18(%rdi), %eax
cmpl %esi, %eax
je 0x88e77
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
addl $-0x5, %eax
cmpl $-0x7, %eax
ja 0x88e37
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x88e37
callq 0x3c180
movl %r14d, 0x18(%rbx)
leal -0x5(%r14), %eax
cmpl $-0x7, %eax
ja 0x88e6c
movl %r14d, %r15d
shlq $0x3, %r15
movq %r15, %rdi
callq 0x3c450
movq %rax, %r12
testl %r14d, %r14d
je 0x88e68
movq %r12, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x3c160
movq %r12, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/AST/APValue.cpp
|
clang::APValue::setVectorUninit(unsigned int)
|
MutableArrayRef<APValue> setVectorUninit(unsigned N) {
assert(isVector() && "Invalid accessor");
Vec *V = ((Vec *)(char *)&Data);
V->Elts = new APValue[N];
V->NumElts = N;
return {V->Elts, V->NumElts};
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %ebx
leaq (%rbx,%rbx,8), %r15
leaq 0x8(,%r15,8), %rdi
callq 0x3c450
movq %rax, %rcx
movq %rbx, (%rax)
addq $0x8, %rcx
testl %ebp, %ebp
je 0x89422
leaq -0x48(,%r15,8), %rax
movabsq $-0x1c71c71c71c71c71, %rdx # imm = 0xE38E38E38E38E38F
mulq %rdx
movq %rdx, %xmm0
shrq $0x6, %rdx
addq $0x4, %rdx
andq $-0x4, %rdx
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
psrlq $0x6, %xmm0
leaq 0xd8(%rcx), %rax
xorl %esi, %esi
movdqa 0x29a26c(%rip), %xmm1 # 0x3235b0
movdqa 0x298cb4(%rip), %xmm2 # 0x322000
movdqa 0x298cbc(%rip), %xmm3 # 0x322010
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movq %rsi, %xmm5
pshufd $0x44, %xmm5, %xmm5 # xmm5 = xmm5[0,1,0,1]
movdqa %xmm5, %xmm6
por %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8 # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6 # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %edi
notl %edi
testb $0x1, %dil
je 0x893a9
movl $0x0, -0xd8(%rax)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %edi
testb $0x1, %dil
je 0x893c2
movl $0x0, -0x90(%rax)
por %xmm1, %xmm5
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7 # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5 # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
pxor %xmm4, %xmm5
pextrw $0x0, %xmm5, %edi
testb $0x1, %dil
je 0x893fe
movl $0x0, -0x48(%rax)
pextrw $0x4, %xmm5, %edi
testb $0x1, %dil
je 0x8940f
movl $0x0, (%rax)
addq $0x4, %rsi
addq $0x120, %rax # imm = 0x120
cmpq %rsi, %rdx
jne 0x8935c
movq %rcx, 0x8(%r14)
movl %ebp, 0x10(%r14)
movq %rcx, %rax
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
|
/clang/AST/APValue.h
|
clang::TagType const* clang::Type::getAs<clang::TagType>() const
|
TypeClass getTypeClass() const { return static_cast<TypeClass>(TypeBits.TC); }
|
movb 0x10(%rdi), %cl
addb $-0x2f, %cl
xorl %eax, %eax
cmpb $-0x2, %cl
cmovaeq %rdi, %rax
jae 0x896b5
movq 0x8(%rdi), %rax
andq $-0x10, %rax
movq (%rax), %rax
movb 0x10(%rax), %al
addb $-0x2d, %al
cmpb $0x1, %al
jbe 0x22549c
xorl %eax, %eax
retq
|
/clang/AST/Type.h
|
llvm::SmallVectorTemplateBase<clang::NamedDecl*, true>::push_back(clang::NamedDecl*)
|
void push_back(ValueParamT Elt) {
const T *EltPtr = reserveForParamAndGetAddress(Elt);
memcpy(reinterpret_cast<void *>(this->end()), EltPtr, sizeof(T));
this->set_size(this->size() + 1);
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %edx
cmpl 0xc(%rdi), %edx
jae 0x89f21
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
movq %r14, (%rax,%rcx,8)
incl 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
incq %rdx
leaq 0x10(%rbx), %rsi
movl $0x8, %ecx
movq %rbx, %rdi
callq 0x56f14
jmp 0x89f0c
nop
|
/llvm/ADT/SmallVector.h
|
llvm::SmallVectorTemplateBase<clang::TypeSourceInfo*, true>::push_back(clang::TypeSourceInfo*)
|
void push_back(ValueParamT Elt) {
const T *EltPtr = reserveForParamAndGetAddress(Elt);
memcpy(reinterpret_cast<void *>(this->end()), EltPtr, sizeof(T));
this->set_size(this->size() + 1);
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %edx
cmpl 0xc(%rdi), %edx
jae 0x8a00b
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
movq %r14, (%rax,%rcx,8)
incl 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
incq %rdx
leaq 0x10(%rbx), %rsi
movl $0x8, %ecx
movq %rbx, %rdi
callq 0x56f14
jmp 0x89ff6
nop
|
/llvm/ADT/SmallVector.h
|
clang::ASTContext::getPreferredTypeAlign(clang::Type const*) const
|
unsigned ASTContext::getPreferredTypeAlign(const Type *T) const {
TypeInfo TI = getTypeInfo(T);
unsigned ABIAlign = TI.Align;
T = T->getBaseElementTypeUnsafe();
// The preferred alignment of member pointers is that of a pointer.
if (T->isMemberPointerType())
return getPreferredTypeAlign(getPointerDiffType().getTypePtr());
if (!Target->allowsLargerPreferedTypeAlignment())
return ABIAlign;
if (const auto *RT = T->getAs<RecordType>()) {
const RecordDecl *RD = RT->getDecl();
// When used as part of a typedef, or together with a 'packed' attribute,
// the 'aligned' attribute can be used to decrease alignment. Note that the
// 'packed' case is already taken into consideration when computing the
// alignment, we only need to handle the typedef case here.
if (TI.AlignRequirement == AlignRequirementKind::RequiredByTypedef ||
RD->isInvalidDecl())
return ABIAlign;
unsigned PreferredAlign = static_cast<unsigned>(
toBits(getASTRecordLayout(RD).PreferredAlignment));
assert(PreferredAlign >= ABIAlign &&
"PreferredAlign should be at least as large as ABIAlign.");
return PreferredAlign;
}
// Double (and, for targets supporting AIX `power` alignment, long double) and
// long long should be naturally aligned (despite requiring less alignment) if
// possible.
if (const auto *CT = T->getAs<ComplexType>())
T = CT->getElementType().getTypePtr();
if (const auto *ET = T->getAs<EnumType>())
T = ET->getDecl()->getIntegerType().getTypePtr();
if (T->isSpecificBuiltinType(BuiltinType::Double) ||
T->isSpecificBuiltinType(BuiltinType::LongLong) ||
T->isSpecificBuiltinType(BuiltinType::ULongLong) ||
(T->isSpecificBuiltinType(BuiltinType::LongDouble) &&
Target->defaultsToAIXPowerAlignment()))
// Don't increase the alignment if an alignment attribute was specified on a
// typedef declaration.
if (!TI.isAlignRequired())
return std::max(ABIAlign, (unsigned)getTypeSize(T));
return ABIAlign;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
xorl %r12d, %r12d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8bd06
movq %rdx, %r14
movzbl 0x10(%r15), %ecx
addl $-0x7, %ecx
movq %r15, %rax
cmpl $-0x5, %ecx
cmovbq %r12, %rax
jae 0x8b90e
movq 0x8(%r15), %rax
andq $-0x10, %rax
movq (%rax), %rax
movzbl 0x10(%rax), %eax
addl $-0x2, %eax
cmpl $0x4, %eax
ja 0x8b90c
movq %r15, %rdi
callq 0x22549c
jmp 0x8b90e
xorl %eax, %eax
testq %rax, %rax
je 0x8b91e
movq 0x20(%rax), %rcx
andq $-0x10, %rcx
movq (%rcx), %r15
testq %rax, %rax
jne 0x8b8d7
movq 0x8(%r15), %rax
andq $-0x10, %rax
movq (%rax), %rax
cmpb $0x1f, 0x10(%rax)
movq 0x4348(%rbx), %rdi
jne 0x8b955
movl 0x90(%rdi), %esi
movq %rbx, %rdi
callq 0x8a2ea
andq $-0x10, %rax
movq (%rax), %r15
jmp 0x8b8c9
movq (%rdi), %rax
callq *0x328(%rax)
testb %al, %al
je 0x8bab1
movq 0x8(%r15), %rax
andq $-0x10, %rax
movq (%rax), %rdi
cmpb $0x2e, 0x10(%rdi)
setne %al
testq %rdi, %rdi
sete %bpl
orb %al, %bpl
jne 0x8b9ca
callq 0x226c68
movq %rax, %rsi
movq %r14, %rcx
shrq $0x20, %rcx
movl %r14d, %eax
cmpl $0x1, %ecx
je 0x8b9ca
testb $-0x80, 0x1c(%rsi)
movl %r14d, %eax
jne 0x8b9ca
movq %rbx, %rdi
callq 0x203026
movl 0x18(%rax), %r12d
movq 0x47f8(%rbx), %rax
andq $-0x10, %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x8bd06
imull %r12d, %eax
testb %bpl, %bpl
je 0x8bab4
movq %r15, %rdi
callq 0x8c03c
testq %rax, %rax
je 0x8b9eb
movq 0x20(%rax), %rax
andq $-0x10, %rax
movq (%rax), %r15
movq 0x8(%r15), %rax
andq $-0x10, %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x8ba15
cmpb $0x2d, 0x10(%rdi)
jne 0x8ba15
callq 0x226c68
movq %rax, %rdi
callq 0x8bec0
andq $-0x10, %rax
movq (%rax), %r15
movq 0x8(%r15), %rax
andq $-0x10, %rax
movq (%rax), %rax
cmpb $0xd, 0x10(%rax)
sete %dl
testq %rax, %rax
setne %cl
andb %dl, %cl
cmpb $0x1, %cl
jne 0x8bab1
movl $0xff80000, %edx # imm = 0xFF80000
andl 0x10(%rax), %edx
cmpl $0xed00000, %edx # imm = 0xED00000
jne 0x8ba61
movq %r14, %rax
shrq $0x20, %rax
jne 0x8bab1
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8bd06
cmpl %eax, %r14d
cmoval %r14d, %eax
jmp 0x8bab4
testb %cl, %cl
je 0x8bab1
movl $0xff80000, %edx # imm = 0xFF80000
andl 0x10(%rax), %edx
cmpl $0xdf00000, %edx # imm = 0xDF00000
je 0x8ba44
testb %cl, %cl
je 0x8bab1
movl $0xff80000, %edx # imm = 0xFF80000
andl 0x10(%rax), %edx
cmpl $0xdb00000, %edx # imm = 0xDB00000
je 0x8ba44
testb %cl, %cl
je 0x8bab1
movl $0xff80000, %ecx # imm = 0xFF80000
andl 0x10(%rax), %ecx
cmpl $0xed80000, %ecx # imm = 0xED80000
jne 0x8bab1
movq 0x4348(%rbx), %rdi
movq (%rdi), %rax
callq *0x330(%rax)
testb %al, %al
jne 0x8ba44
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
|
/AST/ASTContext.cpp
|
bool clang::Decl::hasAttr<clang::AlignedAttr>() const
|
bool hasAttrs() const { return HasAttrs; }
|
testb $0x1, 0x1d(%rdi)
jne 0x8bf0f
xorl %eax, %eax
retq
pushq %rax
callq 0xc136a
movq (%rax), %rcx
movl 0x8(%rax), %edx
leaq (%rcx,%rdx,8), %rax
testq %rdx, %rdx
je 0x8bf3c
shlq $0x3, %rdx
movq (%rcx), %rsi
cmpw $0x6c, 0x20(%rsi)
je 0x8bf3c
addq $0x8, %rcx
addq $-0x8, %rdx
jne 0x8bf28
cmpq %rax, %rcx
setne %al
addq $0x8, %rsp
retq
nop
|
/clang/AST/DeclBase.h
|
clang::ASTContext::getPointerAuthVTablePointerDiscriminator(clang::CXXRecordDecl const*)
|
uint16_t
ASTContext::getPointerAuthVTablePointerDiscriminator(const CXXRecordDecl *RD) {
assert(RD->isPolymorphic() &&
"Attempted to get vtable pointer discriminator on a monomorphic type");
std::unique_ptr<MangleContext> MC(createMangleContext());
SmallString<256> Str;
llvm::raw_svector_ostream Out(Str);
MC->mangleCXXVTable(RD, Out);
return llvm::getPointerAuthStableSipHash(Str);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rsi, %r14
xorl %r13d, %r13d
xorl %esi, %esi
callq 0x8c8c4
movq %rax, %rbx
leaq 0x58(%rsp), %r12
movq %r12, -0x18(%r12)
movq %r13, -0x10(%r12)
movq $0x100, -0x8(%r12) # imm = 0x100
leaq 0x8(%rsp), %r15
movl $0x2, 0x8(%r15)
movb $0x0, 0x28(%r15)
movl $0x1, 0x2c(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movq %r13, 0x20(%r15)
leaq 0x42b266(%rip), %rax # 0x4b7ac0
addq $0x10, %rax
movq %rax, (%r15)
leaq 0x40(%rsp), %r13
movq %r13, 0x30(%r15)
movq %r15, %rdi
callq 0x57780
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq *0x68(%rax)
movq (%r13), %rdi
movq 0x8(%r13), %rsi
callq 0x3189b5
movl %eax, %ebp
movq %r15, %rdi
callq 0x58c66
movq (%r13), %rdi
cmpq %r12, %rdi
je 0x8c8a6
callq 0x3c3a0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movl %ebp, %eax
addq $0x158, %rsp # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/AST/ASTContext.cpp
|
clang::ASTContext::getArrayDecayedType(clang::QualType) const
|
QualType ASTContext::getArrayDecayedType(QualType Ty) const {
// Get the element type with 'getAsArrayType' so that we don't lose any
// typedefs in the element type of the array. This also handles propagation
// of type qualifiers from the array type into the element type if present
// (C99 6.7.3p8).
const ArrayType *PrettyArrayType = getAsArrayType(Ty);
assert(PrettyArrayType && "Not an array type!");
QualType PtrTy = getPointerType(PrettyArrayType->getElementType());
// int x[restrict 4] -> int *restrict
QualType Result = getQualifiedType(PtrTy,
PrettyArrayType->getIndexTypeQualifiers());
// int x[_Nullable] -> int * _Nullable
if (auto Nullability = Ty->getNullability()) {
Result = const_cast<ASTContext *>(this)->getAttributedType(
AttributedType::getNullabilityAttrKind(*Nullability), Result, Result);
}
return Result;
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x8b6d6
movq %rax, %r15
movq 0x20(%rax), %rsi
movq %rbx, %rdi
callq 0x8a9e4
movl 0x10(%r15), %edx
shrl $0x13, %edx
andl $0x7, %edx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8a34c
movq %rax, %r15
andq $-0x10, %r14
movq (%r14), %rdi
callq 0x22aa98
btl $0x8, %eax
jb 0x8db8e
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movzwl %ax, %eax
movsbq %al, %rax
leaq 0x297b64(%rip), %rcx # 0x325700
movl (%rcx,%rax,4), %esi
movq %rbx, %rdi
movq %r15, %rdx
movq %r15, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x8d430
|
/AST/ASTContext.cpp
|
clang::ASTContext::getAtomicType(clang::QualType) const
|
QualType ASTContext::getAtomicType(QualType T) const {
// Unique pointers, to guarantee there is only one pointer of a particular
// structure.
llvm::FoldingSetNodeID ID;
AtomicType::Profile(ID, T);
void *InsertPos = nullptr;
if (AtomicType *AT = AtomicTypes.FindNodeOrInsertPos(ID, InsertPos))
return QualType(AT, 0);
// If the atomic value type isn't canonical, this won't be a canonical type
// either, so fill in the canonical type field.
QualType Canonical;
if (!T.isCanonical()) {
Canonical = getAtomicType(getCanonicalType(T));
// Get the new insert position for the node we care about.
AtomicType *NewIP = AtomicTypes.FindNodeOrInsertPos(ID, InsertPos);
assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
}
auto *New = new (*this, alignof(AtomicType)) AtomicType(T, Canonical);
Types.push_back(New);
AtomicTypes.InsertNode(New, InsertPos);
return QualType(New, 0);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movabsq $0x2000000000, %rax # imm = 0x2000000000
movq %rax, -0x8(%r13)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x75350
movq %r14, %rsi
shrq $0x20, %rsi
movq %r12, %rdi
callq 0x75350
movq %rsp, %rdx
movq $0x0, (%rdx)
leaq 0x300(%rbx), %r15
leaq 0x42a0be(%rip), %rcx # 0x4b88f8
movq %r15, %rdi
movq %r12, %rsi
callq 0x3181fc
testq %rax, %rax
je 0x8e856
movq %rax, %r12
addq $-0x18, %r12
jmp 0x8e924
movq %r14, %rbp
andq $-0x10, %rbp
movq (%rbp), %rax
cmpq %rax, 0x8(%rax)
jne 0x8e86c
xorl %r13d, %r13d
jmp 0x8e898
movl %r14d, %esi
andl $0x7, %esi
orq 0x8(%rbp), %rsi
movq %rbx, %rdi
callq 0x8e7d8
movq %rax, %r13
leaq 0x42a070(%rip), %rcx # 0x4b88f8
leaq 0x8(%rsp), %rsi
movq %rsp, %rdx
movq %r15, %rdi
callq 0x3181fc
leaq 0x850(%rbx), %rdi
movl $0x30, %esi
movl $0x4, %edx
callq 0x6515a
movq %rax, %r12
movq (%rbp), %rax
movzwl 0x11(%rax), %eax
andl $0x1f, %eax
cmpq $0x10, %r13
cmovbq %r12, %r13
movq %r12, (%r12)
movq %r13, 0x8(%r12)
movb $0x7, 0x10(%r12)
movzwl 0x11(%r12), %ecx
andl $0xfffff800, %ecx # imm = 0xFFFFF800
orl %eax, %ecx
movw %cx, 0x11(%r12)
leaq 0x18(%r12), %r13
movq $0x0, 0x18(%r12)
movq %r14, 0x20(%r12)
addq $0x8, %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8a2ac
movq (%rsp), %rdx
leaq 0x429fe4(%rip), %rcx # 0x4b88f8
movq %r15, %rdi
movq %r13, %rsi
callq 0x318150
leaq 0x18(%rsp), %r13
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x8e933
callq 0x3c3a0
andq $-0x10, %r12
movq %r12, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/AST/ASTContext.cpp
|
clang::ConstantArrayType::getSize() const
|
llvm::APInt getSize() const {
return ConstantArrayTypeBits.HasExternalSize
? SizePtr->Size
: llvm::APInt(ConstantArrayTypeBits.SizeWidth * 8, Size);
}
|
pushq %rbx
movq %rdi, %rbx
movl 0x10(%rsi), %eax
btl $0x19, %eax
jb 0x8e973
shrl $0x17, %eax
andl $0xf8, %eax
movq 0x28(%rsi), %rdx
movq %rbx, %rdi
movl %eax, %esi
xorl %ecx, %ecx
callq 0x66024
jmp 0x8e992
movq 0x28(%rsi), %rsi
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rbx)
cmpl $0x40, %eax
ja 0x8e98a
movq (%rsi), %rax
movq %rax, (%rbx)
jmp 0x8e992
movq %rbx, %rdi
callq 0x70bce
movq %rbx, %rax
popq %rbx
retq
nop
|
/clang/AST/Type.h
|
clang::ASTContext::getExtVectorType(clang::QualType, unsigned int) const
|
QualType ASTContext::getExtVectorType(QualType vecType,
unsigned NumElts) const {
assert(vecType->isBuiltinType() || vecType->isDependentType() ||
(vecType->isBitIntType() &&
// Only support _BitInt elements with byte-sized power of 2 NumBits.
llvm::isPowerOf2_32(vecType->castAs<BitIntType>()->getNumBits()) &&
vecType->castAs<BitIntType>()->getNumBits() >= 8));
// Check if we've already instantiated a vector of this type.
llvm::FoldingSetNodeID ID;
VectorType::Profile(ID, vecType, NumElts, Type::ExtVector,
VectorKind::Generic);
void *InsertPos = nullptr;
if (VectorType *VTP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos))
return QualType(VTP, 0);
// If the element type isn't canonical, this won't be a canonical type either,
// so fill in the canonical type field.
QualType Canonical;
if (!vecType.isCanonical()) {
Canonical = getExtVectorType(getCanonicalType(vecType), NumElts);
// Get the new insert position for the node we care about.
VectorType *NewIP = VectorTypes.FindNodeOrInsertPos(ID, InsertPos);
assert(!NewIP && "Shouldn't be in the map!"); (void)NewIP;
}
auto *New = new (*this, alignof(ExtVectorType))
ExtVectorType(vecType, NumElts, Canonical);
VectorTypes.InsertNode(New, InsertPos);
Types.push_back(New);
return QualType(New, 0);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %r13
movq %r13, -0x10(%r13)
movabsq $0x2000000000, %rax # imm = 0x2000000000
movq %rax, -0x8(%r13)
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movl $0x38, %ecx
xorl %r8d, %r8d
callq 0x8f03c
leaq 0x10(%rsp), %rdx
movq $0x0, (%rdx)
leaq 0x120(%rbx), %r15
leaq 0x4296eb(%rip), %rcx # 0x4b87d8
movq %r15, %rdi
movq %r12, %rsi
callq 0x3181fc
testq %rax, %rax
je 0x8f109
movq %rax, %r12
addq $-0x18, %r12
jmp 0x8f1b1
movq %r14, %rax
andq $-0x10, %rax
movq (%rax), %rcx
cmpq %rcx, 0x8(%rcx)
jne 0x8f124
movq $0x0, 0x8(%rsp)
jmp 0x8f156
movl %r14d, %esi
andl $0x7, %esi
orq 0x8(%rax), %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x8f08e
movq %rax, 0x8(%rsp)
leaq 0x429694(%rip), %rcx # 0x4b87d8
leaq 0x18(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x3181fc
leaq 0x850(%rbx), %rdi
movl $0x30, %esi
movl $0x4, %edx
callq 0x6515a
movq %rax, %r12
movq %rax, %rdi
movl $0x38, %esi
movq %r14, %rdx
movl %ebp, %ecx
movq 0x8(%rsp), %r8
xorl %r9d, %r9d
callq 0x2253e4
movq 0x10(%rsp), %rdx
leaq 0x18(%r12), %rsi
leaq 0x42963e(%rip), %rcx # 0x4b87d8
movq %r15, %rdi
callq 0x318150
addq $0x8, %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x8a2ac
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0x8f1c0
callq 0x3c3a0
andq $-0x10, %r12
movq %r12, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/AST/ASTContext.cpp
|
clang::ASTContext::getConstantMatrixType(clang::QualType, unsigned int, unsigned int) const
|
QualType ASTContext::getConstantMatrixType(QualType ElementTy, unsigned NumRows,
unsigned NumColumns) const {
llvm::FoldingSetNodeID ID;
ConstantMatrixType::Profile(ID, ElementTy, NumRows, NumColumns,
Type::ConstantMatrix);
assert(MatrixType::isValidElementType(ElementTy) &&
"need a valid element type");
assert(ConstantMatrixType::isDimensionValid(NumRows) &&
ConstantMatrixType::isDimensionValid(NumColumns) &&
"need valid matrix dimensions");
void *InsertPos = nullptr;
if (ConstantMatrixType *MTP = MatrixTypes.FindNodeOrInsertPos(ID, InsertPos))
return QualType(MTP, 0);
QualType Canonical;
if (!ElementTy.isCanonical()) {
Canonical =
getConstantMatrixType(getCanonicalType(ElementTy), NumRows, NumColumns);
ConstantMatrixType *NewIP = MatrixTypes.FindNodeOrInsertPos(ID, InsertPos);
assert(!NewIP && "Matrix type shouldn't already exist in the map");
(void)NewIP;
}
auto *New = new (*this, alignof(ConstantMatrixType))
ConstantMatrixType(ElementTy, NumRows, NumColumns, Canonical);
MatrixTypes.InsertNode(New, InsertPos);
Types.push_back(New);
return QualType(New, 0);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movabsq $0x2000000000, %rax # imm = 0x2000000000
movq %rax, -0x8(%rcx)
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movl %ebp, %ecx
movl $0x1d, %r8d
callq 0x8f32a
leaq 0x10(%rsp), %rdx
movq $0x0, (%rdx)
leaq 0x148(%rbx), %r12
leaq 0x4295b4(%rip), %rcx # 0x4b87f0
movq %r12, %rdi
movq %r13, %rsi
callq 0x3181fc
testq %rax, %rax
je 0x8f258
movq %rax, %r13
addq $-0x18, %r13
jmp 0x8f2fd
movq %r15, %rax
andq $-0x10, %rax
movq (%rax), %rcx
cmpq %rcx, 0x8(%rcx)
jne 0x8f273
movq $0x0, 0x8(%rsp)
jmp 0x8f2a8
movl %r15d, %esi
andl $0x7, %esi
orq 0x8(%rax), %rsi
movq %rbx, %rdi
movl %r14d, %edx
movl %ebp, %ecx
callq 0x8f1da
movq %rax, 0x8(%rsp)
leaq 0x42955a(%rip), %rcx # 0x4b87f0
leaq 0x18(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r12, %rdi
callq 0x3181fc
leaq 0x850(%rbx), %rdi
movl $0x30, %esi
movl $0x4, %edx
callq 0x6515a
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movq 0x8(%rsp), %r8
callq 0x22533e
movq 0x10(%rsp), %rdx
leaq 0x18(%r13), %rsi
leaq 0x42950a(%rip), %rcx # 0x4b87f0
movq %r12, %rdi
callq 0x318150
addq $0x8, %rbx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x8a2ac
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x8f311
callq 0x3c3a0
andq $-0x10, %r13
movq %r13, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/AST/ASTContext.cpp
|
clang::ASTContext::getCanonicalFunctionResultType(clang::QualType) const
|
const ExtQualsTypeCommonBase *getCommonPtr() const {
assert(!isNull() && "Cannot retrieve a NULL type pointer");
auto CommonPtrVal = reinterpret_cast<uintptr_t>(Value.getOpaqueValue());
CommonPtrVal &= ~(uintptr_t)((1 << TypeAlignmentInBits) - 1);
return reinterpret_cast<ExtQualsTypeCommonBase*>(CommonPtrVal);
}
|
movq %rsi, %rax
andq $-0x10, %rax
movq 0x8(%rax), %rax
andl $0x7, %esi
movb $0x1, %cl
testb $0x8, %al
je 0x8f41c
movq %rax, %rcx
andq $-0x10, %rcx
movzwl 0x18(%rcx), %ecx
testl $0x1c0, %ecx # imm = 0x1C0
sete %cl
orq %rax, %rsi
testb %cl, %cl
je 0x8f427
movq %rsi, %rax
retq
andl $0x7, %esi
testb $0x8, %al
jne 0x8f432
xorl %edx, %edx
jmp 0x8f444
movq %rax, %rcx
andq $-0x10, %rcx
movq $-0x1c1, %rdx # imm = 0xFE3F
andq 0x18(%rcx), %rdx
orq %rsi, %rdx
andq $-0x10, %rax
movq (%rax), %rsi
andq $-0x10, %rsi
jmp 0x8a34c
nop
|
/clang/AST/Type.h
|
clang::ObjCObjectType const* clang::Type::getAs<clang::ObjCObjectType>() const
|
TypeClass getTypeClass() const { return static_cast<TypeClass>(TypeBits.TC); }
|
movb 0x10(%rdi), %cl
addb $-0x23, %cl
xorl %eax, %eax
cmpb $-0x2, %cl
cmovaeq %rdi, %rax
jae 0x90efd
movq 0x8(%rdi), %rax
andq $-0x10, %rax
movq (%rax), %rax
movb 0x10(%rax), %al
addb $-0x21, %al
cmpb $0x1, %al
jbe 0x22549c
xorl %eax, %eax
retq
|
/clang/AST/Type.h
|
void llvm::SmallVectorImpl<clang::ObjCProtocolDecl*>::append<clang::ObjCProtocolDecl* const*, void>(clang::ObjCProtocolDecl* const*, clang::ObjCProtocolDecl* const*)
|
void append(ItTy in_start, ItTy in_end) {
this->assertSafeToAddRange(in_start, in_end);
size_type NumInputs = std::distance(in_start, in_end);
this->reserve(this->size() + NumInputs);
this->uninitialized_copy(in_start, in_end, this->end());
this->set_size(this->size() + NumInputs);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %r15
subq %rsi, %r15
movq %r15, %r13
sarq $0x3, %r13
movl 0x8(%rdi), %edx
movl 0xc(%rdi), %eax
addq %r13, %rdx
cmpq %rax, %rdx
jbe 0x90f3c
leaq 0x10(%rbx), %rsi
movl $0x8, %ecx
movq %rbx, %rdi
callq 0x56f14
cmpq %r12, %r14
je 0x90f56
movl 0x8(%rbx), %edi
shlq $0x3, %rdi
addq (%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3c370
addl %r13d, 0x8(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/llvm/ADT/SmallVector.h
|
clang::ObjCObjectPointerType const* clang::Type::getAs<clang::ObjCObjectPointerType>() const
|
const T *Type::getAs() const {
static_assert(!TypeIsArrayType<T>::value,
"ArrayType cannot be used with getAs!");
// If this is directly a T type, return it.
if (const auto *Ty = dyn_cast<T>(this))
return Ty;
// If the canonical form of this type isn't the right kind, reject it.
if (!isa<T>(CanonicalType))
return nullptr;
// If this is a typedef for the type, strip the typedef off without
// losing all typedef information.
return cast<T>(getUnqualifiedDesugaredType());
}
|
xorl %eax, %eax
cmpb $0x20, 0x10(%rdi)
cmoveq %rdi, %rax
je 0x9111f
movq 0x8(%rdi), %rax
andq $-0x10, %rax
movq (%rax), %rax
cmpb $0x20, 0x10(%rax)
je 0x22549c
xorl %eax, %eax
retq
|
/clang/AST/Type.h
|
clang::AutoType const* clang::Type::getAs<clang::AutoType>() const
|
const T *Type::getAs() const {
static_assert(!TypeIsArrayType<T>::value,
"ArrayType cannot be used with getAs!");
// If this is directly a T type, return it.
if (const auto *Ty = dyn_cast<T>(this))
return Ty;
// If the canonical form of this type isn't the right kind, reject it.
if (!isa<T>(CanonicalType))
return nullptr;
// If this is a typedef for the type, strip the typedef off without
// losing all typedef information.
return cast<T>(getUnqualifiedDesugaredType());
}
|
xorl %eax, %eax
cmpb $0x10, 0x10(%rdi)
cmoveq %rdi, %rax
je 0x91507
movq 0x8(%rdi), %rax
andq $-0x10, %rax
movq (%rax), %rax
cmpb $0x10, 0x10(%rax)
je 0x22549c
xorl %eax, %eax
retq
|
/clang/AST/Type.h
|
clang::ASTContext::UnwrapSimilarTypes(clang::QualType&, clang::QualType&, bool)
|
bool ASTContext::UnwrapSimilarTypes(QualType &T1, QualType &T2,
bool AllowPiMismatch) {
UnwrapSimilarArrayTypes(T1, T2, AllowPiMismatch);
const auto *T1PtrType = T1->getAs<PointerType>();
const auto *T2PtrType = T2->getAs<PointerType>();
if (T1PtrType && T2PtrType) {
T1 = T1PtrType->getPointeeType();
T2 = T2PtrType->getPointeeType();
return true;
}
const auto *T1MPType = T1->getAs<MemberPointerType>();
const auto *T2MPType = T2->getAs<MemberPointerType>();
if (T1MPType && T2MPType &&
hasSameUnqualifiedType(QualType(T1MPType->getClass(), 0),
QualType(T2MPType->getClass(), 0))) {
T1 = T1MPType->getPointeeType();
T2 = T2MPType->getPointeeType();
return true;
}
if (getLangOpts().ObjC) {
const auto *T1OPType = T1->getAs<ObjCObjectPointerType>();
const auto *T2OPType = T2->getAs<ObjCObjectPointerType>();
if (T1OPType && T2OPType) {
T1 = T1OPType->getPointeeType();
T2 = T2OPType->getPointeeType();
return true;
}
}
// FIXME: Block pointers, too?
return false;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
callq 0x9152c
movq (%r14), %rax
andq $-0x10, %rax
movq (%rax), %rdi
callq 0x77ce4
movq %rax, %r15
movq (%rbx), %rax
andq $-0x10, %rax
movq (%rax), %rdi
callq 0x77ce4
testq %r15, %r15
je 0x9172b
testq %rax, %rax
je 0x9172b
movq 0x20(%r15), %rcx
movq %rcx, (%r14)
movq 0x20(%rax), %rax
movq %rax, (%rbx)
movb $0x1, %cl
jmp 0x9178e
movq (%r14), %rax
andq $-0x10, %rax
movq (%rax), %rdi
callq 0x8c2c0
movq %rax, %r15
movq (%rbx), %rax
andq $-0x10, %rax
movq (%rax), %rdi
callq 0x8c2c0
testq %r15, %r15
je 0x9177e
testq %rax, %rax
je 0x9177e
movq 0x28(%r15), %rcx
andq $-0x10, %rcx
movq 0x28(%rax), %rdx
andq $-0x10, %rdx
movq 0x8(%rcx), %rcx
andq $-0x10, %rcx
movq (%rcx), %rcx
movq 0x8(%rdx), %rdx
andq $-0x10, %rdx
cmpq (%rdx), %rcx
je 0x91719
movq 0x830(%r12), %rax
testb $0x2, 0x2(%rax)
jne 0x9179c
xorl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq (%r14), %rax
andq $-0x10, %rax
movq (%rax), %rdi
callq 0x910fc
movq %rax, %r15
movq (%rbx), %rax
andq $-0x10, %rax
movq (%rax), %rdi
callq 0x910fc
xorl %ecx, %ecx
testq %r15, %r15
je 0x9178e
testq %rax, %rax
jne 0x91719
jmp 0x9178e
nop
|
/AST/ASTContext.cpp
|
clang::NonTypeTemplateParmDecl::getDefaultArgument() const
|
const TemplateArgumentLoc &getDefaultArgument() const {
static const TemplateArgumentLoc NoneLoc;
return DefaultArgument.isSet() ? *DefaultArgument.get() : NoneLoc;
}
|
pushq %rbx
movq %rdi, %rbx
leaq 0x485287(%rip), %rax # 0x516c90
movb (%rax), %al
testb %al, %al
je 0x91a62
movq 0x48(%rbx), %rax
cmpq $0x8, %rax
jb 0x91a59
addq $0x48, %rbx
movl %eax, %ecx
andl $0x6, %ecx
andq $-0x8, %rax
xorl %edx, %edx
cmpl $0x2, %ecx
cmoveq %rax, %rdx
leaq 0x48(%rdx), %rax
testq %rdx, %rdx
cmoveq %rbx, %rax
movq (%rax), %rax
movl %eax, %ecx
andl $0x6, %ecx
cmpl $0x4, %ecx
setne %cl
andq $-0x8, %rax
sete %dl
orb %cl, %dl
jne 0x91a60
movq 0x8(%rax), %rax
jmp 0x91a60
leaq 0x485210(%rip), %rax # 0x516c70
popq %rbx
retq
callq 0x3c9ba
jmp 0x91a0f
nop
|
/clang/AST/DeclTemplate.h
|
clang::ObjCObjectPointerType::isObjCIdType() const
|
bool isObjCIdType() const {
return getObjectType()->isObjCUnqualifiedId();
}
|
pushq %rax
movq 0x20(%rdi), %rax
andq $-0x10, %rax
movq (%rax), %rdi
movb 0x10(%rdi), %cl
addb $-0x23, %cl
xorl %eax, %eax
cmpb $-0x2, %cl
cmovaeq %rdi, %rax
jae 0x93742
callq 0x22549c
cmpl $0x3ffffff, 0x10(%rax) # imm = 0x3FFFFFF
ja 0x93780
movq 0x18(%rax), %rax
andq $-0x10, %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
andq $-0x10, %rax
movq (%rax), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x93782
cmpb $0xd, 0x10(%rcx)
jne 0x93782
movl $0xff80000, %eax # imm = 0xFF80000
andl 0x10(%rcx), %eax
cmpl $0xf080000, %eax # imm = 0xF080000
sete %al
jmp 0x93782
xorl %eax, %eax
popq %rcx
retq
|
/clang/AST/Type.h
|
clang::ASTContext::getBuiltinVaListDecl() const
|
TypedefDecl *ASTContext::getBuiltinVaListDecl() const {
if (!BuiltinVaListDecl) {
BuiltinVaListDecl = CreateVaListDecl(this, Target->getBuiltinVaListKind());
assert(BuiltinVaListDecl->isImplicit());
}
return BuiltinVaListDecl;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x540(%rdi)
jne 0x94369
movq 0x4348(%rbx), %rdi
movq (%rdi), %rax
callq *0x120(%rax)
movl %eax, %eax
leaq 0x2929f7(%rip), %rcx # 0x32646c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x47f8(%rbx), %rsi
jmp 0x93f12
leaq 0x293058(%rip), %rsi # 0x326ae9
xorl %ebp, %ebp
movl $0xd, %edx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x8a174
movq %rax, %r15
movq %rax, %rdi
callq 0xbe5cc
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movq $0x0, 0x50(%rsp)
leaq 0x298e51(%rip), %rax # 0x32c91b
movq %rax, 0x60(%rsp)
leaq 0x293042(%rip), %rax # 0x326b18
movq %rax, 0x68(%rsp)
movups 0x4860(%rbx), %xmm0
movlps %xmm0, 0x30(%rsp)
movups %xmm0, 0x38(%rsp)
leaq 0x3644fe(%rip), %rax # 0x3f7ff1
movq %rax, 0x70(%rsp)
movq 0x47e8(%rbx), %rsi
movq %rbx, %rdi
callq 0x8a9e4
movq %rax, 0x48(%rsp)
leaq 0x29300b(%rip), %rax # 0x326b1e
movq %rax, 0x78(%rsp)
movq 0x47e8(%rbx), %rsi
movq %rbx, %rdi
callq 0x8a9e4
movq %rax, 0x50(%rsp)
leaq 0x292fff(%rip), %rax # 0x326b32
movq %rax, 0x80(%rsp)
movq %r15, 0x28(%rsp)
addq $0x40, %r15
xorl %r14d, %r14d
movq 0x4380(%rbx), %r12
movq 0x60(%rsp,%r14,8), %r13
testq %r13, %r13
je 0x93b65
movq %r13, %rdi
callq 0x3c190
movq %rax, %rdx
jmp 0x93b67
xorl %edx, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x78292
movq 0x30(%rsp,%r14,8), %r9
movl %ebp, 0x18(%rsp)
movl %ebp, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %rax, %r8
callq 0xbdf62
andb $-0x61, 0x1d(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0xc271a
incq %r14
cmpq $0x5, %r14
jne 0x93b47
jmp 0x94295
leaq 0x292ef5(%rip), %rsi # 0x326ab1
xorl %ebp, %ebp
movl $0x9, %edx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x8a174
movq %rax, %r14
movq 0x830(%rbx), %rax
testb $0x4, 0x1(%rax)
je 0x93c49
movq 0x808(%rbx), %rax
movq 0x50(%rax), %rsi
leaq 0x48(%rsi), %rdi
callq 0x956b8
leaq 0x28(%rax), %r15
testq %rax, %rax
cmoveq %rax, %r15
movq 0x4380(%rbx), %rdi
leaq 0x32d42e(%rip), %rsi # 0x3c1038
movl $0x3, %edx
callq 0x78292
movl $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %rax, %r9
callq 0xc81d8
orb $0x2, 0x1d(%rax)
leaq 0x30(%rax), %rsi
movq %r14, %rdi
callq 0xc1110
movq %r14, %rdi
callq 0xbe5cc
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movq $0x0, 0x50(%rsp)
movq 0x47e8(%rbx), %rsi
movq %rbx, %rdi
callq 0x8a9e4
movq %rax, 0x30(%rsp)
leaq 0x292e39(%rip), %rax # 0x326abb
movq %rax, 0x60(%rsp)
movq 0x47e8(%rbx), %rsi
movq %rbx, %rdi
callq 0x8a9e4
movq %rax, 0x38(%rsp)
leaq 0x292e21(%rip), %rax # 0x326ac3
movq %rax, 0x68(%rsp)
movq 0x47e8(%rbx), %rsi
movq %rbx, %rdi
callq 0x8a9e4
movq %rax, 0x40(%rsp)
leaq 0x292e0a(%rip), %rax # 0x326acc
movq %rax, 0x70(%rsp)
movq 0x4840(%rbx), %rax
movq %rax, 0x48(%rsp)
leaq 0x292dfb(%rip), %rcx # 0x326ad5
movq %rcx, 0x78(%rsp)
movq %rax, 0x50(%rsp)
leaq 0x292df4(%rip), %rax # 0x326adf
movq %rax, 0x80(%rsp)
movq %r14, 0x28(%rsp)
movq %r14, %r15
addq $0x40, %r15
xorl %r14d, %r14d
movq 0x4380(%rbx), %r12
movq 0x60(%rsp,%r14,8), %r13
testq %r13, %r13
je 0x93d20
movq %r13, %rdi
callq 0x3c190
movq %rax, %rdx
jmp 0x93d22
xorl %edx, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x78292
movq 0x30(%rsp,%r14,8), %r9
movl %ebp, 0x18(%rsp)
movl %ebp, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %rax, %r8
callq 0xbdf62
andb $-0x61, 0x1d(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0xc271a
incq %r14
cmpq $0x5, %r14
jne 0x93d02
movq 0x28(%rsp), %r14
jmp 0x94152
movq 0x4348(%rbx), %rax
movl 0x88(%rax), %esi
movq %rbx, %rdi
callq 0x8a2ea
andq $-0x10, %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x8bd06
leaq 0x30(%rsp), %r15
movl $0x4, %edx
movq %r15, %rdi
movl %eax, %esi
xorl %ecx, %ecx
callq 0x66024
movq 0x4840(%rbx), %rsi
movq %rbx, %rdi
movq %r15, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x8e376
leaq 0x292ccf(%rip), %rdx # 0x326a9f
movl $0x11, %ecx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8a23c
movq %rax, %r14
cmpl $0x41, 0x8(%r15)
jb 0x94362
movq 0x30(%rsp), %rdi
jmp 0x94358
leaq 0x292cea(%rip), %rsi # 0x326ae9
xorl %ebp, %ebp
movl $0xd, %edx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x8a174
movq %rax, %r15
movq %rax, %rdi
callq 0xbe5cc
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movq 0x4848(%rbx), %rax
movq %rax, 0x30(%rsp)
leaq 0x292cd5(%rip), %rcx # 0x326b10
movq %rcx, 0x60(%rsp)
movq %rax, 0x38(%rsp)
leaq 0x292cca(%rip), %rax # 0x326b16
movq %rax, 0x68(%rsp)
movq 0x47e8(%rbx), %rsi
movq %rbx, %rdi
callq 0x8a9e4
movq %rax, 0x40(%rsp)
leaq 0x292cb0(%rip), %rax # 0x326b1c
movq %rax, 0x70(%rsp)
movq 0x47e8(%rbx), %rsi
movq %rbx, %rdi
callq 0x8a9e4
movq %rax, 0x48(%rsp)
leaq 0x292ca4(%rip), %rax # 0x326b30
movq %rax, 0x78(%rsp)
movq %r15, 0x28(%rsp)
addq $0x40, %r15
xorl %r14d, %r14d
movq 0x4380(%rbx), %r12
movq 0x60(%rsp,%r14,8), %r13
testq %r13, %r13
je 0x93ebb
movq %r13, %rdi
callq 0x3c190
movq %rax, %rdx
jmp 0x93ebd
xorl %edx, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x78292
movq 0x30(%rsp,%r14,8), %r9
movl %ebp, 0x18(%rsp)
movl %ebp, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %rax, %r8
callq 0xbdf62
andb $-0x61, 0x1d(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0xc271a
incq %r14
cmpq $0x4, %r14
jne 0x93e9d
jmp 0x9402d
movq 0x47e8(%rbx), %rsi
movq %rbx, %rdi
callq 0x8a9e4
jmp 0x9416d
leaq 0x292bc3(%rip), %rsi # 0x326ae9
xorl %ebp, %ebp
movl $0xd, %edx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x8a174
movq %rax, %r15
movq %rax, %rdi
callq 0xbe5cc
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movq 0x4870(%rbx), %rax
movq %rax, 0x30(%rsp)
leaq 0x292b95(%rip), %rcx # 0x326af7
movq %rcx, 0x60(%rsp)
movq %rax, 0x38(%rsp)
leaq 0x292b8e(%rip), %rax # 0x326b01
movq %rax, 0x68(%rsp)
movq 0x47e8(%rbx), %rsi
movq %rbx, %rdi
callq 0x8a9e4
movq %rax, 0x40(%rsp)
leaq 0x292b8b(%rip), %rax # 0x326b1e
movq %rax, 0x70(%rsp)
movq 0x47e8(%rbx), %rsi
movq %rbx, %rdi
callq 0x8a9e4
movq %rax, 0x48(%rsp)
leaq 0x292b7f(%rip), %rax # 0x326b32
movq %rax, 0x78(%rsp)
movq %r15, 0x28(%rsp)
addq $0x40, %r15
xorl %r14d, %r14d
movq 0x4380(%rbx), %r12
movq 0x60(%rsp,%r14,8), %r13
testq %r13, %r13
je 0x93fe2
movq %r13, %rdi
callq 0x3c190
movq %rax, %rdx
jmp 0x93fe4
xorl %edx, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x78292
movq 0x30(%rsp,%r14,8), %r9
movl %ebp, 0x18(%rsp)
movl %ebp, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %rax, %r8
callq 0xbdf62
andb $-0x61, 0x1d(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0xc271a
incq %r14
cmpq $0x4, %r14
jne 0x93fc4
movq 0x28(%rsp), %r14
movq (%r14), %rax
movq %r14, %rdi
callq *0x68(%rax)
movq %r14, 0x57b0(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8fdbc
jmp 0x942d9
leaq 0x292a58(%rip), %rsi # 0x326ab1
xorl %ebp, %ebp
movl $0x9, %edx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x8a174
movq %rax, %r14
movq 0x830(%rbx), %rax
testb $0x4, 0x1(%rax)
je 0x940e6
movq 0x808(%rbx), %rax
movq 0x50(%rax), %rsi
leaq 0x48(%rsi), %rdi
callq 0x956b8
leaq 0x28(%rax), %r15
testq %rax, %rax
cmoveq %rax, %r15
movq 0x4380(%rbx), %rdi
leaq 0x32cf91(%rip), %rsi # 0x3c1038
movl $0x3, %edx
callq 0x78292
movl $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %rax, %r9
callq 0xc81d8
orb $0x2, 0x1d(%rax)
leaq 0x30(%rax), %rsi
movq %r14, %rdi
callq 0xc1110
movq %r14, %rdi
callq 0xbe5cc
movq %r14, %r15
addq $0x40, %r15
movq 0x4380(%rbx), %rdi
leaq 0x292a08(%rip), %rsi # 0x326b0b
movl $0x4, %edx
callq 0x78292
movq %rax, %r12
movq 0x47e8(%rbx), %rsi
movq %rbx, %rdi
callq 0x8a9e4
movl %ebp, 0x18(%rsp)
movl %ebp, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r12, %r8
movq %rax, %r9
callq 0xbdf62
andb $-0x61, 0x1d(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0xc271a
movq (%r14), %rax
movq %r14, %rdi
callq *0x68(%rax)
movq %r14, 0x57b0(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8fdbc
leaq 0x29292b(%rip), %rdx # 0x326a9f
movl $0x11, %ecx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8a23c
movq %rax, %r14
jmp 0x94362
leaq 0x292956(%rip), %rsi # 0x326ae9
xorl %ebp, %ebp
movl $0xd, %edx
movq %rbx, %rdi
xorl %ecx, %ecx
callq 0x8a174
movq %rax, %r15
movq %rax, %rdi
callq 0xbe5cc
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movq $0x0, 0x40(%rsp)
movq 0x47e8(%rbx), %rsi
movq %rbx, %rdi
callq 0x8a9e4
movq %rax, 0x30(%rsp)
leaq 0x292965(%rip), %rax # 0x326b40
movq %rax, 0x60(%rsp)
movq 0x47e8(%rbx), %rsi
movq %rbx, %rdi
callq 0x8a9e4
movq %rax, 0x38(%rsp)
leaq 0x292966(%rip), %rax # 0x326b61
movq %rax, 0x68(%rsp)
movq 0x47e8(%rbx), %rsi
movq %rbx, %rdi
callq 0x8a9e4
movq %rax, 0x40(%rsp)
leaq 0x292963(%rip), %rax # 0x326b7e
movq %rax, 0x70(%rsp)
movq %r15, 0x28(%rsp)
addq $0x40, %r15
xorl %r14d, %r14d
movq 0x4380(%rbx), %r12
movq 0x60(%rsp,%r14,8), %r13
testq %r13, %r13
je 0x9424a
movq %r13, %rdi
callq 0x3c190
movq %rax, %rdx
jmp 0x9424c
xorl %edx, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x78292
movq 0x30(%rsp,%r14,8), %r9
movl %ebp, 0x18(%rsp)
movl %ebp, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %rax, %r8
callq 0xbdf62
andb $-0x61, 0x1d(%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0xc271a
incq %r14
cmpq $0x3, %r14
jne 0x9422c
movq 0x28(%rsp), %r14
movq (%r14), %rax
movq %r14, %rdi
callq *0x68(%rax)
movq %r14, 0x57b0(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8fdbc
leaq 0x29282d(%rip), %rdx # 0x326ae9
movl $0xd, %ecx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8a23c
movq %rbx, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x8fc1e
movq %rax, %r14
movq 0x4348(%rbx), %rax
movl 0x88(%rax), %esi
movq %rbx, %rdi
callq 0x8a2ea
andq $-0x10, %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x8bd06
leaq 0x88(%rsp), %r15
movl $0x1, %edx
movq %r15, %rdi
movl %eax, %esi
xorl %ecx, %ecx
callq 0x66024
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x8e376
leaq 0x292769(%rip), %rdx # 0x326a9f
movl $0x11, %ecx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8a23c
movq %rax, %r14
cmpl $0x41, 0x8(%r15)
jb 0x94362
movq 0x88(%rsp), %rdi
testq %rdi, %rdi
je 0x94362
callq 0x3c180
movq %r14, 0x540(%rbx)
movq 0x540(%rbx), %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/AST/ASTContext.cpp
|
clang::ASTContext::getVTableContext()
|
VTableContextBase *ASTContext::getVTableContext() {
if (!VTContext.get()) {
auto ABI = Target->getCXXABI();
if (ABI.isMicrosoft())
VTContext.reset(new MicrosoftVTableContext(*this));
else {
auto ComponentLayout = getLangOpts().RelativeCXXABIVTables
? ItaniumVTableContext::Relative
: ItaniumVTableContext::Pointer;
VTContext.reset(new ItaniumVTableContext(*this, ComponentLayout));
}
}
return VTContext.get();
}
|
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x59a8(%rdi)
jne 0x94a57
movq 0x4348(%rbx), %rax
cmpl $0xa, 0x154(%rax)
jne 0x94a11
movl $0x90, %edi
callq 0x3c390
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
xorl %ecx, %ecx
movl %ecx, 0x18(%rax)
movb $0x1, 0x20(%rax)
leaq 0x42548a(%rip), %rdx # 0x4b9e68
addq $0x10, %rdx
movq %rdx, (%rax)
movq %rbx, 0x28(%rax)
movups %xmm0, 0x30(%rax)
movl %ecx, 0x40(%rax)
movups %xmm0, 0x48(%rax)
movl %ecx, 0x58(%rax)
movups %xmm0, 0x60(%rax)
movl %ecx, 0x70(%rax)
movups %xmm0, 0x78(%rax)
movl %ecx, 0x88(%rax)
movq %rax, 0x59a8(%rbx)
jmp 0x94a57
movq 0x830(%rbx), %rax
movl 0xa8(%rax), %ebp
shrl $0x4, %ebp
andl $0x1, %ebp
movl $0x90, %edi
callq 0x3c390
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x236056
movq 0x59a8(%rbx), %rdi
movq %r14, 0x59a8(%rbx)
testq %rdi, %rdi
je 0x94a57
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x59a8(%rbx), %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
|
/AST/ASTContext.cpp
|
llvm::MapVector<clang::NamedDecl const*, unsigned int, llvm::DenseMap<clang::NamedDecl const*, unsigned int, llvm::DenseMapInfo<clang::NamedDecl const*, void>, llvm::detail::DenseMapPair<clang::NamedDecl const*, unsigned int>>, llvm::SmallVector<std::pair<clang::NamedDecl const*, unsigned int>, 0u>>::find(clang::NamedDecl const* const&) const
|
const_iterator find(const KeyT &Key) const {
typename MapType::const_iterator Pos = Map.find(Key);
return Pos == Map.end()? Vector.end() :
(Vector.begin() + Pos->second);
}
|
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rsi
callq 0x99fc4
movl 0x10(%rbx), %ecx
shlq $0x4, %rcx
addq (%rbx), %rcx
leaq 0x8(%rax), %rdx
leaq 0x20(%rbx), %rsi
cmpq %rcx, %rax
cmoveq %rsi, %rdx
movl (%rdx), %eax
shlq $0x4, %rax
addq 0x18(%rbx), %rax
popq %rbx
retq
nop
|
/llvm/ADT/MapVector.h
|
clang::ASTContext::getTemplateParamObjectDecl(clang::QualType, clang::APValue const&) const
|
TemplateParamObjectDecl *
ASTContext::getTemplateParamObjectDecl(QualType T, const APValue &V) const {
assert(T->isRecordType() && "template param object of unexpected type");
// C++ [temp.param]p8:
// [...] a static storage duration object of type 'const T' [...]
T.addConst();
llvm::FoldingSetNodeID ID;
TemplateParamObjectDecl::Profile(ID, T, V);
void *InsertPos;
if (TemplateParamObjectDecl *Existing =
TemplateParamObjectDecls.FindNodeOrInsertPos(ID, InsertPos))
return Existing;
TemplateParamObjectDecl *New = TemplateParamObjectDecl::Create(*this, T, V);
TemplateParamObjectDecls.InsertNode(New, InsertPos);
return New;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r13
orq $0x1, %r14
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movabsq $0x2000000000, %rax # imm = 0x2000000000
movq %rax, -0x8(%rbp)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x94e42
leaq 0x4d0(%r13), %r12
leaq 0x423b87(%rip), %rcx # 0x4b8958
movq %rsp, %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x3181fc
movq %rax, %r15
addq $-0x38, %rax
testq %r15, %r15
cmovneq %rax, %r15
jne 0x94e1e
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xd3b04
movq %rax, %r15
movq (%rsp), %rdx
leaq 0x38(%rax), %rsi
testq %rax, %rax
cmoveq %rax, %rsi
leaq 0x423b42(%rip), %rcx # 0x4b8958
movq %r12, %rdi
callq 0x318150
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x94e2d
callq 0x3c3a0
movq %r15, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/AST/ASTContext.cpp
|
bool clang::Decl::hasAttr<clang::CUDAGlobalAttr>() const
|
bool hasAttrs() const { return HasAttrs; }
|
testb $0x1, 0x1d(%rdi)
jne 0x95439
xorl %eax, %eax
retq
pushq %rax
callq 0xc136a
movq (%rax), %rcx
movl 0x8(%rax), %edx
leaq (%rcx,%rdx,8), %rax
testq %rdx, %rdx
je 0x95467
shlq $0x3, %rdx
movq (%rcx), %rsi
cmpw $0x92, 0x20(%rsi)
je 0x95467
addq $0x8, %rcx
addq $-0x8, %rdx
jne 0x95452
cmpq %rax, %rcx
setne %al
addq $0x8, %rsp
retq
|
/clang/AST/DeclBase.h
|
llvm::SmallVectorTemplateBase<clang::SourceLocation, true>::push_back(clang::SourceLocation)
|
void push_back(ValueParamT Elt) {
const T *EltPtr = reserveForParamAndGetAddress(Elt);
memcpy(reinterpret_cast<void *>(this->end()), EltPtr, sizeof(T));
this->set_size(this->size() + 1);
}
|
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl 0x8(%rdi), %edx
cmpl 0xc(%rdi), %edx
jae 0x956a1
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
movl %ebp, (%rax,%rcx,4)
incl 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
incq %rdx
leaq 0x10(%rbx), %rsi
movl $0x4, %ecx
movq %rbx, %rdi
callq 0x56f14
jmp 0x9568e
nop
|
/llvm/ADT/SmallVector.h
|
llvm::DenseMap<clang::CXXRecordDecl const*, clang::CharUnits, llvm::DenseMapInfo<clang::CXXRecordDecl const*, void>, llvm::detail::DenseMapPair<clang::CXXRecordDecl const*, clang::CharUnits>>::grow(unsigned int)
|
void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBuckets(OldBuckets, OldBuckets+OldNumBuckets);
// Free the old table.
deallocate_buffer(OldBuckets, sizeof(BucketT) * OldNumBuckets,
alignof(BucketT));
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl 0x10(%rdi), %ebx
movq (%rdi), %r14
leal -0x1(%rsi), %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x8, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x10, %ecx
orl %eax, %ecx
incl %ecx
cmpl $0x41, %ecx
movl $0x40, %edi
cmovael %ecx, %edi
movl %edi, 0x10(%r15)
shlq $0x4, %rdi
movl $0x8, %esi
callq 0x56dc3
movq %rax, (%r15)
testq %r14, %r14
je 0x9594e
shlq $0x4, %rbx
leaq (%r14,%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x95a16
movl $0x8, %edx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x56dc8
movq $0x0, 0x8(%r15)
movl 0x10(%r15), %ecx
testq %rcx, %rcx
je 0x95a0f
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x1, %ecx
negq %rcx
addq %rdx, %rcx
addq $0x2, %rcx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
addq $0x10, %rax
xorl %edx, %edx
movdqa 0x28c668(%rip), %xmm1 # 0x322000
movdqa 0x28c670(%rip), %xmm2 # 0x322010
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movq %rdx, %xmm4
pshufd $0x44, %xmm4, %xmm4 # xmm4 = xmm4[0,1,0,1]
por %xmm1, %xmm4
pxor %xmm2, %xmm4
movdqa %xmm4, %xmm5
pcmpgtd %xmm0, %xmm5
pcmpeqd %xmm0, %xmm4
pshufd $0xf5, %xmm4, %xmm6 # xmm6 = xmm4[1,1,3,3]
pand %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm4 # xmm4 = xmm5[1,1,3,3]
por %xmm6, %xmm4
movd %xmm4, %esi
notl %esi
testb $0x1, %sil
je 0x959ec
movq $-0x1000, -0x10(%rax) # imm = 0xF000
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %esi
testb $0x1, %sil
je 0x95a02
movq $-0x1000, (%rax) # imm = 0xF000
addq $0x2, %rdx
addq $0x20, %rax
cmpq %rdx, %rcx
jne 0x959a8
popq %rbx
popq %r14
popq %r15
retq
nop
|
/llvm/ADT/DenseMap.h
|
clang::NonTypeTemplateParmDecl::hasPlaceholderTypeConstraint() const
|
bool hasPlaceholderTypeConstraint() const {
auto *AT = getType()->getContainedAutoType();
return AT && AT->isConstrained();
}
|
pushq %rax
movq 0x30(%rdi), %rax
andq $-0x10, %rax
movq (%rax), %rdi
callq 0x226c7c
xorl %ecx, %ecx
testq %rax, %rax
je 0x9645a
cmpb $0x10, 0x10(%rax)
cmoveq %rax, %rcx
testq %rcx, %rcx
je 0x96469
cmpq $0x0, 0x28(%rcx)
setne %al
jmp 0x9646b
xorl %eax, %eax
popq %rcx
retq
nop
|
/clang/AST/DeclTemplate.h
|
clang::CXXRecordDecl::bases_begin()
|
base_class_iterator bases_begin() { return data().getBases(); }
|
pushq %rbx
movq %rdi, %rbx
movq 0x68(%rdi), %rsi
leaq 0x60(%rsi), %rdi
callq 0x79ef0
movq 0x80(%rbx), %rdi
movq 0x18(%rdi), %rax
testb $0x1, %al
jne 0x967a4
popq %rbx
retq
popq %rbx
jmp 0xc42c6
|
/clang/AST/DeclCXX.h
|
bool llvm::DenseMapBase<llvm::DenseMap<clang::CXXRecordDecl const*, clang::ASTRecordLayout::VBaseInfo, llvm::DenseMapInfo<clang::CXXRecordDecl const*, void>, llvm::detail::DenseMapPair<clang::CXXRecordDecl const*, clang::ASTRecordLayout::VBaseInfo>>, clang::CXXRecordDecl const*, clang::ASTRecordLayout::VBaseInfo, llvm::DenseMapInfo<clang::CXXRecordDecl const*, void>, llvm::detail::DenseMapPair<clang::CXXRecordDecl const*, clang::ASTRecordLayout::VBaseInfo>>::LookupBucketFor<clang::CXXRecordDecl const*>(clang::CXXRecordDecl const* const&, llvm::detail::DenseMapPair<clang::CXXRecordDecl const*, clang::ASTRecordLayout::VBaseInfo> const*&) const
|
unsigned getNumBuckets() const {
return NumBuckets;
}
|
movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x9687c
pushq %rbx
movq (%rdi), %rdi
movl (%rsi), %r8d
movl %r8d, %eax
shrl $0x4, %eax
shrl $0x9, %r8d
xorl %eax, %r8d
decl %ecx
andl %ecx, %r8d
movl $0x1, %r10d
xorl %r9d, %r9d
movl %r8d, %r11d
leaq (%r11,%r11,2), %r11
leaq (%rdi,%r11,8), %r11
movq (%r11), %rbx
cmpq %rbx, (%rsi)
jne 0x96843
movq %r11, (%rdx)
movb $0x1, %al
xorl %r11d, %r11d
testb %r11b, %r11b
jne 0x96821
jmp 0x96879
cmpq $-0x1000, %rbx # imm = 0xF000
jne 0x9685d
testq %r9, %r9
cmovneq %r9, %r11
movq %r11, (%rdx)
xorl %r11d, %r11d
xorl %eax, %eax
jmp 0x9683c
xorq $-0x2000, %rbx # imm = 0xE000
orq %r9, %rbx
cmoveq %r11, %r9
addl %r10d, %r8d
incl %r10d
andl %ecx, %r8d
movb $0x1, %r11b
jmp 0x9683c
popq %rbx
jmp 0x96885
movq $0x0, (%rdx)
xorl %eax, %eax
andb $0x1, %al
retq
|
/llvm/ADT/DenseMap.h
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.