name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
void llvm::SmallVectorImpl<clang::CustomizableOptional<clang::FileEntryRef>>::resizeImpl<false>(unsigned long) | void resizeImpl(size_type N) {
if (N == this->size())
return;
if (N < this->size()) {
this->truncate(N);
return;
}
this->reserve(N);
for (auto I = this->end(), E = this->begin() + N; I != E; ++I)
if (ForOverwrite)
new (&*I) T;
else
new (&*I) T();
this->set_size(N);
} | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0x87dfe0
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jne 0x99ccd9
jmp 0x99cd92
movq 0x18(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x87dfe0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x99cd0e
movq 0x18(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x99cda0
jmp 0x99cd92
movq 0x18(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x99ce00
movq 0x18(%rsp), %rdi
callq 0x99cc60
movq 0x18(%rsp), %rdi
movq %rax, 0x30(%rsp)
callq 0x99cc50
movq 0x38(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x28(%rsp), %rax
je 0x99cd83
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x73aa90
movq 0x8(%rsp), %rdi
callq 0x9928a0
movq 0x30(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x30(%rsp)
jmp 0x99cd47
movq 0x18(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x87e040
addq $0x48, %rsp
retq
nopw (%rax,%rax)
| /llvm/ADT/SmallVector.h |
llvm::DenseMapIterator<void const*, llvm::StringRef, llvm::DenseMapInfo<void const*, void>, llvm::detail::DenseMapPair<void const*, llvm::StringRef>, false>::RetreatPastEmptyBuckets() | void RetreatPastEmptyBuckets() {
assert(Ptr >= End);
const KeyT Empty = KeyInfoT::getEmptyKey();
const KeyT Tombstone = KeyInfoT::getTombstoneKey();
while (Ptr != End && (KeyInfoT::isEqual(Ptr[-1].getFirst(), Empty) ||
KeyInfoT::isEqual(Ptr[-1].getFirst(), Tombstone)))
--Ptr;
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x999610
movq %rax, 0x18(%rsp)
callq 0x99a0f0
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdx
movq (%rdx), %rcx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, 0x7(%rsp)
je 0x99d420
movq 0x8(%rsp), %rax
movq (%rax), %rdi
addq $-0x18, %rdi
callq 0x9995c0
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x99a0c0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x6(%rsp)
jne 0x99d418
movq 0x8(%rsp), %rax
movq (%rax), %rdi
addq $-0x18, %rdi
callq 0x9995c0
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x99a0c0
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x99d42a
jmp 0x99d43e
movq 0x8(%rsp), %rax
movq (%rax), %rcx
addq $-0x18, %rcx
movq %rcx, (%rax)
jmp 0x99d3b7
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /llvm/ADT/DenseMap.h |
clang::FileSystemStatCache::get(llvm::StringRef, llvm::vfs::Status&, bool, std::unique_ptr<llvm::vfs::File, std::default_delete<llvm::vfs::File>>*, clang::FileSystemStatCache*, llvm::vfs::FileSystem&) | std::error_code
FileSystemStatCache::get(StringRef Path, llvm::vfs::Status &Status,
bool isFile, std::unique_ptr<llvm::vfs::File> *F,
FileSystemStatCache *Cache,
llvm::vfs::FileSystem &FS) {
bool isForDir = !isFile;
std::error_code RetCode;
// If we have a cache, use it to resolve the stat query.
if (Cache)
RetCode = Cache->getStat(Path, Status, isFile, F, FS);
else if (isForDir || !F) {
// If this is a directory or a file descriptor is not needed and we have
// no cache, just go to the file system.
llvm::ErrorOr<llvm::vfs::Status> StatusOrErr = FS.status(Path);
if (!StatusOrErr) {
RetCode = StatusOrErr.getError();
} else {
Status = *StatusOrErr;
}
} else {
// Otherwise, we have to go to the filesystem. We can always just use
// 'stat' here, but (for files) the client is asking whether the file exists
// because it wants to turn around and *open* it. It is more efficient to
// do "open+fstat" on success than it is to do "stat+open".
//
// Because of this, check to see if the file exists with 'open'. If the
// open succeeds, use fstat to get the stat info.
auto OwnedFile = FS.openFileForRead(Path);
if (!OwnedFile) {
// If the open fails, our "stat" fails.
RetCode = OwnedFile.getError();
} else {
// Otherwise, the open succeeded. Do an fstat to get the information
// about the file. We'll end up returning the open file descriptor to the
// client to do what they please with it.
llvm::ErrorOr<llvm::vfs::Status> StatusOrErr = (*OwnedFile)->status();
if (StatusOrErr) {
Status = *StatusOrErr;
*F = std::move(*OwnedFile);
} else {
// fstat rarely fails. If it does, claim the initial open didn't
// succeed.
*F = nullptr;
RetCode = StatusOrErr.getError();
}
}
}
// If the path doesn't exist, return failure.
if (RetCode)
return RetCode;
// If the path exists, make sure that its "directoryness" matches the clients
// demands.
if (Status.isDirectory() != isForDir) {
// If not, close the file if opened.
if (F)
*F = nullptr;
return std::make_error_code(
Status.isDirectory() ?
std::errc::is_a_directory : std::errc::not_a_directory);
}
return std::error_code();
} | subq $0x1e8, %rsp # imm = 0x1E8
movb %cl, %al
movq 0x1f0(%rsp), %rcx
movq %rdi, 0x1c8(%rsp)
movq %rsi, 0x1d0(%rsp)
movq %rdx, 0x1c0(%rsp)
andb $0x1, %al
movb %al, 0x1bf(%rsp)
movq %r8, 0x1b0(%rsp)
movq %r9, 0x1a8(%rsp)
movb 0x1bf(%rsp), %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, 0x1a7(%rsp)
leaq 0x190(%rsp), %rdi
callq 0x7f50e0
cmpq $0x0, 0x1a8(%rsp)
je 0x99dc6e
movq 0x1a8(%rsp), %rdi
movq 0x1c8(%rsp), %rax
movq %rax, 0x170(%rsp)
movq 0x1d0(%rsp), %rax
movq %rax, 0x178(%rsp)
movq 0x1c0(%rsp), %rcx
movb 0x1bf(%rsp), %r8b
movq 0x1b0(%rsp), %r9
movq 0x1f0(%rsp), %r10
movq 0x170(%rsp), %rsi
movq 0x178(%rsp), %rdx
movq (%rdi), %rax
andb $0x1, %r8b
movzbl %r8b, %r8d
movq %r10, (%rsp)
callq *0x18(%rax)
movl %eax, 0x180(%rsp)
movq %rdx, 0x188(%rsp)
movq 0x180(%rsp), %rax
movq %rax, 0x190(%rsp)
movq 0x188(%rsp), %rax
movq %rax, 0x198(%rsp)
jmp 0x99de94
testb $0x1, 0x1a7(%rsp)
jne 0x99dc87
cmpq $0x0, 0x1b0(%rsp)
jne 0x99dd42
movq 0x1f0(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0xe8(%rsp), %rdi
leaq 0x1c8(%rsp), %rsi
callq 0x7f18a0
movq 0x10(%rsp), %rsi
movq (%rsi), %rax
leaq 0x110(%rsp), %rdi
leaq 0xe8(%rsp), %rdx
callq *0x28(%rax)
leaq 0x110(%rsp), %rdi
callq 0x841850
testb $0x1, %al
jne 0x99dd13
leaq 0x110(%rsp), %rdi
callq 0x8418a0
movl %eax, 0xd8(%rsp)
movq %rdx, 0xe0(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x190(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0x198(%rsp)
jmp 0x99dd30
leaq 0x110(%rsp), %rdi
callq 0x84a430
movq %rax, %rsi
movq 0x1c0(%rsp), %rdi
callq 0x997350
leaq 0x110(%rsp), %rdi
callq 0x81b310
jmp 0x99de92
movq 0x1f0(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x98(%rsp), %rdi
leaq 0x1c8(%rsp), %rsi
callq 0x7f18a0
movq 0x8(%rsp), %rsi
movq (%rsi), %rax
leaq 0xc0(%rsp), %rdi
leaq 0x98(%rsp), %rdx
callq *0x30(%rax)
leaq 0xc0(%rsp), %rdi
callq 0x898b00
testb $0x1, %al
jne 0x99ddd1
leaq 0xc0(%rsp), %rdi
callq 0x898b20
movl %eax, 0x88(%rsp)
movq %rdx, 0x90(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x190(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x198(%rsp)
jmp 0x99de85
leaq 0xc0(%rsp), %rdi
callq 0x898b80
movq %rax, %rdi
callq 0x898b90
movq %rax, %rsi
movq (%rsi), %rax
leaq 0x28(%rsp), %rdi
callq *0x10(%rax)
leaq 0x28(%rsp), %rdi
callq 0x841850
testb $0x1, %al
jne 0x99de04
jmp 0x99de3d
leaq 0x28(%rsp), %rdi
callq 0x84a430
movq %rax, %rsi
movq 0x1c0(%rsp), %rdi
callq 0x997350
leaq 0xc0(%rsp), %rdi
callq 0x898b80
movq %rax, %rsi
movq 0x1b0(%rsp), %rdi
callq 0x995780
jmp 0x99de7b
movq 0x1b0(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x99df70
leaq 0x28(%rsp), %rdi
callq 0x8418a0
movl %eax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x190(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x198(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x81b310
leaq 0xc0(%rsp), %rdi
callq 0x898ba0
jmp 0x99de94
leaq 0x190(%rsp), %rdi
callq 0x7f5160
testb $0x1, %al
jne 0x99dea7
jmp 0x99decc
movq 0x190(%rsp), %rax
movq %rax, 0x1d8(%rsp)
movq 0x198(%rsp), %rax
movq %rax, 0x1e0(%rsp)
jmp 0x99df4d
movq 0x1c0(%rsp), %rdi
callq 0x898910
andb $0x1, %al
movzbl %al, %eax
movb 0x1a7(%rsp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x99df40
cmpq $0x0, 0x1b0(%rsp)
je 0x99df0b
movq 0x1b0(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x99df70
movq 0x1c0(%rsp), %rdi
callq 0x898910
movb %al, %cl
movl $0x14, %edi
movl $0x15, %eax
testb $0x1, %cl
cmovnel %eax, %edi
callq 0x840920
movl %eax, 0x1d8(%rsp)
movq %rdx, 0x1e0(%rsp)
jmp 0x99df4d
leaq 0x1d8(%rsp), %rdi
callq 0x7f50e0
movl 0x1d8(%rsp), %eax
movq 0x1e0(%rsp), %rdx
addq $0x1e8, %rsp # imm = 0x1E8
retq
nopw %cs:(%rax,%rax)
nop
| /Basic/FileSystemStatCache.cpp |
clang::tooling::dependencies::DependencyScanningTool::getTranslationUnitDependencies(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, llvm::StringRef, llvm::DenseSet<clang::tooling::dependencies::ModuleID, llvm::DenseMapInfo<clang::tooling::dependencies::ModuleID, void>> const&, llvm::function_ref<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> (clang::tooling::dependencies::ModuleID const&, clang::tooling::dependencies::ModuleOutputKind)>) | llvm::Expected<TranslationUnitDeps>
DependencyScanningTool::getTranslationUnitDependencies(
const std::vector<std::string> &CommandLine, StringRef CWD,
const llvm::DenseSet<ModuleID> &AlreadySeen,
LookupModuleOutputCallback LookupModuleOutput) {
FullDependencyConsumer Consumer(AlreadySeen);
CallbackActionController Controller(LookupModuleOutput);
llvm::Error Result =
Worker.computeDependencies(CWD, CommandLine, Consumer, Controller);
if (Result)
return std::move(Result);
return Consumer.takeTranslationUnitDeps();
} | subq $0x278, %rsp # imm = 0x278
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
leaq 0x280(%rsp), %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x270(%rsp)
movq %rcx, 0x260(%rsp)
movq %r8, 0x268(%rsp)
movq %rsi, 0x258(%rsp)
movq %rdx, 0x250(%rsp)
movq %r9, 0x248(%rsp)
movq 0x258(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x248(%rsp), %rsi
leaq 0x178(%rsp), %rdi
callq 0x99ed70
movq 0x30(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x150(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x158(%rsp)
movq 0x150(%rsp), %rsi
movq 0x158(%rsp), %rdx
leaq 0x160(%rsp), %rdi
callq 0x99e5a0
movq 0x260(%rsp), %rax
movq %rax, 0x138(%rsp)
movq 0x268(%rsp), %rax
movq %rax, 0x140(%rsp)
movq 0x250(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x120(%rsp), %rdi
callq 0x86ae40
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %r8
movq 0x138(%rsp), %rdx
movq 0x140(%rsp), %rcx
leaq 0x148(%rsp), %rdi
leaq 0x178(%rsp), %r9
leaq 0x160(%rsp), %r10
leaq 0x120(%rsp), %rax
movq %r10, (%rsp)
movq (%rax), %r10
movq %r10, 0x8(%rsp)
movq 0x8(%rax), %r10
movq %r10, 0x10(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x9c9f90
leaq 0x148(%rsp), %rdi
callq 0x7f7980
testb $0x1, %al
jne 0x99ecd6
jmp 0x99ecf5
movq 0x20(%rsp), %rdi
leaq 0x148(%rsp), %rsi
callq 0x99ee10
movl $0x1, 0x118(%rsp)
jmp 0x99ed2f
leaq 0x48(%rsp), %rdi
leaq 0x178(%rsp), %rsi
callq 0x99ee50
movq 0x20(%rsp), %rdi
leaq 0x48(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x99efb0
leaq 0x48(%rsp), %rdi
callq 0x8078b0
movl $0x1, 0x118(%rsp)
leaq 0x148(%rsp), %rdi
callq 0x7f51d0
leaq 0x160(%rsp), %rdi
callq 0x99f550
leaq 0x178(%rsp), %rdi
callq 0x99eff0
movq 0x28(%rsp), %rax
addq $0x278, %rsp # imm = 0x278
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /Tooling/DependencyScanning/DependencyScanningTool.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::CachedHashString, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::CachedHashString, void>, llvm::detail::DenseSetPair<llvm::CachedHashString>>, llvm::CachedHashString, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::CachedHashString, void>, llvm::detail::DenseSetPair<llvm::CachedHashString>>::getMinBucketToReserveForEntries(unsigned int) | unsigned getMinBucketToReserveForEntries(unsigned NumEntries) {
// Ensure that "NumEntries * 4 < NumBuckets * 3"
if (NumEntries == 0)
return 0;
// +1 is required because of the strict equality.
// For example if NumEntries is 48, we need to return 401.
return NextPowerOf2(NumEntries * 4 / 3 + 1);
} | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x9b334e
movl $0x0, 0x14(%rsp)
jmp 0x9b336e
movl 0x4(%rsp), %eax
shll $0x2, %eax
movl $0x3, %ecx
xorl %edx, %edx
divl %ecx
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x7f65b0
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
| /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<clang::FileEntry const*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<clang::FileEntry const*, void>, llvm::detail::DenseSetPair<clang::FileEntry const*>>, clang::FileEntry const*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<clang::FileEntry const*, void>, llvm::detail::DenseSetPair<clang::FileEntry const*>>::find(clang::FileEntry const*) const | const_iterator find(const_arg_type_t<KeyT> Val) const {
const BucketT *TheBucket;
if (LookupBucketFor(Val, TheBucket))
return makeConstIterator(TheBucket,
shouldReverseIterate<KeyT>() ? getBuckets()
: getBucketsEnd(),
*this, true);
return end();
} | subq $0x48, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
leaq 0x28(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x98b070
testb $0x1, %al
jne 0x9b4bdd
jmp 0x9b4c3b
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x982ae0
testb $0x1, %al
jne 0x9b4bf2
jmp 0x9b4c03
movq 0x18(%rsp), %rdi
callq 0x98b210
movq %rax, 0x8(%rsp)
jmp 0x9b4c12
movq 0x18(%rsp), %rdi
callq 0x9b4dc0
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movl $0x1, %r8d
movq %rcx, %rdi
callq 0x9b4ce0
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
jmp 0x9b4c4f
movq 0x18(%rsp), %rdi
callq 0x9b4c60
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rdx
addq $0x48, %rsp
retq
nop
| /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<clang::Module const*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<clang::Module const*, void>, llvm::detail::DenseSetPair<clang::Module const*>>, clang::Module const*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<clang::Module const*, void>, llvm::detail::DenseSetPair<clang::Module const*>>::find(clang::Module const*) const | const_iterator find(const_arg_type_t<KeyT> Val) const {
const BucketT *TheBucket;
if (LookupBucketFor(Val, TheBucket))
return makeConstIterator(TheBucket,
shouldReverseIterate<KeyT>() ? getBuckets()
: getBucketsEnd(),
*this, true);
return end();
} | subq $0x48, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
leaq 0x28(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x9b6aa0
testb $0x1, %al
jne 0x9b69ed
jmp 0x9b6a4b
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x9b6d20
testb $0x1, %al
jne 0x9b6a02
jmp 0x9b6a13
movq 0x18(%rsp), %rdi
callq 0x9b6d30
movq %rax, 0x8(%rsp)
jmp 0x9b6a22
movq 0x18(%rsp), %rdi
callq 0x9b6d40
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movl $0x1, %r8d
movq %rcx, %rdi
callq 0x9b6c40
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
jmp 0x9b6a5f
movq 0x18(%rsp), %rdi
callq 0x9b6d80
movq %rax, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rdx
addq $0x48, %rsp
retq
nop
| /llvm/ADT/DenseMap.h |
llvm::DenseMapIterator<clang::tooling::dependencies::ModuleID, clang::tooling::dependencies::ModuleDeps*, llvm::DenseMapInfo<clang::tooling::dependencies::ModuleID, void>, llvm::detail::DenseMapPair<clang::tooling::dependencies::ModuleID, clang::tooling::dependencies::ModuleDeps*>, false>::DenseMapIterator(llvm::detail::DenseMapPair<clang::tooling::dependencies::ModuleID, clang::tooling::dependencies::ModuleDeps*>*, llvm::detail::DenseMapPair<clang::tooling::dependencies::ModuleID, clang::tooling::dependencies::ModuleDeps*>*, llvm::DebugEpochBase const&, bool) | DenseMapIterator(pointer Pos, pointer E, const DebugEpochBase &Epoch,
bool NoAdvance = false)
: DebugEpochBase::HandleBase(&Epoch), Ptr(Pos), End(E) {
assert(isHandleInSync() && "invalid construction!");
if (NoAdvance) return;
if (shouldReverseIterate<KeyT>()) {
RetreatPastEmptyBuckets();
return;
}
AdvancePastEmptyBuckets();
} | subq $0x38, %rsp
movb %r8b, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rsi
callq 0x8148c0
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rax)
testb $0x1, 0x17(%rsp)
je 0x9b7ab4
jmp 0x9b7ad5
callq 0x9a3460
testb $0x1, %al
jne 0x9b7abf
jmp 0x9b7acb
movq 0x8(%rsp), %rdi
callq 0x9b7ae0
jmp 0x9b7ad5
movq 0x8(%rsp), %rdi
callq 0x9b7bc0
addq $0x38, %rsp
retq
nopw (%rax,%rax)
| /llvm/ADT/DenseMap.h |
std::pair<clang::Module const*, std::unique_ptr<clang::tooling::dependencies::ModuleDeps, std::default_delete<clang::tooling::dependencies::ModuleDeps>>> const* llvm::SmallVectorTemplateCommon<std::pair<clang::Module const*, std::unique_ptr<clang::tooling::dependencies::ModuleDeps, std::default_delete<clang::tooling::dependencies::ModuleDeps>>>, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<std::pair<clang::Module const*, std::unique_ptr<clang::tooling::dependencies::ModuleDeps, std::default_delete<clang::tooling::dependencies::ModuleDeps>>>, false>>(llvm::SmallVectorTemplateBase<std::pair<clang::Module const*, std::unique_ptr<clang::tooling::dependencies::ModuleDeps, std::default_delete<clang::tooling::dependencies::ModuleDeps>>>, false>*, std::pair<clang::Module const*, std::unique_ptr<clang::tooling::dependencies::ModuleDeps, std::default_delete<clang::tooling::dependencies::ModuleDeps>>> const&, unsigned long) | static const T *reserveForParamAndGetAddressImpl(U *This, const T &Elt,
size_t N) {
size_t NewSize = This->size() + N;
if (LLVM_LIKELY(NewSize <= This->capacity()))
return &Elt;
bool ReferencesStorage = false;
int64_t Index = -1;
if (!U::TakesParamByValue) {
if (LLVM_UNLIKELY(This->isReferenceToStorage(&Elt))) {
ReferencesStorage = true;
Index = &Elt - This->begin();
}
}
This->grow(NewSize);
return ReferencesStorage ? This->begin() + Index : &Elt;
} | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rdi
callq 0x87dfe0
addq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
callq 0x87ddf0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
ja 0x9ba917
movq 0x40(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x9ba9ae
movb $0x0, 0x2f(%rsp)
movq $-0x1, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x9ba9c0
testb $0x1, %al
jne 0x9ba93a
jmp 0x9ba967
movb $0x1, 0x2f(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
callq 0x9b4460
movq %rax, %rcx
movq 0x10(%rsp), %rax
subq %rcx, %rax
sarq $0x4, %rax
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x9baa20
testb $0x1, 0x2f(%rsp)
je 0x9ba99a
movq 0x48(%rsp), %rdi
callq 0x9b4460
movq 0x20(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
jmp 0x9ba9a4
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
| /llvm/ADT/SmallVector.h |
clang::tooling::dependencies::DependencyScanningWorkerFilesystem::findEntryByFilenameWithWriteThrough(llvm::StringRef) | const CachedFileSystemEntry *
DependencyScanningWorkerFilesystem::findEntryByFilenameWithWriteThrough(
StringRef Filename) {
if (const auto *Entry = LocalCache.findEntryByFilename(Filename))
return Entry;
auto &Shard = SharedCache.getShardForFilename(Filename);
if (const auto *Entry = Shard.findEntryByFilename(Filename))
return &LocalCache.insertEntryForFilename(Filename, *Entry);
return nullptr;
} | subq $0x88, %rsp
movq %rsi, 0x70(%rsp)
movq %rdx, 0x78(%rsp)
movq %rdi, 0x68(%rsp)
movq 0x68(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x20, %rdi
movq 0x70(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
callq 0x9c3490
movq %rax, 0x60(%rsp)
cmpq $0x0, 0x60(%rsp)
je 0x9c33c6
movq 0x60(%rsp), %rax
movq %rax, 0x80(%rsp)
jmp 0x9c3473
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x70(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0x9c1dd0
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movq 0x70(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x9c1f00
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x9c3467
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rcx
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x9c3540
movq %rax, 0x80(%rsp)
jmp 0x9c3473
movq $0x0, 0x80(%rsp)
movq 0x80(%rsp), %rax
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /Tooling/DependencyScanning/DependencyScanningFilesystem.cpp |
parseLTOMode(clang::driver::Driver&, llvm::opt::ArgList const&, llvm::opt::OptSpecifier, llvm::opt::OptSpecifier) | static driver::LTOKind parseLTOMode(Driver &D, const llvm::opt::ArgList &Args,
OptSpecifier OptEq, OptSpecifier OptNeg) {
if (!Args.hasFlag(OptEq, OptNeg, false))
return LTOK_None;
const Arg *A = Args.getLastArg(OptEq);
StringRef LTOName = A->getValue();
driver::LTOKind LTOMode = llvm::StringSwitch<LTOKind>(LTOName)
.Case("full", LTOK_Full)
.Case("thin", LTOK_Thin)
.Default(LTOK_Unknown);
if (LTOMode == LTOK_Unknown) {
D.Diag(diag::err_drv_unsupported_option_argument)
<< A->getSpelling() << A->getValue();
return LTOK_None;
}
return LTOMode;
} | subq $0xe8, %rsp
movl %edx, 0xe0(%rsp)
movl %ecx, 0xdc(%rsp)
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq 0xc8(%rsp), %rdi
movl 0xe0(%rsp), %eax
movl %eax, 0xc4(%rsp)
movl 0xdc(%rsp), %eax
movl %eax, 0xc0(%rsp)
movl 0xc4(%rsp), %esi
movl 0xc0(%rsp), %edx
xorl %ecx, %ecx
callq 0x828060
testb $0x1, %al
jne 0x9e6462
movl $0x0, 0xe4(%rsp)
jmp 0x9e65e0
movq 0xc8(%rsp), %rdi
movl 0xe0(%rsp), %eax
movl %eax, 0xb4(%rsp)
movl 0xb4(%rsp), %esi
callq 0x828720
movq %rax, 0xb8(%rsp)
movq 0xb8(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq %rax, %rsi
leaq 0xa0(%rsp), %rdi
callq 0x7eb0f0
movq 0xa0(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x70(%rsp), %rsi
movq 0x78(%rsp), %rdx
leaq 0x80(%rsp), %rdi
callq 0xa0c370
leaq 0x60(%rsp), %rdi
leaq 0x759de72(%rip), %rsi # 0x7f8435a
callq 0x7ec120
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rdx
leaq 0x80(%rsp), %rdi
movl $0x1, %ecx
callq 0xa0c3b0
movq %rax, 0x10(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x750f2c6(%rip), %rsi # 0x7ef57e0
callq 0x7ec120
movq 0x10(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
movl $0x2, %ecx
callq 0xa0c3b0
movq %rax, %rdi
movl $0x3, %esi
callq 0xa0c450
movl %eax, 0x9c(%rsp)
cmpl $0x3, 0x9c(%rsp)
jne 0x9e65d2
movq 0xd0(%rsp), %rsi
leaq 0x30(%rsp), %rdi
movl $0x1e7, %edx # imm = 0x1E7
callq 0x9df2d0
movq 0xb8(%rsp), %rdi
callq 0x83b7a0
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x973710
movq %rax, 0x8(%rsp)
movq 0xb8(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rsi
callq 0x9e4c20
leaq 0x30(%rsp), %rdi
callq 0x949780
movl $0x0, 0xe4(%rsp)
jmp 0x9e65e0
movl 0x9c(%rsp), %eax
movl %eax, 0xe4(%rsp)
movl 0xe4(%rsp), %eax
addq $0xe8, %rsp
retq
nop
| /Driver/Driver.cpp |
clang::driver::Driver::BuildCompilation(llvm::ArrayRef<char const*>) | Compilation *Driver::BuildCompilation(ArrayRef<const char *> ArgList) {
llvm::PrettyStackTraceString CrashInfo("Compilation construction");
// FIXME: Handle environment options which affect driver behavior, somewhere
// (client?). GCC_EXEC_PREFIX, LPATH, CC_PRINT_OPTIONS.
// We look for the driver mode option early, because the mode can affect
// how other options are parsed.
auto DriverMode = getDriverMode(ClangExecutable, ArgList.slice(1));
if (!DriverMode.empty())
setDriverMode(DriverMode);
// FIXME: What are we going to do with -V and -b?
// Arguments specified in command line.
bool ContainsError;
CLOptions = std::make_unique<InputArgList>(
ParseArgStrings(ArgList.slice(1), /*UseDriverMode=*/true, ContainsError));
// Try parsing configuration file.
if (!ContainsError)
ContainsError = loadConfigFiles();
bool HasConfigFile = !ContainsError && (CfgOptions.get() != nullptr);
// All arguments, from both config file and command line.
InputArgList Args = std::move(HasConfigFile ? std::move(*CfgOptions)
: std::move(*CLOptions));
if (HasConfigFile)
for (auto *Opt : *CLOptions) {
if (Opt->getOption().matches(options::OPT_config))
continue;
const Arg *BaseArg = &Opt->getBaseArg();
if (BaseArg == Opt)
BaseArg = nullptr;
appendOneArg(Args, Opt, BaseArg);
}
// In CL mode, look for any pass-through arguments
if (IsCLMode() && !ContainsError) {
SmallVector<const char *, 16> CLModePassThroughArgList;
for (const auto *A : Args.filtered(options::OPT__SLASH_clang)) {
A->claim();
CLModePassThroughArgList.push_back(A->getValue());
}
if (!CLModePassThroughArgList.empty()) {
// Parse any pass through args using default clang processing rather
// than clang-cl processing.
auto CLModePassThroughOptions = std::make_unique<InputArgList>(
ParseArgStrings(CLModePassThroughArgList, /*UseDriverMode=*/false,
ContainsError));
if (!ContainsError)
for (auto *Opt : *CLModePassThroughOptions) {
appendOneArg(Args, Opt, nullptr);
}
}
}
// Check for working directory option before accessing any files
if (Arg *WD = Args.getLastArg(options::OPT_working_directory))
if (VFS->setCurrentWorkingDirectory(WD->getValue()))
Diag(diag::err_drv_unable_to_set_working_directory) << WD->getValue();
// Check for missing include directories.
if (!Diags.isIgnored(diag::warn_missing_include_dirs, SourceLocation())) {
for (auto IncludeDir : Args.getAllArgValues(options::OPT_I_Group)) {
if (!VFS->exists(IncludeDir))
Diag(diag::warn_missing_include_dirs) << IncludeDir;
}
}
// FIXME: This stuff needs to go into the Compilation, not the driver.
bool CCCPrintPhases;
// -canonical-prefixes, -no-canonical-prefixes are used very early in main.
Args.ClaimAllArgs(options::OPT_canonical_prefixes);
Args.ClaimAllArgs(options::OPT_no_canonical_prefixes);
// f(no-)integated-cc1 is also used very early in main.
Args.ClaimAllArgs(options::OPT_fintegrated_cc1);
Args.ClaimAllArgs(options::OPT_fno_integrated_cc1);
// Ignore -pipe.
Args.ClaimAllArgs(options::OPT_pipe);
// Extract -ccc args.
//
// FIXME: We need to figure out where this behavior should live. Most of it
// should be outside in the client; the parts that aren't should have proper
// options, either by introducing new ones or by overloading gcc ones like -V
// or -b.
CCCPrintPhases = Args.hasArg(options::OPT_ccc_print_phases);
CCCPrintBindings = Args.hasArg(options::OPT_ccc_print_bindings);
if (const Arg *A = Args.getLastArg(options::OPT_ccc_gcc_name))
CCCGenericGCCName = A->getValue();
// Process -fproc-stat-report options.
if (const Arg *A = Args.getLastArg(options::OPT_fproc_stat_report_EQ)) {
CCPrintProcessStats = true;
CCPrintStatReportFilename = A->getValue();
}
if (Args.hasArg(options::OPT_fproc_stat_report))
CCPrintProcessStats = true;
// FIXME: TargetTriple is used by the target-prefixed calls to as/ld
// and getToolChain is const.
if (IsCLMode()) {
// clang-cl targets MSVC-style Win32.
llvm::Triple T(TargetTriple);
T.setOS(llvm::Triple::Win32);
T.setVendor(llvm::Triple::PC);
T.setEnvironment(llvm::Triple::MSVC);
T.setObjectFormat(llvm::Triple::COFF);
if (Args.hasArg(options::OPT__SLASH_arm64EC))
T.setArch(llvm::Triple::aarch64, llvm::Triple::AArch64SubArch_arm64ec);
TargetTriple = T.str();
} else if (IsDXCMode()) {
// Build TargetTriple from target_profile option for clang-dxc.
if (const Arg *A = Args.getLastArg(options::OPT_target_profile)) {
StringRef TargetProfile = A->getValue();
if (auto Triple =
toolchains::HLSLToolChain::parseTargetProfile(TargetProfile))
TargetTriple = *Triple;
else
Diag(diag::err_drv_invalid_directx_shader_module) << TargetProfile;
A->claim();
if (Args.hasArg(options::OPT_spirv)) {
llvm::Triple T(TargetTriple);
T.setArch(llvm::Triple::spirv);
T.setOS(llvm::Triple::Vulkan);
// Set specific Vulkan version if applicable.
if (const Arg *A = Args.getLastArg(options::OPT_fspv_target_env_EQ)) {
const llvm::StringSet<> ValidValues = {"vulkan1.2", "vulkan1.3"};
if (ValidValues.contains(A->getValue())) {
T.setOSName(A->getValue());
} else {
Diag(diag::err_drv_invalid_value)
<< A->getAsString(Args) << A->getValue();
}
A->claim();
}
TargetTriple = T.str();
}
} else {
Diag(diag::err_drv_dxc_missing_target_profile);
}
}
if (const Arg *A = Args.getLastArg(options::OPT_target))
TargetTriple = A->getValue();
if (const Arg *A = Args.getLastArg(options::OPT_ccc_install_dir))
Dir = Dir = A->getValue();
for (const Arg *A : Args.filtered(options::OPT_B)) {
A->claim();
PrefixDirs.push_back(A->getValue(0));
}
if (std::optional<std::string> CompilerPathValue =
llvm::sys::Process::GetEnv("COMPILER_PATH")) {
StringRef CompilerPath = *CompilerPathValue;
while (!CompilerPath.empty()) {
std::pair<StringRef, StringRef> Split =
CompilerPath.split(llvm::sys::EnvPathSeparator);
PrefixDirs.push_back(std::string(Split.first));
CompilerPath = Split.second;
}
}
if (const Arg *A = Args.getLastArg(options::OPT__sysroot_EQ))
SysRoot = A->getValue();
if (const Arg *A = Args.getLastArg(options::OPT__dyld_prefix_EQ))
DyldPrefix = A->getValue();
if (const Arg *A = Args.getLastArg(options::OPT_resource_dir))
ResourceDir = A->getValue();
if (const Arg *A = Args.getLastArg(options::OPT_save_temps_EQ)) {
SaveTemps = llvm::StringSwitch<SaveTempsMode>(A->getValue())
.Case("cwd", SaveTempsCwd)
.Case("obj", SaveTempsObj)
.Default(SaveTempsCwd);
}
if (const Arg *A = Args.getLastArg(options::OPT_offload_host_only,
options::OPT_offload_device_only,
options::OPT_offload_host_device)) {
if (A->getOption().matches(options::OPT_offload_host_only))
Offload = OffloadHost;
else if (A->getOption().matches(options::OPT_offload_device_only))
Offload = OffloadDevice;
else
Offload = OffloadHostDevice;
}
setLTOMode(Args);
// Process -fembed-bitcode= flags.
if (Arg *A = Args.getLastArg(options::OPT_fembed_bitcode_EQ)) {
StringRef Name = A->getValue();
unsigned Model = llvm::StringSwitch<unsigned>(Name)
.Case("off", EmbedNone)
.Case("all", EmbedBitcode)
.Case("bitcode", EmbedBitcode)
.Case("marker", EmbedMarker)
.Default(~0U);
if (Model == ~0U) {
Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args)
<< Name;
} else
BitcodeEmbed = static_cast<BitcodeEmbedMode>(Model);
}
// Remove existing compilation database so that each job can append to it.
if (Arg *A = Args.getLastArg(options::OPT_MJ))
llvm::sys::fs::remove(A->getValue());
// Setting up the jobs for some precompile cases depends on whether we are
// treating them as PCH, implicit modules or C++20 ones.
// TODO: inferring the mode like this seems fragile (it meets the objective
// of not requiring anything new for operation, however).
const Arg *Std = Args.getLastArg(options::OPT_std_EQ);
ModulesModeCXX20 =
!Args.hasArg(options::OPT_fmodules) && Std &&
(Std->containsValue("c++20") || Std->containsValue("c++2a") ||
Std->containsValue("c++23") || Std->containsValue("c++2b") ||
Std->containsValue("c++26") || Std->containsValue("c++2c") ||
Std->containsValue("c++latest"));
// Process -fmodule-header{=} flags.
if (Arg *A = Args.getLastArg(options::OPT_fmodule_header_EQ,
options::OPT_fmodule_header)) {
// These flags force C++20 handling of headers.
ModulesModeCXX20 = true;
if (A->getOption().matches(options::OPT_fmodule_header))
CXX20HeaderType = HeaderMode_Default;
else {
StringRef ArgName = A->getValue();
unsigned Kind = llvm::StringSwitch<unsigned>(ArgName)
.Case("user", HeaderMode_User)
.Case("system", HeaderMode_System)
.Default(~0U);
if (Kind == ~0U) {
Diags.Report(diag::err_drv_invalid_value)
<< A->getAsString(Args) << ArgName;
} else
CXX20HeaderType = static_cast<ModuleHeaderMode>(Kind);
}
}
std::unique_ptr<llvm::opt::InputArgList> UArgs =
std::make_unique<InputArgList>(std::move(Args));
// Perform the default argument translations.
DerivedArgList *TranslatedArgs = TranslateInputArgs(*UArgs);
// Owned by the host.
const ToolChain &TC = getToolChain(
*UArgs, computeTargetTriple(*this, TargetTriple, *UArgs));
// Check if the environment version is valid except wasm case.
llvm::Triple Triple = TC.getTriple();
if (!Triple.isWasm()) {
StringRef TripleVersionName = Triple.getEnvironmentVersionString();
StringRef TripleObjectFormat =
Triple.getObjectFormatTypeName(Triple.getObjectFormat());
if (Triple.getEnvironmentVersion().empty() && TripleVersionName != "" &&
TripleVersionName != TripleObjectFormat) {
Diags.Report(diag::err_drv_triple_version_invalid)
<< TripleVersionName << TC.getTripleString();
ContainsError = true;
}
}
// Report warning when arm64EC option is overridden by specified target
if ((TC.getTriple().getArch() != llvm::Triple::aarch64 ||
TC.getTriple().getSubArch() != llvm::Triple::AArch64SubArch_arm64ec) &&
UArgs->hasArg(options::OPT__SLASH_arm64EC)) {
getDiags().Report(clang::diag::warn_target_override_arm64ec)
<< TC.getTriple().str();
}
// A common user mistake is specifying a target of aarch64-none-eabi or
// arm-none-elf whereas the correct names are aarch64-none-elf &
// arm-none-eabi. Detect these cases and issue a warning.
if (TC.getTriple().getOS() == llvm::Triple::UnknownOS &&
TC.getTriple().getVendor() == llvm::Triple::UnknownVendor) {
switch (TC.getTriple().getArch()) {
case llvm::Triple::arm:
case llvm::Triple::armeb:
case llvm::Triple::thumb:
case llvm::Triple::thumbeb:
if (TC.getTriple().getEnvironmentName() == "elf") {
Diag(diag::warn_target_unrecognized_env)
<< TargetTriple
<< (TC.getTriple().getArchName().str() + "-none-eabi");
}
break;
case llvm::Triple::aarch64:
case llvm::Triple::aarch64_be:
case llvm::Triple::aarch64_32:
if (TC.getTriple().getEnvironmentName().starts_with("eabi")) {
Diag(diag::warn_target_unrecognized_env)
<< TargetTriple
<< (TC.getTriple().getArchName().str() + "-none-elf");
}
break;
default:
break;
}
}
// The compilation takes ownership of Args.
Compilation *C = new Compilation(*this, TC, UArgs.release(), TranslatedArgs,
ContainsError);
if (!HandleImmediateArgs(*C))
return C;
// Construct the list of inputs.
InputList Inputs;
BuildInputs(C->getDefaultToolChain(), *TranslatedArgs, Inputs);
// Populate the tool chains for the offloading devices, if any.
CreateOffloadingDeviceToolChains(*C, Inputs);
// Construct the list of abstract actions to perform for this compilation. On
// MachO targets this uses the driver-driver and universal actions.
if (TC.getTriple().isOSBinFormatMachO())
BuildUniversalActions(*C, C->getDefaultToolChain(), Inputs);
else
BuildActions(*C, C->getArgs(), Inputs, C->getActions());
if (CCCPrintPhases) {
PrintActions(*C);
return C;
}
BuildJobs(*C);
return C;
} | subq $0x1378, %rsp # imm = 0x1378
movq %rsi, 0x1360(%rsp)
movq %rdx, 0x1368(%rsp)
movq %rdi, 0x1358(%rsp)
movq 0x1358(%rsp), %rax
movq %rax, 0x170(%rsp)
leaq 0x1340(%rsp), %rdi
leaq 0x74cdd40(%rip), %rsi # 0x7ebc6ee
callq 0x9e4b30
movq 0x170(%rsp), %rsi
addq $0x70, %rsi
leaq 0x1320(%rsp), %rdi
callq 0x7eaca0
leaq 0x1360(%rsp), %rdi
movl $0x1, %esi
callq 0x9da860
movq %rax, 0x1310(%rsp)
movq %rdx, 0x1318(%rsp)
movq 0x1320(%rsp), %rdi
movq 0x1328(%rsp), %rsi
movq 0x1310(%rsp), %rdx
movq 0x1318(%rsp), %rcx
callq 0x9f1130
movq %rax, 0x1330(%rsp)
movq %rdx, 0x1338(%rsp)
leaq 0x1330(%rsp), %rdi
callq 0x7ed530
testb $0x1, %al
jne 0x9eea71
movq 0x170(%rsp), %rdi
movq 0x1330(%rsp), %rax
movq %rax, 0x1300(%rsp)
movq 0x1338(%rsp), %rax
movq %rax, 0x1308(%rsp)
movq 0x1300(%rsp), %rsi
movq 0x1308(%rsp), %rdx
callq 0x9e3840
leaq 0x1360(%rsp), %rdi
movl $0x1, %esi
callq 0x9da860
movq 0x170(%rsp), %rsi
movq %rax, 0x1180(%rsp)
movq %rdx, 0x1188(%rsp)
movq 0x1180(%rsp), %rdx
movq 0x1188(%rsp), %rcx
leaq 0x1190(%rsp), %rdi
movl $0x1, %r8d
leaq 0x12ff(%rsp), %r9
callq 0x9e3de0
leaq 0x12f0(%rsp), %rdi
leaq 0x1190(%rsp), %rsi
callq 0x9ec0c0
movq 0x170(%rsp), %rdi
addq $0x460, %rdi # imm = 0x460
leaq 0x12f0(%rsp), %rsi
callq 0x9ec160
leaq 0x12f0(%rsp), %rdi
callq 0x7f4080
leaq 0x1190(%rsp), %rdi
callq 0x7ecd90
testb $0x1, 0x12ff(%rsp)
jne 0x9eeb31
movq 0x170(%rsp), %rdi
callq 0x9ec380
andb $0x1, %al
movb %al, 0x12ff(%rsp)
xorl %eax, %eax
testb $0x1, 0x12ff(%rsp)
movb %al, 0x16f(%rsp)
jne 0x9eeb66
movq 0x170(%rsp), %rdi
addq $0x458, %rdi # imm = 0x458
callq 0x9f13f0
cmpq $0x0, %rax
setne %al
movb %al, 0x16f(%rsp)
movb 0x16f(%rsp), %al
andb $0x1, %al
movb %al, 0x117f(%rsp)
testb $0x1, 0x117f(%rsp)
je 0x9eeb9e
movq 0x170(%rsp), %rdi
addq $0x458, %rdi # imm = 0x458
callq 0x9ec110
movq %rax, 0x160(%rsp)
jmp 0x9eebba
movq 0x170(%rsp), %rdi
addq $0x460, %rdi # imm = 0x460
callq 0x9ec110
movq %rax, 0x160(%rsp)
movq 0x160(%rsp), %rsi
leaq 0x1018(%rsp), %rdi
callq 0x9f1400
testb $0x1, 0x117f(%rsp)
je 0x9eed93
movq 0x170(%rsp), %rdi
addq $0x460, %rdi # imm = 0x460
callq 0x9ec110
movq %rax, 0x1010(%rsp)
movq 0x1010(%rsp), %rsi
leaq 0xff8(%rsp), %rdi
callq 0x82a0b0
movq 0x1010(%rsp), %rsi
leaq 0xfe0(%rsp), %rdi
callq 0x82a170
movq 0xff8(%rsp), %rax
movq %rax, 0xfc8(%rsp)
movq 0x1000(%rsp), %rax
movq %rax, 0xfd0(%rsp)
movq 0x1008(%rsp), %rax
movq %rax, 0xfd8(%rsp)
movq 0xfe0(%rsp), %rax
movq %rax, 0xfb0(%rsp)
movq 0xfe8(%rsp), %rax
movq %rax, 0xfb8(%rsp)
movq 0xff0(%rsp), %rax
movq %rax, 0xfc0(%rsp)
leaq 0xfc8(%rsp), %rcx
leaq 0xfb0(%rsp), %rax
movq (%rcx), %rdx
movq %rdx, (%rsp)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
callq 0x82a230
testb $0x1, %al
jne 0x9eecd4
jmp 0x9eed91
leaq 0xff8(%rsp), %rdi
callq 0x82a2c0
movq (%rax), %rax
movq %rax, 0xfa8(%rsp)
movq 0xfa8(%rsp), %rdi
callq 0x7ee280
movq %rax, 0x158(%rsp)
leaq 0xfa4(%rsp), %rdi
movl $0xe5, %esi
callq 0x7eba60
movq 0x158(%rsp), %rdi
movl 0xfa4(%rsp), %esi
callq 0x82f0e0
testb $0x1, %al
jne 0x9eed2d
jmp 0x9eed2f
jmp 0x9eed7f
movq 0xfa8(%rsp), %rdi
callq 0x9ec190
movq %rax, 0xf98(%rsp)
movq 0xf98(%rsp), %rax
cmpq 0xfa8(%rsp), %rax
jne 0x9eed62
movq $0x0, 0xf98(%rsp)
movq 0xfa8(%rsp), %rsi
movq 0xf98(%rsp), %rdx
leaq 0x1018(%rsp), %rdi
callq 0x9ec1d0
leaq 0xff8(%rsp), %rdi
callq 0x82a2d0
jmp 0x9eec23
jmp 0x9eed93
movq 0x170(%rsp), %rdi
callq 0x9df4e0
testb $0x1, %al
jne 0x9eeda9
jmp 0x9ef0f2
testb $0x1, 0x12ff(%rsp)
jne 0x9ef0f2
leaq 0xf08(%rsp), %rdi
callq 0x828980
leaq 0xed0(%rsp), %rdi
leaq 0x1018(%rsp), %rsi
movl $0xcc, %edx
callq 0x9e2820
leaq 0xed0(%rsp), %rax
movq %rax, 0xf00(%rsp)
movq 0xf00(%rsp), %rsi
leaq 0xeb8(%rsp), %rdi
callq 0x7ec890
movq 0xf00(%rsp), %rsi
leaq 0xea0(%rsp), %rdi
callq 0x7ec8c0
movq 0xeb8(%rsp), %rax
movq %rax, 0xe88(%rsp)
movq 0xec0(%rsp), %rax
movq %rax, 0xe90(%rsp)
movq 0xec8(%rsp), %rax
movq %rax, 0xe98(%rsp)
movq 0xea0(%rsp), %rax
movq %rax, 0xe70(%rsp)
movq 0xea8(%rsp), %rax
movq %rax, 0xe78(%rsp)
movq 0xeb0(%rsp), %rax
movq %rax, 0xe80(%rsp)
leaq 0xe88(%rsp), %rcx
leaq 0xe70(%rsp), %rax
movq (%rcx), %rdx
movq %rdx, (%rsp)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
callq 0x7ec8f0
testb $0x1, %al
jne 0x9eeec6
jmp 0x9eef1c
leaq 0xeb8(%rsp), %rdi
callq 0x7ec980
movq (%rax), %rax
movq %rax, 0xe68(%rsp)
movq 0xe68(%rsp), %rdi
callq 0x7ed2f0
movq 0xe68(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq %rax, %rsi
leaq 0xf08(%rsp), %rdi
callq 0x809410
leaq 0xeb8(%rsp), %rdi
callq 0x7eca10
jmp 0x9eee18
leaq 0xf08(%rsp), %rdi
callq 0x87e020
testb $0x1, %al
jne 0x9ef0e5
leaq 0xcf0(%rsp), %rdi
leaq 0xf08(%rsp), %rsi
callq 0x7eb3d0
movq 0x170(%rsp), %rsi
movq 0xcf0(%rsp), %rdx
movq 0xcf8(%rsp), %rcx
leaq 0xd00(%rsp), %rdi
xorl %r8d, %r8d
leaq 0x12ff(%rsp), %r9
callq 0x9e3de0
leaq 0xe60(%rsp), %rdi
leaq 0xd00(%rsp), %rsi
callq 0x9ec0c0
leaq 0xd00(%rsp), %rdi
callq 0x7ecd90
testb $0x1, 0x12ff(%rsp)
jne 0x9ef0d8
leaq 0xe60(%rsp), %rdi
callq 0x9ec110
movq %rax, 0xce8(%rsp)
movq 0xce8(%rsp), %rsi
leaq 0xcd0(%rsp), %rdi
callq 0x82a0b0
movq 0xce8(%rsp), %rsi
leaq 0xcb8(%rsp), %rdi
callq 0x82a170
movq 0xcd0(%rsp), %rax
movq %rax, 0xca0(%rsp)
movq 0xcd8(%rsp), %rax
movq %rax, 0xca8(%rsp)
movq 0xce0(%rsp), %rax
movq %rax, 0xcb0(%rsp)
movq 0xcb8(%rsp), %rax
movq %rax, 0xc88(%rsp)
movq 0xcc0(%rsp), %rax
movq %rax, 0xc90(%rsp)
movq 0xcc8(%rsp), %rax
movq %rax, 0xc98(%rsp)
leaq 0xca0(%rsp), %rcx
leaq 0xc88(%rsp), %rax
movq (%rcx), %rdx
movq %rdx, (%rsp)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
callq 0x82a230
testb $0x1, %al
jne 0x9ef093
jmp 0x9ef0d6
leaq 0xcd0(%rsp), %rdi
callq 0x82a2c0
movq (%rax), %rax
movq %rax, 0xc80(%rsp)
movq 0xc80(%rsp), %rsi
leaq 0x1018(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x9ec1d0
leaq 0xcd0(%rsp), %rdi
callq 0x82a2d0
jmp 0x9eefe5
jmp 0x9ef0d8
leaq 0xe60(%rsp), %rdi
callq 0x7f4080
leaq 0xf08(%rsp), %rdi
callq 0x7f0160
leaq 0x1018(%rsp), %rdi
movl $0xceb, %esi # imm = 0xCEB
callq 0x9e26c0
movq %rax, 0xc78(%rsp)
cmpq $0x0, 0xc78(%rsp)
je 0x9ef1e0
movq 0x170(%rsp), %rdi
addq $0x8, %rdi
callq 0x899560
movq %rax, 0x150(%rsp)
movq 0xc78(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq %rax, %rsi
leaq 0xc40(%rsp), %rdi
callq 0x7f1850
movq 0x150(%rsp), %rdi
movq (%rdi), %rax
leaq 0xc40(%rsp), %rsi
callq *0x40(%rax)
movl %eax, 0xc68(%rsp)
movq %rdx, 0xc70(%rsp)
leaq 0xc68(%rsp), %rdi
callq 0x7f5160
testb $0x1, %al
jne 0x9ef18b
jmp 0x9ef1de
movq 0x170(%rsp), %rsi
leaq 0xc20(%rsp), %rdi
movl $0x1d4, %edx # imm = 0x1D4
callq 0x9df2d0
movq 0xc78(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq %rax, 0xc18(%rsp)
leaq 0xc20(%rsp), %rdi
leaq 0xc18(%rsp), %rsi
callq 0x9e4c20
leaq 0xc20(%rsp), %rdi
callq 0x949780
jmp 0x9ef1e0
movq 0x170(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x148(%rsp)
leaq 0xc14(%rsp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x73aa90
leaq 0xc14(%rsp), %rdi
callq 0x9485e0
movq 0x148(%rsp), %rdi
movl 0xc14(%rsp), %edx
movl $0x25f, %esi # imm = 0x25F
callq 0x9f1490
testb $0x1, %al
jne 0x9ef38e
leaq 0xbec(%rsp), %rdi
movl $0x5, %esi
callq 0x7eba60
movl 0xbec(%rsp), %edx
leaq 0xbf0(%rsp), %rdi
leaq 0x1018(%rsp), %rsi
callq 0x828890
leaq 0xbf0(%rsp), %rax
movq %rax, 0xc08(%rsp)
movq 0xc08(%rsp), %rdi
callq 0x7ec290
movq %rax, 0xbe0(%rsp)
movq 0xc08(%rsp), %rdi
callq 0x7ec2c0
movq %rax, 0xbd8(%rsp)
leaq 0xbe0(%rsp), %rdi
leaq 0xbd8(%rsp), %rsi
callq 0x7ec2f0
testb $0x1, %al
jne 0x9ef2c8
leaq 0xbf0(%rsp), %rdi
callq 0x7e5cf0
jmp 0x9ef38c
leaq 0xbe0(%rsp), %rdi
callq 0x7ec330
movq %rax, %rsi
leaq 0xbb8(%rsp), %rdi
callq 0x73a040
movq 0x170(%rsp), %rdi
addq $0x8, %rdi
callq 0x899560
movq %rax, 0x140(%rsp)
leaq 0xb90(%rsp), %rdi
leaq 0xbb8(%rsp), %rsi
callq 0x7fcea0
movq 0x140(%rsp), %rdi
movq (%rdi), %rax
leaq 0xb90(%rsp), %rsi
callq *0x58(%rax)
xorb $-0x1, %al
testb $0x1, %al
jne 0x9ef331
jmp 0x9ef36d
movq 0x170(%rsp), %rsi
leaq 0xb70(%rsp), %rdi
movl $0x25f, %edx # imm = 0x25F
callq 0x9df2d0
leaq 0xb70(%rsp), %rdi
leaq 0xbb8(%rsp), %rsi
callq 0x949720
leaq 0xb70(%rsp), %rdi
callq 0x949780
leaq 0xbb8(%rsp), %rdi
callq 0x73b5d0
leaq 0xbe0(%rsp), %rdi
callq 0x7ec5f0
jmp 0x9ef29d
jmp 0x9ef38e
leaq 0xb68(%rsp), %rdi
movl $0xab, %esi
callq 0x7eba60
movl 0xb68(%rsp), %esi
leaq 0x1018(%rsp), %rdi
callq 0x829bc0
leaq 0xb64(%rsp), %rdi
movl $0xb19, %esi # imm = 0xB19
callq 0x7eba60
movl 0xb64(%rsp), %esi
leaq 0x1018(%rsp), %rdi
callq 0x829bc0
leaq 0xb60(%rsp), %rdi
movl $0x358, %esi # imm = 0x358
callq 0x7eba60
movl 0xb60(%rsp), %esi
leaq 0x1018(%rsp), %rdi
callq 0x829bc0
leaq 0xb5c(%rsp), %rdi
movl $0x484, %esi # imm = 0x484
callq 0x7eba60
movl 0xb5c(%rsp), %esi
leaq 0x1018(%rsp), %rdi
callq 0x829bc0
leaq 0xb58(%rsp), %rdi
movl $0xbaf, %esi # imm = 0xBAF
callq 0x7eba60
movl 0xb58(%rsp), %esi
leaq 0x1018(%rsp), %rdi
callq 0x829bc0
leaq 0x1018(%rsp), %rdi
movl $0xb5, %esi
callq 0x9df320
andb $0x1, %al
movb %al, 0xb6f(%rsp)
leaq 0x1018(%rsp), %rdi
movl $0xb4, %esi
callq 0x9df320
movb %al, %cl
movq 0x170(%rsp), %rax
andb $0x1, %cl
movzbl %cl, %ecx
movb %cl, %dl
movb 0x350(%rax), %cl
andb $0x1, %dl
andb $-0x2, %cl
orb %dl, %cl
movb %cl, 0x350(%rax)
leaq 0x1018(%rsp), %rdi
movl $0xb1, %esi
callq 0x9e26c0
movq %rax, 0xb50(%rsp)
cmpq $0x0, 0xb50(%rsp)
je 0x9ef4ea
movq 0xb50(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq 0x170(%rsp), %rdi
movq %rax, %rsi
addq $0x3b8, %rdi # imm = 0x3B8
callq 0x73a0b0
leaq 0x1018(%rsp), %rdi
movl $0x61b, %esi # imm = 0x61B
callq 0x9e26c0
movq %rax, 0xb48(%rsp)
cmpq $0x0, 0xb48(%rsp)
je 0x9ef54f
movq 0x170(%rsp), %rax
movb 0x380(%rax), %cl
andb $-0x5, %cl
orb $0x4, %cl
movb %cl, 0x380(%rax)
movq 0xb48(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq 0x170(%rsp), %rdi
movq %rax, %rsi
addq $0x2b0, %rdi # imm = 0x2B0
callq 0x73a0b0
leaq 0x1018(%rsp), %rdi
movl $0x61c, %esi # imm = 0x61C
callq 0x9df320
testb $0x1, %al
jne 0x9ef567
jmp 0x9ef581
movq 0x170(%rsp), %rax
movb 0x380(%rax), %cl
andb $-0x5, %cl
orb $0x4, %cl
movb %cl, 0x380(%rax)
movq 0x170(%rsp), %rdi
callq 0x9df4e0
testb $0x1, %al
jne 0x9ef597
jmp 0x9ef675
movq 0x170(%rsp), %rsi
addq $0x398, %rsi # imm = 0x398
leaq 0xae8(%rsp), %rdi
callq 0x7fcea0
leaq 0xb10(%rsp), %rdi
leaq 0xae8(%rsp), %rsi
callq 0x932470
leaq 0xb10(%rsp), %rdi
movl $0xe, %esi
callq 0x939d10
leaq 0xb10(%rsp), %rdi
movl $0x2, %esi
callq 0x939bb0
leaq 0xb10(%rsp), %rdi
movl $0x13, %esi
callq 0x93a000
leaq 0xb10(%rsp), %rdi
movl $0x1, %esi
callq 0x93a2f0
leaq 0x1018(%rsp), %rdi
movl $0x85, %esi
callq 0x9df320
testb $0x1, %al
jne 0x9ef628
jmp 0x9ef63f
leaq 0xb10(%rsp), %rdi
movl $0x3, %esi
movl $0x23, %edx
callq 0x939a10
leaq 0xb10(%rsp), %rdi
callq 0x92f640
movq 0x170(%rsp), %rdi
movq %rax, %rsi
addq $0x398, %rdi # imm = 0x398
callq 0x73a990
leaq 0xb10(%rsp), %rdi
callq 0x92f630
jmp 0x9efa44
movq 0x170(%rsp), %rdi
callq 0x9e6240
testb $0x1, %al
jne 0x9ef68b
jmp 0x9efa42
leaq 0x1018(%rsp), %rdi
movl $0xc80, %esi # imm = 0xC80
callq 0x9e26c0
movq %rax, 0xae0(%rsp)
cmpq $0x0, 0xae0(%rsp)
je 0x9efa19
movq 0xae0(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq %rax, %rsi
leaq 0xad0(%rsp), %rdi
callq 0x7eb0f0
movq 0xad0(%rsp), %rax
movq %rax, 0xa98(%rsp)
movq 0xad8(%rsp), %rax
movq %rax, 0xaa0(%rsp)
movq 0xa98(%rsp), %rsi
movq 0xaa0(%rsp), %rdx
leaq 0xaa8(%rsp), %rdi
callq 0xb47800
leaq 0xaa8(%rsp), %rdi
callq 0x8422f0
testb $0x1, %al
jne 0x9ef723
jmp 0x9ef749
leaq 0xaa8(%rsp), %rdi
callq 0x842310
movq 0x170(%rsp), %rdi
movq %rax, %rsi
addq $0x398, %rdi # imm = 0x398
callq 0x73a990
jmp 0x9ef785
movq 0x170(%rsp), %rsi
leaq 0xa78(%rsp), %rdi
movl $0x179, %edx # imm = 0x179
callq 0x9df2d0
leaq 0xa78(%rsp), %rdi
leaq 0xad0(%rsp), %rsi
callq 0x9d6350
leaq 0xa78(%rsp), %rdi
callq 0x949780
leaq 0xaa8(%rsp), %rdi
callq 0x842320
movq 0xae0(%rsp), %rdi
callq 0x7ed2f0
leaq 0x1018(%rsp), %rdi
movl $0xc40, %esi # imm = 0xC40
callq 0x9df320
testb $0x1, %al
jne 0x9ef7ba
jmp 0x9efa17
movq 0x170(%rsp), %rsi
addq $0x398, %rsi # imm = 0x398
leaq 0xa18(%rsp), %rdi
callq 0x7fcea0
leaq 0xa40(%rsp), %rdi
leaq 0xa18(%rsp), %rsi
callq 0x932470
leaq 0xa40(%rsp), %rdi
movl $0x33, %esi
xorl %edx, %edx
callq 0x939a10
leaq 0xa40(%rsp), %rdi
movl $0x28, %esi
callq 0x939d10
leaq 0x1018(%rsp), %rdi
movl $0x6cf, %esi # imm = 0x6CF
callq 0x9e26c0
movq %rax, 0xa10(%rsp)
cmpq $0x0, 0xa10(%rsp)
je 0x9ef9e6
movq 0xb29f47f(%rip), %rax # 0xbc8ecc0
movq %rax, 0x9c8(%rsp)
movq 0xb29f478(%rip), %rax # 0xbc8ecc8
movq %rax, 0x9d0(%rsp)
movq 0xb29f471(%rip), %rax # 0xbc8ecd0
movq %rax, 0x9d8(%rsp)
movq 0xb29f46a(%rip), %rax # 0xbc8ecd8
movq %rax, 0x9e0(%rsp)
leaq 0x9c8(%rsp), %rax
movq %rax, 0x9e8(%rsp)
movq $0x2, 0x9f0(%rsp)
movq 0x9e8(%rsp), %rsi
movq 0x9f0(%rsp), %rdx
leaq 0x9f8(%rsp), %rdi
callq 0x9f14e0
movq 0xa10(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq %rax, %rsi
leaq 0x9b8(%rsp), %rdi
callq 0x7eb0f0
movq 0x9b8(%rsp), %rsi
movq 0x9c0(%rsp), %rdx
leaq 0x9f8(%rsp), %rdi
callq 0x9bfa40
testb $0x1, %al
jne 0x9ef8f1
jmp 0x9ef932
movq 0xa10(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq %rax, %rsi
leaq 0x9a8(%rsp), %rdi
callq 0x7eb0f0
movq 0x9a8(%rsp), %rsi
movq 0x9b0(%rsp), %rdx
leaq 0xa40(%rsp), %rdi
callq 0x939d60
jmp 0x9ef9cc
movq 0x170(%rsp), %rsi
leaq 0x988(%rsp), %rdi
movl $0x190, %edx # imm = 0x190
callq 0x9df2d0
movq 0xa10(%rsp), %rsi
leaq 0x968(%rsp), %rdi
leaq 0x1018(%rsp), %rdx
callq 0x83b050
leaq 0x988(%rsp), %rdi
leaq 0x968(%rsp), %rsi
callq 0x973770
movq %rax, 0x138(%rsp)
movq 0xa10(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq 0x138(%rsp), %rdi
movq %rax, 0x960(%rsp)
leaq 0x960(%rsp), %rsi
callq 0x9e4c20
leaq 0x968(%rsp), %rdi
callq 0x73b5d0
leaq 0x988(%rsp), %rdi
callq 0x949780
movq 0xa10(%rsp), %rdi
callq 0x7ed2f0
leaq 0x9f8(%rsp), %rdi
callq 0x805e80
leaq 0xa40(%rsp), %rdi
callq 0x92f640
movq 0x170(%rsp), %rdi
movq %rax, %rsi
addq $0x398, %rdi # imm = 0x398
callq 0x73a990
leaq 0xa40(%rsp), %rdi
callq 0x92f630
jmp 0x9efa40
movq 0x170(%rsp), %rsi
leaq 0x940(%rsp), %rdi
movl $0x15f, %edx # imm = 0x15F
callq 0x9df2d0
leaq 0x940(%rsp), %rdi
callq 0x949780
jmp 0x9efa42
jmp 0x9efa44
leaq 0x1018(%rsp), %rdi
movl $0xc6a, %esi # imm = 0xC6A
callq 0x9e26c0
movq %rax, 0x938(%rsp)
cmpq $0x0, 0x938(%rsp)
je 0x9efa8f
movq 0x938(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq 0x170(%rsp), %rdi
movq %rax, %rsi
addq $0x398, %rdi # imm = 0x398
callq 0x73a0b0
leaq 0x1018(%rsp), %rdi
movl $0xb2, %esi
callq 0x9e26c0
movq %rax, 0x930(%rsp)
cmpq $0x0, 0x930(%rsp)
je 0x9efaeb
movq 0x930(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq 0x170(%rsp), %rdi
movq %rax, %rsi
addq $0x50, %rdi
callq 0x73a0b0
movq 0x170(%rsp), %rdi
movq %rax, %rsi
addq $0x50, %rdi
callq 0x73a990
leaq 0x8f8(%rsp), %rdi
leaq 0x1018(%rsp), %rsi
movl $0xa8, %edx
callq 0x9e2820
leaq 0x8f8(%rsp), %rax
movq %rax, 0x928(%rsp)
movq 0x928(%rsp), %rsi
leaq 0x8e0(%rsp), %rdi
callq 0x7ec890
movq 0x928(%rsp), %rsi
leaq 0x8c8(%rsp), %rdi
callq 0x7ec8c0
movq 0x8e0(%rsp), %rax
movq %rax, 0x8b0(%rsp)
movq 0x8e8(%rsp), %rax
movq %rax, 0x8b8(%rsp)
movq 0x8f0(%rsp), %rax
movq %rax, 0x8c0(%rsp)
movq 0x8c8(%rsp), %rax
movq %rax, 0x898(%rsp)
movq 0x8d0(%rsp), %rax
movq %rax, 0x8a0(%rsp)
movq 0x8d8(%rsp), %rax
movq %rax, 0x8a8(%rsp)
leaq 0x8b0(%rsp), %rcx
leaq 0x898(%rsp), %rax
movq (%rcx), %rdx
movq %rdx, (%rsp)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
callq 0x7ec8f0
testb $0x1, %al
jne 0x9efbf0
jmp 0x9efcad
leaq 0x8e0(%rsp), %rdi
callq 0x7ec980
movq (%rax), %rax
movq %rax, 0x890(%rsp)
movq 0x890(%rsp), %rdi
callq 0x7ed2f0
movq 0x170(%rsp), %rax
addq $0x140, %rax # imm = 0x140
movq %rax, 0x130(%rsp)
movq 0x890(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq %rax, 0x128(%rsp)
leaq 0x86f(%rsp), %rdi
callq 0x73a200
movq 0x128(%rsp), %rsi
leaq 0x870(%rsp), %rdi
leaq 0x86f(%rsp), %rdx
callq 0x7e5c40
movq 0x130(%rsp), %rdi
leaq 0x870(%rsp), %rsi
callq 0x865680
leaq 0x870(%rsp), %rdi
callq 0x73b5d0
leaq 0x86f(%rsp), %rdi
callq 0x73b530
leaq 0x8e0(%rsp), %rdi
callq 0x7eca10
jmp 0x9efb3f
leaq 0x830(%rsp), %rdi
leaq 0x74cca55(%rip), %rsi # 0x7ebc711
callq 0x7eb0f0
movq 0x830(%rsp), %rsi
movq 0x838(%rsp), %rdx
leaq 0x840(%rsp), %rdi
callq 0x8e59c0
leaq 0x840(%rsp), %rdi
callq 0x8422f0
testb $0x1, %al
jne 0x9efcf4
jmp 0x9efde9
leaq 0x840(%rsp), %rdi
callq 0x842310
movq %rax, %rsi
leaq 0x820(%rsp), %rdi
callq 0x7eaca0
leaq 0x820(%rsp), %rdi
callq 0x7ed530
xorb $-0x1, %al
testb $0x1, %al
jne 0x9efd29
jmp 0x9efde7
leaq 0x800(%rsp), %rdi
leaq 0x820(%rsp), %rsi
movl $0x3a, %edx
callq 0x8320f0
movq 0x170(%rsp), %rax
addq $0x140, %rax # imm = 0x140
movq %rax, 0x120(%rsp)
leaq 0x800(%rsp), %rax
movq %rax, 0x118(%rsp)
leaq 0x7df(%rsp), %rdi
callq 0x73a200
movq 0x118(%rsp), %rsi
leaq 0x7e0(%rsp), %rdi
leaq 0x7df(%rsp), %rdx
callq 0x7f6ce0
movq 0x120(%rsp), %rdi
leaq 0x7e0(%rsp), %rsi
callq 0x865680
leaq 0x7e0(%rsp), %rdi
callq 0x73b5d0
leaq 0x7df(%rsp), %rdi
callq 0x73b530
movq 0x810(%rsp), %rax
movq %rax, 0x820(%rsp)
movq 0x818(%rsp), %rax
movq %rax, 0x828(%rsp)
jmp 0x9efd11
jmp 0x9efde9
leaq 0x840(%rsp), %rdi
callq 0x842320
leaq 0x1018(%rsp), %rdi
movl $0xc5e, %esi # imm = 0xC5E
callq 0x9e26c0
movq %rax, 0x7d0(%rsp)
cmpq $0x0, 0x7d0(%rsp)
je 0x9efe41
movq 0x7d0(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq 0x170(%rsp), %rdi
movq %rax, %rsi
addq $0x1d0, %rdi # imm = 0x1D0
callq 0x73a0b0
leaq 0x1018(%rsp), %rdi
movl $0x13e, %esi # imm = 0x13E
callq 0x9e26c0
movq %rax, 0x7c8(%rsp)
cmpq $0x0, 0x7c8(%rsp)
je 0x9efe8c
movq 0x7c8(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq 0x170(%rsp), %rdi
movq %rax, %rsi
addq $0x1f0, %rdi # imm = 0x1F0
callq 0x73a0b0
leaq 0x1018(%rsp), %rdi
movl $0xc02, %esi # imm = 0xC02
callq 0x9e26c0
movq %rax, 0x7c0(%rsp)
cmpq $0x0, 0x7c0(%rsp)
je 0x9efed7
movq 0x7c0(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq 0x170(%rsp), %rdi
movq %rax, %rsi
addq $0xe0, %rdi
callq 0x73a0b0
leaq 0x1018(%rsp), %rdi
movl $0xc18, %esi # imm = 0xC18
callq 0x9e26c0
movq %rax, 0x7b8(%rsp)
cmpq $0x0, 0x7b8(%rsp)
je 0x9effca
movq 0x7b8(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq %rax, %rsi
leaq 0x790(%rsp), %rdi
callq 0x7eb0f0
movq 0x790(%rsp), %rsi
movq 0x798(%rsp), %rdx
leaq 0x7a0(%rsp), %rdi
callq 0x9f1590
leaq 0x780(%rsp), %rdi
leaq 0x74d96ab(%rip), %rsi # 0x7ec95f6
callq 0x7ec4b0
movq 0x780(%rsp), %rsi
movq 0x788(%rsp), %rdx
leaq 0x7a0(%rsp), %rdi
movl $0x1, %ecx
callq 0x9f15d0
movq %rax, 0x110(%rsp)
leaq 0x770(%rsp), %rdi
leaq 0x74fcc55(%rip), %rsi # 0x7eecbde
callq 0x7ec4b0
movq 0x110(%rsp), %rdi
movq 0x770(%rsp), %rsi
movq 0x778(%rsp), %rdx
movl $0x2, %ecx
callq 0x9f15d0
movq %rax, %rdi
movl $0x1, %esi
callq 0x9f1670
movl %eax, %ecx
movq 0x170(%rsp), %rax
movl %ecx, 0x14(%rax)
leaq 0x1018(%rsp), %rdi
movl $0xb82, %esi # imm = 0xB82
movl $0xb80, %edx # imm = 0xB80
movl $0xb81, %ecx # imm = 0xB81
callq 0x9f16c0
movq %rax, 0x768(%rsp)
cmpq $0x0, 0x768(%rsp)
je 0x9f00b4
movq 0x768(%rsp), %rdi
callq 0x7ee280
movq %rax, 0x108(%rsp)
leaq 0x764(%rsp), %rdi
movl $0xb82, %esi # imm = 0xB82
callq 0x7eba60
movq 0x108(%rsp), %rdi
movl 0x764(%rsp), %esi
callq 0x82f0e0
testb $0x1, %al
jne 0x9f003e
jmp 0x9f004f
movq 0x170(%rsp), %rax
movl $0x1, 0x1c(%rax)
jmp 0x9f00b2
movq 0x768(%rsp), %rdi
callq 0x7ee280
movq %rax, 0x100(%rsp)
leaq 0x760(%rsp), %rdi
movl $0xb80, %esi # imm = 0xB80
callq 0x7eba60
movq 0x100(%rsp), %rdi
movl 0x760(%rsp), %esi
callq 0x82f0e0
testb $0x1, %al
jne 0x9f0090
jmp 0x9f00a1
movq 0x170(%rsp), %rax
movl $0x2, 0x1c(%rax)
jmp 0x9f00b0
movq 0x170(%rsp), %rax
movl $0x0, 0x1c(%rax)
jmp 0x9f00b2
jmp 0x9f00b4
movq 0x170(%rsp), %rdi
leaq 0x1018(%rsp), %rsi
callq 0x9e6260
leaq 0x1018(%rsp), %rdi
movl $0x27c, %esi # imm = 0x27C
callq 0x9e26c0
movq %rax, 0x758(%rsp)
cmpq $0x0, 0x758(%rsp)
je 0x9f02e8
movq 0x758(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq %rax, %rsi
leaq 0x748(%rsp), %rdi
callq 0x7eb0f0
movq 0x748(%rsp), %rax
movq %rax, 0x718(%rsp)
movq 0x750(%rsp), %rax
movq %rax, 0x720(%rsp)
movq 0x718(%rsp), %rsi
movq 0x720(%rsp), %rdx
leaq 0x728(%rsp), %rdi
callq 0x96d230
leaq 0x708(%rsp), %rdi
leaq 0x8333cf4(%rip), %rsi # 0x8d23e51
callq 0x7ec4b0
movq 0x708(%rsp), %rsi
movq 0x710(%rsp), %rdx
leaq 0x728(%rsp), %rdi
xorl %ecx, %ecx
callq 0x96d270
movq %rax, 0xe8(%rsp)
leaq 0x6f8(%rsp), %rdi
leaq 0x75f737f(%rip), %rsi # 0x7fe7517
callq 0x7ec4b0
movq 0xe8(%rsp), %rdi
movq 0x6f8(%rsp), %rsi
movq 0x700(%rsp), %rdx
movl $0x2, %ecx
callq 0x96d270
movq %rax, 0xf0(%rsp)
leaq 0x6e8(%rsp), %rdi
leaq 0x74d4e16(%rip), %rsi # 0x7ec4fec
callq 0x929990
movq 0xf0(%rsp), %rdi
movq 0x6e8(%rsp), %rsi
movq 0x6f0(%rsp), %rdx
movl $0x2, %ecx
callq 0x96d270
movq %rax, 0xf8(%rsp)
leaq 0x6d8(%rsp), %rdi
leaq 0x9afd6b3(%rip), %rsi # 0xa4ed8c7
callq 0x8e68b0
movq 0xf8(%rsp), %rdi
movq 0x6d8(%rsp), %rsi
movq 0x6e0(%rsp), %rdx
movl $0x1, %ecx
callq 0x96d270
movq %rax, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x9f1870
movl %eax, 0x744(%rsp)
cmpl $-0x1, 0x744(%rsp)
jne 0x9f02d4
movq 0x170(%rsp), %rax
movq (%rax), %rsi
leaq 0x6b8(%rsp), %rdi
movl $0x190, %edx # imm = 0x190
callq 0x9496b0
movq 0x758(%rsp), %rsi
leaq 0x698(%rsp), %rdi
leaq 0x1018(%rsp), %rdx
callq 0x83b050
leaq 0x6b8(%rsp), %rdi
leaq 0x698(%rsp), %rsi
callq 0x973770
movq %rax, %rdi
leaq 0x748(%rsp), %rsi
callq 0x9d6350
leaq 0x698(%rsp), %rdi
callq 0x73b5d0
leaq 0x6b8(%rsp), %rdi
callq 0x949780
jmp 0x9f02e6
movq 0x170(%rsp), %rax
movl 0x744(%rsp), %ecx
movl %ecx, 0x18(%rax)
jmp 0x9f02e8
leaq 0x1018(%rsp), %rdi
movl $0x91b, %esi # imm = 0x91B
callq 0x9e26c0
movq %rax, 0x690(%rsp)
cmpq $0x0, 0x690(%rsp)
je 0x9f034d
movq 0x690(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq %rax, %rsi
leaq 0x668(%rsp), %rdi
callq 0x7f1850
leaq 0x668(%rsp), %rdi
movl $0x1, %esi
callq 0x8e12a0
movl %eax, 0x658(%rsp)
movq %rdx, 0x660(%rsp)
leaq 0x1018(%rsp), %rdi
movl $0xc54, %esi # imm = 0xC54
callq 0x9e26c0
movq %rax, 0x650(%rsp)
leaq 0x1018(%rsp), %rdi
movl $0x3b4, %esi # imm = 0x3B4
callq 0x9df320
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xe7(%rsp)
jne 0x9f05f5
xorl %eax, %eax
cmpq $0x0, 0x650(%rsp)
movb %al, 0xe7(%rsp)
je 0x9f05f5
movq 0x650(%rsp), %rax
movq %rax, 0xd8(%rsp)
leaq 0x640(%rsp), %rdi
leaq 0x74fc3f2(%rip), %rsi # 0x7eec7b6
callq 0x7eb0f0
movq 0xd8(%rsp), %rdi
movq 0x640(%rsp), %rsi
movq 0x648(%rsp), %rdx
callq 0x9e4cb0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0xe6(%rsp)
jne 0x9f05e7
movq 0x650(%rsp), %rax
movq %rax, 0xd0(%rsp)
leaq 0x630(%rsp), %rdi
leaq 0x74f51ac(%rip), %rsi # 0x7ee55c5
callq 0x7eb0f0
movq 0xd0(%rsp), %rdi
movq 0x630(%rsp), %rsi
movq 0x638(%rsp), %rdx
callq 0x9e4cb0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0xe6(%rsp)
jne 0x9f05e7
movq 0x650(%rsp), %rax
movq %rax, 0xc8(%rsp)
leaq 0x620(%rsp), %rdi
leaq 0x74cc2b1(%rip), %rsi # 0x7ebc71f
callq 0x7eb0f0
movq 0xc8(%rsp), %rdi
movq 0x620(%rsp), %rsi
movq 0x628(%rsp), %rdx
callq 0x9e4cb0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0xe6(%rsp)
jne 0x9f05e7
movq 0x650(%rsp), %rax
movq %rax, 0xc0(%rsp)
leaq 0x610(%rsp), %rdi
leaq 0x74cc262(%rip), %rsi # 0x7ebc725
callq 0x7eb0f0
movq 0xc0(%rsp), %rdi
movq 0x610(%rsp), %rsi
movq 0x618(%rsp), %rdx
callq 0x9e4cb0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0xe6(%rsp)
jne 0x9f05e7
movq 0x650(%rsp), %rax
movq %rax, 0xb8(%rsp)
leaq 0x600(%rsp), %rdi
leaq 0x74fc2a9(%rip), %rsi # 0x7eec7c1
callq 0x7eb0f0
movq 0xb8(%rsp), %rdi
movq 0x600(%rsp), %rsi
movq 0x608(%rsp), %rdx
callq 0x9e4cb0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0xe6(%rsp)
jne 0x9f05e7
movq 0x650(%rsp), %rax
movq %rax, 0xb0(%rsp)
leaq 0x5f0(%rsp), %rdi
leaq 0x74cc1be(%rip), %rsi # 0x7ebc72b
callq 0x7eb0f0
movq 0xb0(%rsp), %rdi
movq 0x5f0(%rsp), %rsi
movq 0x5f8(%rsp), %rdx
callq 0x9e4cb0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0xe6(%rsp)
jne 0x9f05e7
movq 0x650(%rsp), %rax
movq %rax, 0xa8(%rsp)
leaq 0x5e0(%rsp), %rdi
leaq 0x74cc173(%rip), %rsi # 0x7ebc731
callq 0x7eb0f0
movq 0xa8(%rsp), %rdi
movq 0x5e0(%rsp), %rsi
movq 0x5e8(%rsp), %rdx
callq 0x9e4cb0
movb %al, 0xe6(%rsp)
movb 0xe6(%rsp), %al
movb %al, 0xe7(%rsp)
movq 0x170(%rsp), %rax
movb 0xe7(%rsp), %cl
andb $0x1, %cl
movb %cl, 0x24(%rax)
leaq 0x1018(%rsp), %rdi
movl $0x395, %esi # imm = 0x395
movl $0x396, %edx # imm = 0x396
callq 0x9e50a0
movq %rax, 0x5d8(%rsp)
cmpq $0x0, 0x5d8(%rsp)
je 0x9f0818
movq 0x170(%rsp), %rax
movb $0x1, 0x24(%rax)
movq 0x5d8(%rsp), %rdi
callq 0x7ee280
movq %rax, 0xa0(%rsp)
leaq 0x5d4(%rsp), %rdi
movl $0x396, %esi # imm = 0x396
callq 0x7eba60
movq 0xa0(%rsp), %rdi
movl 0x5d4(%rsp), %esi
callq 0x82f0e0
testb $0x1, %al
jne 0x9f0685
jmp 0x9f0699
movq 0x170(%rsp), %rax
movl $0x1, 0x20(%rax)
jmp 0x9f0816
movq 0x5d8(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq %rax, %rsi
leaq 0x5c0(%rsp), %rdi
callq 0x7eb0f0
movq 0x5c0(%rsp), %rax
movq %rax, 0x590(%rsp)
movq 0x5c8(%rsp), %rax
movq %rax, 0x598(%rsp)
movq 0x590(%rsp), %rsi
movq 0x598(%rsp), %rdx
leaq 0x5a0(%rsp), %rdi
callq 0x96d230
leaq 0x580(%rsp), %rdi
leaq 0x7dc5133(%rip), %rsi # 0x87b5837
callq 0x7ec120
movq 0x580(%rsp), %rsi
movq 0x588(%rsp), %rdx
leaq 0x5a0(%rsp), %rdi
movl $0x2, %ecx
callq 0x96d270
movq %rax, 0x98(%rsp)
leaq 0x570(%rsp), %rdi
leaq 0x74fe1bc(%rip), %rsi # 0x7eee8fe
callq 0x8e68b0
movq 0x98(%rsp), %rdi
movq 0x570(%rsp), %rsi
movq 0x578(%rsp), %rdx
movl $0x3, %ecx
callq 0x96d270
movq %rax, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x9f1870
movl %eax, 0x5bc(%rsp)
cmpl $-0x1, 0x5bc(%rsp)
jne 0x9f0802
movq 0x170(%rsp), %rax
movq (%rax), %rsi
leaq 0x550(%rsp), %rdi
movl $0x190, %edx # imm = 0x190
callq 0x9496b0
movq 0x5d8(%rsp), %rsi
leaq 0x530(%rsp), %rdi
leaq 0x1018(%rsp), %rdx
callq 0x83b050
leaq 0x550(%rsp), %rdi
leaq 0x530(%rsp), %rsi
callq 0x973770
movq %rax, %rdi
leaq 0x5c0(%rsp), %rsi
callq 0x9d6350
leaq 0x530(%rsp), %rdi
callq 0x73b5d0
leaq 0x550(%rsp), %rdi
callq 0x949780
jmp 0x9f0814
movq 0x170(%rsp), %rax
movl 0x5bc(%rsp), %ecx
movl %ecx, 0x20(%rax)
jmp 0x9f0816
jmp 0x9f0818
leaq 0x528(%rsp), %rdi
leaq 0x1018(%rsp), %rsi
callq 0x9ec0c0
leaq 0x528(%rsp), %rdi
callq 0x9ec110
movq 0x170(%rsp), %rdi
movq %rax, %rsi
callq 0x9e5210
movq %rax, 0x520(%rsp)
leaq 0x528(%rsp), %rdi
callq 0x9ec110
movq 0x170(%rsp), %rsi
movq %rax, 0x88(%rsp)
addq $0x398, %rsi # imm = 0x398
leaq 0x4d0(%rsp), %rdi
callq 0x7eaca0
leaq 0x528(%rsp), %rdi
callq 0x9ec110
movq %rax, 0x80(%rsp)
leaq 0x4c0(%rsp), %rdi
leaq 0x7522392(%rip), %rsi # 0x7f12c39
callq 0x7eb0f0
movq 0x80(%rsp), %r8
movq 0x170(%rsp), %rsi
movq 0x4d0(%rsp), %rdx
movq 0x4d8(%rsp), %rcx
leaq 0x4e0(%rsp), %rdi
leaq 0x4c0(%rsp), %rax
movq (%rax), %r9
movq %r9, (%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
callq 0x9ed650
movq 0x170(%rsp), %rdi
movq 0x88(%rsp), %rsi
leaq 0x4e0(%rsp), %rdx
callq 0x9ea5e0
movq %rax, 0x90(%rsp)
leaq 0x4e0(%rsp), %rdi
callq 0x92f630
movq 0x90(%rsp), %rax
movq %rax, 0x518(%rsp)
movq 0x518(%rsp), %rdi
callq 0x9df070
movq %rax, %rsi
leaq 0x488(%rsp), %rdi
callq 0x93a7b0
leaq 0x488(%rsp), %rdi
callq 0x9f18c0
testb $0x1, %al
jne 0x9f0b42
leaq 0x488(%rsp), %rdi
callq 0x9389f0
movq %rax, 0x478(%rsp)
movq %rdx, 0x480(%rsp)
leaq 0x488(%rsp), %rdi
callq 0x938c30
movl %eax, %edi
callq 0x930f70
movq %rax, 0x468(%rsp)
movq %rdx, 0x470(%rsp)
leaq 0x488(%rsp), %rdi
callq 0x938940
movq %rax, 0x458(%rsp)
movq %rdx, 0x460(%rsp)
leaq 0x458(%rsp), %rdi
callq 0x93d3a0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x7f(%rsp)
jne 0x9f09e2
jmp 0x9f0ab3
movq 0x478(%rsp), %rax
movq %rax, 0x448(%rsp)
movq 0x480(%rsp), %rax
movq %rax, 0x450(%rsp)
leaq 0x438(%rsp), %rdi
leaq 0x7522228(%rip), %rsi # 0x7f12c39
callq 0x7eb0f0
movq 0x448(%rsp), %rdi
movq 0x450(%rsp), %rsi
movq 0x438(%rsp), %rdx
movq 0x440(%rsp), %rcx
callq 0x7f20f0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x7f(%rsp)
jne 0x9f0a4a
jmp 0x9f0ab3
movq 0x478(%rsp), %rax
movq %rax, 0x428(%rsp)
movq 0x480(%rsp), %rax
movq %rax, 0x430(%rsp)
movq 0x468(%rsp), %rax
movq %rax, 0x418(%rsp)
movq 0x470(%rsp), %rax
movq %rax, 0x420(%rsp)
movq 0x428(%rsp), %rdi
movq 0x430(%rsp), %rsi
movq 0x418(%rsp), %rdx
movq 0x420(%rsp), %rcx
callq 0x7f20f0
movb %al, 0x7f(%rsp)
movb 0x7f(%rsp), %al
testb $0x1, %al
jne 0x9f0ac0
jmp 0x9f0b40
movq 0x170(%rsp), %rax
movq (%rax), %rsi
leaq 0x3f8(%rsp), %rdi
movl $0x1ce, %edx # imm = 0x1CE
callq 0x9496b0
leaq 0x3f8(%rsp), %rdi
leaq 0x478(%rsp), %rsi
callq 0x9d6350
movq %rax, 0x70(%rsp)
movq 0x518(%rsp), %rsi
leaq 0x3d8(%rsp), %rdi
callq 0x9f1910
movq 0x70(%rsp), %rdi
leaq 0x3d8(%rsp), %rsi
callq 0x973770
leaq 0x3d8(%rsp), %rdi
callq 0x73b5d0
leaq 0x3f8(%rsp), %rdi
callq 0x949780
movb $0x1, 0x12ff(%rsp)
jmp 0x9f0b42
movq 0x518(%rsp), %rdi
callq 0x9df070
movq %rax, %rdi
callq 0x939300
cmpl $0x3, %eax
jne 0x9f0b76
movq 0x518(%rsp), %rdi
callq 0x9df070
movq %rax, %rdi
callq 0x939690
cmpl $0x23, %eax
je 0x9f0bea
leaq 0x528(%rsp), %rdi
callq 0x9ecbd0
movq %rax, %rdi
movl $0x85, %esi
callq 0x9df320
testb $0x1, %al
jne 0x9f0b96
jmp 0x9f0bea
movq 0x170(%rsp), %rdi
callq 0x9f1950
movq %rax, %rsi
leaq 0x3b8(%rsp), %rdi
movl $0x262, %edx # imm = 0x262
callq 0x9496b0
movq 0x518(%rsp), %rdi
callq 0x9df070
movq %rax, %rdi
callq 0x92f640
movq %rax, %rsi
leaq 0x3b8(%rsp), %rdi
callq 0x949720
leaq 0x3b8(%rsp), %rdi
callq 0x949780
movq 0x518(%rsp), %rdi
callq 0x9df070
movq %rax, %rdi
callq 0x92f6f0
cmpl $0x0, %eax
jne 0x9f0ed5
movq 0x518(%rsp), %rdi
callq 0x9df070
movq %rax, %rdi
callq 0x93ae10
cmpl $0x0, %eax
jne 0x9f0ed5
movq 0x518(%rsp), %rdi
callq 0x9df070
movq %rax, %rdi
callq 0x939300
movl %eax, %ecx
movl %ecx, %eax
decl %eax
movl %ecx, 0x6c(%rsp)
subl $0x2, %eax
jb 0x9f0c70
jmp 0x9f0c4c
movl 0x6c(%rsp), %eax
addl $-0x3, %eax
subl $0x3, %eax
jb 0x9f0da6
jmp 0x9f0c5e
movl 0x6c(%rsp), %eax
addl $-0x23, %eax
subl $0x1, %eax
ja 0x9f0ed1
jmp 0x9f0c70
movq 0x518(%rsp), %rdi
callq 0x9df070
movq %rax, %rdi
callq 0x938810
movq %rax, 0x3a8(%rsp)
movq %rdx, 0x3b0(%rsp)
leaq 0x398(%rsp), %rdi
leaq 0x74ffe72(%rip), %rsi # 0x7ef0b16
callq 0x7eb0f0
movq 0x3a8(%rsp), %rdi
movq 0x3b0(%rsp), %rsi
movq 0x398(%rsp), %rdx
movq 0x3a0(%rsp), %rcx
callq 0x7ed410
testb $0x1, %al
jne 0x9f0cd7
jmp 0x9f0da1
movq 0x170(%rsp), %rsi
leaq 0x378(%rsp), %rdi
movl $0xa1, %edx
callq 0x9df2d0
movq 0x170(%rsp), %rsi
addq $0x398, %rsi # imm = 0x398
leaq 0x378(%rsp), %rdi
callq 0x949720
movq %rax, 0x60(%rsp)
movq 0x518(%rsp), %rdi
callq 0x9df070
movq %rax, %rdi
callq 0x938690
movq %rax, 0x328(%rsp)
movq %rdx, 0x330(%rsp)
leaq 0x338(%rsp), %rdi
leaq 0x328(%rsp), %rsi
callq 0x81d6e0
leaq 0x358(%rsp), %rdi
leaq 0x338(%rsp), %rsi
leaq 0x74cb9d8(%rip), %rdx # 0x7ebc73b
callq 0x7fcec0
movq 0x60(%rsp), %rdi
leaq 0x358(%rsp), %rsi
callq 0x973770
leaq 0x358(%rsp), %rdi
callq 0x73b5d0
leaq 0x338(%rsp), %rdi
callq 0x73b5d0
leaq 0x378(%rsp), %rdi
callq 0x949780
jmp 0x9f0ed3
movq 0x518(%rsp), %rdi
callq 0x9df070
movq %rax, %rdi
callq 0x938810
movq %rax, 0x318(%rsp)
movq %rdx, 0x320(%rsp)
leaq 0x308(%rsp), %rdi
leaq 0x74cb967(%rip), %rsi # 0x7ebc741
callq 0x7eb0f0
movq 0x308(%rsp), %rsi
movq 0x310(%rsp), %rdx
leaq 0x318(%rsp), %rdi
callq 0x7f7120
testb $0x1, %al
jne 0x9f0e05
jmp 0x9f0ecf
movq 0x170(%rsp), %rsi
leaq 0x2e8(%rsp), %rdi
movl $0xa1, %edx
callq 0x9df2d0
movq 0x170(%rsp), %rsi
addq $0x398, %rsi # imm = 0x398
leaq 0x2e8(%rsp), %rdi
callq 0x949720
movq %rax, 0x58(%rsp)
movq 0x518(%rsp), %rdi
callq 0x9df070
movq %rax, %rdi
callq 0x938690
movq %rax, 0x298(%rsp)
movq %rdx, 0x2a0(%rsp)
leaq 0x2a8(%rsp), %rdi
leaq 0x298(%rsp), %rsi
callq 0x81d6e0
leaq 0x2c8(%rsp), %rdi
leaq 0x2a8(%rsp), %rsi
leaq 0x74cb8b5(%rip), %rdx # 0x7ebc746
callq 0x7fcec0
movq 0x58(%rsp), %rdi
leaq 0x2c8(%rsp), %rsi
callq 0x973770
leaq 0x2c8(%rsp), %rdi
callq 0x73b5d0
leaq 0x2a8(%rsp), %rdi
callq 0x73b5d0
leaq 0x2e8(%rsp), %rdi
callq 0x949780
jmp 0x9f0ed3
jmp 0x9f0ed3
jmp 0x9f0ed5
movl $0x210, %edi # imm = 0x210
callq 0x73b270
movq %rax, 0x50(%rsp)
movq 0x518(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x528(%rsp), %rdi
callq 0x9f1960
movq 0x48(%rsp), %rdx
movq 0x50(%rsp), %rdi
movq 0x170(%rsp), %rsi
movq %rax, %rcx
movq 0x520(%rsp), %r8
movb 0x12ff(%rsp), %al
andb $0x1, %al
movzbl %al, %r9d
callq 0x9de2b0
movq 0x50(%rsp), %rax
movq 0x170(%rsp), %rdi
movq %rax, 0x290(%rsp)
movq 0x290(%rsp), %rsi
callq 0x9f1970
testb $0x1, %al
jne 0x9f0f73
movq 0x290(%rsp), %rax
movq %rax, 0x1370(%rsp)
movl $0x1, 0x28c(%rsp)
jmp 0x9f10e5
leaq 0x178(%rsp), %rdi
callq 0x9f2f80
movq 0x290(%rsp), %rdi
callq 0x9f4180
movq 0x170(%rsp), %rdi
movq %rax, %rsi
movq 0x520(%rsp), %rdx
leaq 0x178(%rsp), %rcx
callq 0x9f2fa0
movq 0x170(%rsp), %rdi
movq 0x290(%rsp), %rsi
leaq 0x178(%rsp), %rdx
callq 0x9e6a00
movq 0x518(%rsp), %rdi
callq 0x9df070
movq %rax, %rdi
callq 0x9470e0
testb $0x1, %al
jne 0x9f0fe5
jmp 0x9f101e
movq 0x290(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x290(%rsp), %rdi
callq 0x9f4180
movq 0x170(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq %rax, %rdx
leaq 0x178(%rsp), %rcx
callq 0x9f4190
jmp 0x9f106c
movq 0x290(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x290(%rsp), %rdi
callq 0x9e9cd0
movq %rax, 0x38(%rsp)
movq 0x290(%rsp), %rdi
callq 0x9f5e20
movq 0x170(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq %rax, %r8
leaq 0x178(%rsp), %rcx
callq 0x9f4a30
testb $0x1, 0xb6f(%rsp)
je 0x9f10a8
movq 0x170(%rsp), %rdi
movq 0x290(%rsp), %rsi
callq 0x9f5e30
movq 0x290(%rsp), %rax
movq %rax, 0x1370(%rsp)
movl $0x1, 0x28c(%rsp)
jmp 0x9f10d8
movq 0x170(%rsp), %rdi
movq 0x290(%rsp), %rsi
callq 0x9f5f30
movq 0x290(%rsp), %rax
movq %rax, 0x1370(%rsp)
movl $0x1, 0x28c(%rsp)
leaq 0x178(%rsp), %rdi
callq 0x9f6c30
leaq 0x488(%rsp), %rdi
callq 0x92f630
leaq 0x528(%rsp), %rdi
callq 0x7f4080
leaq 0x1018(%rsp), %rdi
callq 0x7ecd90
leaq 0x1340(%rsp), %rdi
callq 0x87aa80
movq 0x1370(%rsp), %rax
addq $0x1378, %rsp # imm = 0x1378
retq
nopl (%rax)
| /Driver/Driver.cpp |
clang::driver::Driver::BuildJobs(clang::driver::Compilation&) const | void Driver::BuildJobs(Compilation &C) const {
llvm::PrettyStackTraceString CrashInfo("Building compilation jobs");
Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o);
// It is an error to provide a -o option if we are making multiple output
// files. There are exceptions:
//
// IfsMergeJob: when generating interface stubs enabled we want to be able to
// generate the stub file at the same time that we generate the real
// library/a.out. So when a .o, .so, etc are the output, with clang interface
// stubs there will also be a .ifs and .ifso at the same location.
//
// CompileJob of type TY_IFS_CPP: when generating interface stubs is enabled
// and -c is passed, we still want to be able to generate a .ifs file while
// we are also generating .o files. So we allow more than one output file in
// this case as well.
//
// OffloadClass of type TY_Nothing: device-only output will place many outputs
// into a single offloading action. We should count all inputs to the action
// as outputs. Also ignore device-only outputs if we're compiling with
// -fsyntax-only.
if (FinalOutput) {
unsigned NumOutputs = 0;
unsigned NumIfsOutputs = 0;
for (const Action *A : C.getActions()) {
if (A->getType() != types::TY_Nothing &&
A->getType() != types::TY_DX_CONTAINER &&
!(A->getKind() == Action::IfsMergeJobClass ||
(A->getType() == clang::driver::types::TY_IFS_CPP &&
A->getKind() == clang::driver::Action::CompileJobClass &&
0 == NumIfsOutputs++) ||
(A->getKind() == Action::BindArchClass && A->getInputs().size() &&
A->getInputs().front()->getKind() == Action::IfsMergeJobClass)))
++NumOutputs;
else if (A->getKind() == Action::OffloadClass &&
A->getType() == types::TY_Nothing &&
!C.getArgs().hasArg(options::OPT_fsyntax_only))
NumOutputs += A->size();
}
if (NumOutputs > 1) {
Diag(clang::diag::err_drv_output_argument_with_multiple_files);
FinalOutput = nullptr;
}
}
const llvm::Triple &RawTriple = C.getDefaultToolChain().getTriple();
// Collect the list of architectures.
llvm::StringSet<> ArchNames;
if (RawTriple.isOSBinFormatMachO())
for (const Arg *A : C.getArgs())
if (A->getOption().matches(options::OPT_arch))
ArchNames.insert(A->getValue());
// Set of (Action, canonical ToolChain triple) pairs we've built jobs for.
std::map<std::pair<const Action *, std::string>, InputInfoList> CachedResults;
for (Action *A : C.getActions()) {
// If we are linking an image for multiple archs then the linker wants
// -arch_multiple and -final_output <final image name>. Unfortunately, this
// doesn't fit in cleanly because we have to pass this information down.
//
// FIXME: This is a hack; find a cleaner way to integrate this into the
// process.
const char *LinkingOutput = nullptr;
if (isa<LipoJobAction>(A)) {
if (FinalOutput)
LinkingOutput = FinalOutput->getValue();
else
LinkingOutput = getDefaultImageName();
}
BuildJobsForAction(C, A, &C.getDefaultToolChain(),
/*BoundArch*/ StringRef(),
/*AtTopLevel*/ true,
/*MultipleArchs*/ ArchNames.size() > 1,
/*LinkingOutput*/ LinkingOutput, CachedResults,
/*TargetDeviceOffloadKind*/ Action::OFK_None);
}
// If we have more than one job, then disable integrated-cc1 for now. Do this
// also when we need to report process execution statistics.
if (C.getJobs().size() > 1 || CCPrintProcessStats)
for (auto &J : C.getJobs())
J.InProcess = false;
if (CCPrintProcessStats) {
C.setPostCallback([=](const Command &Cmd, int Res) {
std::optional<llvm::sys::ProcessStatistics> ProcStat =
Cmd.getProcessStatistics();
if (!ProcStat)
return;
const char *LinkingOutput = nullptr;
if (FinalOutput)
LinkingOutput = FinalOutput->getValue();
else if (!Cmd.getOutputFilenames().empty())
LinkingOutput = Cmd.getOutputFilenames().front().c_str();
else
LinkingOutput = getDefaultImageName();
if (CCPrintStatReportFilename.empty()) {
using namespace llvm;
// Human readable output.
outs() << sys::path::filename(Cmd.getExecutable()) << ": "
<< "output=" << LinkingOutput;
outs() << ", total="
<< format("%.3f", ProcStat->TotalTime.count() / 1000.) << " ms"
<< ", user="
<< format("%.3f", ProcStat->UserTime.count() / 1000.) << " ms"
<< ", mem=" << ProcStat->PeakMemory << " Kb\n";
} else {
// CSV format.
std::string Buffer;
llvm::raw_string_ostream Out(Buffer);
llvm::sys::printArg(Out, llvm::sys::path::filename(Cmd.getExecutable()),
/*Quote*/ true);
Out << ',';
llvm::sys::printArg(Out, LinkingOutput, true);
Out << ',' << ProcStat->TotalTime.count() << ','
<< ProcStat->UserTime.count() << ',' << ProcStat->PeakMemory
<< '\n';
Out.flush();
std::error_code EC;
llvm::raw_fd_ostream OS(CCPrintStatReportFilename, EC,
llvm::sys::fs::OF_Append |
llvm::sys::fs::OF_Text);
if (EC)
return;
auto L = OS.lock();
if (!L) {
llvm::errs() << "ERROR: Cannot lock file "
<< CCPrintStatReportFilename << ": "
<< toString(L.takeError()) << "\n";
return;
}
OS << Buffer;
OS.flush();
}
});
}
// If the user passed -Qunused-arguments or there were errors, don't warn
// about any unused arguments.
if (Diags.hasErrorOccurred() ||
C.getArgs().hasArg(options::OPT_Qunused_arguments))
return;
// Claim -fdriver-only here.
(void)C.getArgs().hasArg(options::OPT_fdriver_only);
// Claim -### here.
(void)C.getArgs().hasArg(options::OPT__HASH_HASH_HASH);
// Claim --driver-mode, --rsp-quoting, it was handled earlier.
(void)C.getArgs().hasArg(options::OPT_driver_mode);
(void)C.getArgs().hasArg(options::OPT_rsp_quoting);
bool HasAssembleJob = llvm::any_of(C.getJobs(), [](auto &J) {
// Match ClangAs and other derived assemblers of Tool. ClangAs uses a
// longer ShortName "clang integrated assembler" while other assemblers just
// use "assembler".
return strstr(J.getCreator().getShortName(), "assembler");
});
for (Arg *A : C.getArgs()) {
// FIXME: It would be nice to be able to send the argument to the
// DiagnosticsEngine, so that extra values, position, and so on could be
// printed.
if (!A->isClaimed()) {
if (A->getOption().hasFlag(options::NoArgumentUnused))
continue;
// Suppress the warning automatically if this is just a flag, and it is an
// instance of an argument we already claimed.
const Option &Opt = A->getOption();
if (Opt.getKind() == Option::FlagClass) {
bool DuplicateClaimed = false;
for (const Arg *AA : C.getArgs().filtered(&Opt)) {
if (AA->isClaimed()) {
DuplicateClaimed = true;
break;
}
}
if (DuplicateClaimed)
continue;
}
// In clang-cl, don't mention unknown arguments here since they have
// already been warned about.
if (!IsCLMode() || !A->getOption().matches(options::OPT_UNKNOWN)) {
if (A->getOption().hasFlag(options::TargetSpecific) &&
!A->isIgnoredTargetSpecific() && !HasAssembleJob &&
// When for example -### or -v is used
// without a file, target specific options are not
// consumed/validated.
// Instead emitting an error emit a warning instead.
!C.getActions().empty()) {
Diag(diag::err_drv_unsupported_opt_for_target)
<< A->getSpelling() << getTargetTriple();
} else {
Diag(clang::diag::warn_drv_unused_argument)
<< A->getAsString(C.getArgs());
}
}
}
}
} | subq $0x4d8, %rsp # imm = 0x4D8
movq %rdi, 0x4d0(%rsp)
movq %rsi, 0x4c8(%rsp)
movq 0x4d0(%rsp), %rax
movq %rax, 0x78(%rsp)
leaq 0x4b0(%rsp), %rdi
leaq 0x74c6c00(%rip), %rsi # 0x7ebcb63
callq 0x9e4b30
movq 0x4c8(%rsp), %rdi
callq 0x9e9cd0
movq %rax, %rdi
movl $0xb9e, %esi # imm = 0xB9E
callq 0x9e26c0
movq %rax, 0x4a8(%rsp)
cmpq $0x0, 0x4a8(%rsp)
je 0x9f61b4
movl $0x0, 0x4a4(%rsp)
movl $0x0, 0x4a0(%rsp)
movq 0x4c8(%rsp), %rdi
callq 0x9f5e20
movq %rax, 0x498(%rsp)
movq 0x498(%rsp), %rdi
callq 0x9e0470
movq %rax, 0x490(%rsp)
movq 0x498(%rsp), %rdi
callq 0x9e0480
movq %rax, 0x488(%rsp)
movq 0x490(%rsp), %rax
cmpq 0x488(%rsp), %rax
je 0x9f6178
movq 0x490(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x480(%rsp)
movq 0x480(%rsp), %rdi
callq 0x9fa540
cmpl $0x44, %eax
je 0x9f60f8
movq 0x480(%rsp), %rdi
callq 0x9fa540
cmpl $0x43, %eax
je 0x9f60f8
movq 0x480(%rsp), %rdi
callq 0xa012a0
cmpl $0xc, %eax
je 0x9f60f8
movq 0x480(%rsp), %rdi
callq 0x9fa540
cmpl $0x33, %eax
jne 0x9f6096
movq 0x480(%rsp), %rdi
callq 0xa012a0
cmpl $0x8, %eax
jne 0x9f6096
movl 0x4a0(%rsp), %ecx
movl %ecx, %eax
addl $0x1, %eax
movl %eax, 0x4a0(%rsp)
xorl %eax, %eax
cmpl %ecx, %eax
je 0x9f60f8
movq 0x480(%rsp), %rdi
callq 0xa012a0
cmpl $0x1, %eax
jne 0x9f60e5
movq 0x480(%rsp), %rdi
callq 0xa012b0
movq %rax, %rdi
callq 0x87dfe0
cmpq $0x0, %rax
je 0x9f60e5
movq 0x480(%rsp), %rdi
callq 0xa012b0
movq %rax, %rdi
callq 0xa012c0
movq (%rax), %rdi
callq 0xa012a0
cmpl $0xc, %eax
je 0x9f60f8
movl 0x4a4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4a4(%rsp)
jmp 0x9f615d
movq 0x480(%rsp), %rdi
callq 0xa012a0
cmpl $0x2, %eax
jne 0x9f615b
movq 0x480(%rsp), %rdi
callq 0x9fa540
cmpl $0x44, %eax
jne 0x9f615b
movq 0x4c8(%rsp), %rdi
callq 0x9e9cd0
movq %rax, %rdi
movl $0x6e7, %esi # imm = 0x6E7
callq 0x9df320
testb $0x1, %al
jne 0x9f615b
movq 0x480(%rsp), %rdi
callq 0xa012d0
movq %rax, %rcx
movl 0x4a4(%rsp), %eax
addq %rcx, %rax
movl %eax, 0x4a4(%rsp)
jmp 0x9f615d
jmp 0x9f615f
movq 0x490(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x490(%rsp)
jmp 0x9f5fee
cmpl $0x1, 0x4a4(%rsp)
jbe 0x9f61b2
movq 0x78(%rsp), %rsi
leaq 0x460(%rsp), %rdi
movl $0x1c3, %edx # imm = 0x1C3
callq 0x9df2d0
leaq 0x460(%rsp), %rdi
callq 0x949780
movq $0x0, 0x4a8(%rsp)
jmp 0x9f61b4
movq 0x4c8(%rsp), %rdi
callq 0x9f4180
movq %rax, %rdi
callq 0x9df070
movq %rax, 0x458(%rsp)
leaq 0x440(%rsp), %rdi
callq 0x80ce40
movq 0x458(%rsp), %rdi
callq 0x9470e0
testb $0x1, %al
jne 0x9f61f4
jmp 0x9f6398
movq 0x4c8(%rsp), %rdi
callq 0x9e9cd0
movq %rax, 0x438(%rsp)
movq 0x438(%rsp), %rsi
leaq 0x420(%rsp), %rdi
callq 0x82a0b0
movq 0x438(%rsp), %rsi
leaq 0x408(%rsp), %rdi
callq 0x82a170
movq 0x420(%rsp), %rax
movq %rax, 0x3f0(%rsp)
movq 0x428(%rsp), %rax
movq %rax, 0x3f8(%rsp)
movq 0x430(%rsp), %rax
movq %rax, 0x400(%rsp)
movq 0x408(%rsp), %rax
movq %rax, 0x3d8(%rsp)
movq 0x410(%rsp), %rax
movq %rax, 0x3e0(%rsp)
movq 0x418(%rsp), %rax
movq %rax, 0x3e8(%rsp)
leaq 0x3f0(%rsp), %rcx
leaq 0x3d8(%rsp), %rax
movq (%rcx), %rdx
movq %rdx, (%rsp)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
callq 0x82a230
testb $0x1, %al
jne 0x9f62e4
jmp 0x9f6396
leaq 0x420(%rsp), %rdi
callq 0x82a2c0
movq (%rax), %rax
movq %rax, 0x3d0(%rsp)
movq 0x3d0(%rsp), %rdi
callq 0x7ee280
movq %rax, 0x70(%rsp)
leaq 0x3cc(%rsp), %rdi
movl $0x81, %esi
callq 0x7eba60
movq 0x70(%rsp), %rdi
movl 0x3cc(%rsp), %esi
callq 0x82f0e0
testb $0x1, %al
jne 0x9f6337
jmp 0x9f6382
movq 0x3d0(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq %rax, %rsi
leaq 0x3b8(%rsp), %rdi
callq 0x7eb0f0
movq 0x3b8(%rsp), %rsi
movq 0x3c0(%rsp), %rdx
leaq 0x440(%rsp), %rdi
callq 0x8b8ec0
movq %rax, 0x3a8(%rsp)
movb %dl, 0x3b0(%rsp)
jmp 0x9f6384
leaq 0x420(%rsp), %rdi
callq 0x82a2d0
jmp 0x9f6233
jmp 0x9f6398
leaq 0x378(%rsp), %rdi
callq 0xa012f0
movq 0x4c8(%rsp), %rdi
callq 0x9f5e20
movq %rax, 0x370(%rsp)
movq 0x370(%rsp), %rdi
callq 0x9e0470
movq %rax, 0x368(%rsp)
movq 0x370(%rsp), %rdi
callq 0x9e0480
movq %rax, 0x360(%rsp)
movq 0x368(%rsp), %rax
cmpq 0x360(%rsp), %rax
je 0x9f6549
movq 0x368(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x358(%rsp)
movq $0x0, 0x350(%rsp)
leaq 0x358(%rsp), %rdi
callq 0xa01300
testb $0x1, %al
jne 0x9f642c
jmp 0x9f6464
cmpq $0x0, 0x4a8(%rsp)
je 0x9f6450
movq 0x4a8(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq %rax, 0x350(%rsp)
jmp 0x9f6462
movq 0x78(%rsp), %rdi
callq 0x9fc1c0
movq %rax, 0x350(%rsp)
jmp 0x9f6464
movq 0x4c8(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x358(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x4c8(%rsp), %rdi
callq 0x9f4180
movq %rax, 0x68(%rsp)
leaq 0x290(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x73aa90
leaq 0x290(%rsp), %rdi
callq 0x80d290
leaq 0x440(%rsp), %rdi
callq 0x8926d0
movq 0x78(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq 0x60(%rsp), %rcx
movq 0x68(%rsp), %r8
cmpl $0x1, %eax
seta %dil
movq 0x350(%rsp), %r9
movups 0x290(%rsp), %xmm0
movq %rsp, %rax
movups %xmm0, (%rax)
leaq 0x378(%rsp), %r10
movq %r10, 0x20(%rax)
movq %r9, 0x18(%rax)
movzbl %dil, %edi
andl $0x1, %edi
movl %edi, 0x10(%rax)
movl $0x0, 0x28(%rax)
leaq 0x2a0(%rsp), %rdi
movl $0x1, %r9d
callq 0xa01320
leaq 0x2a0(%rsp), %rdi
callq 0xa015b0
movq 0x368(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x368(%rsp)
jmp 0x9f63e4
movq 0x4c8(%rsp), %rdi
callq 0x7eb280
movq %rax, %rdi
callq 0xa01600
cmpq $0x1, %rax
ja 0x9f6580
movq 0x78(%rsp), %rax
movb 0x380(%rax), %al
shrb $0x2, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x9f660f
movq 0x4c8(%rsp), %rdi
callq 0x7eb280
movq %rax, 0x288(%rsp)
movq 0x288(%rsp), %rdi
callq 0x7eb2c0
movq %rax, 0x280(%rsp)
movq 0x288(%rsp), %rdi
callq 0x7eb470
movq %rax, 0x278(%rsp)
leaq 0x280(%rsp), %rdi
leaq 0x278(%rsp), %rsi
callq 0x9da8e0
testb $0x1, %al
jne 0x9f65da
jmp 0x9f660d
leaq 0x280(%rsp), %rdi
callq 0x7f1470
movq %rax, 0x270(%rsp)
movq 0x270(%rsp), %rax
movb $0x0, 0x201(%rax)
leaq 0x280(%rsp), %rdi
callq 0x9da940
jmp 0x9f65bf
jmp 0x9f660f
movq 0x78(%rsp), %rax
movb 0x380(%rax), %al
shrb $0x2, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x9f6685
movq 0x78(%rsp), %rax
movq 0x4c8(%rsp), %rcx
movq %rcx, 0x50(%rsp)
movq 0x4a8(%rsp), %rcx
movq %rcx, 0x240(%rsp)
movq %rax, 0x248(%rsp)
leaq 0x250(%rsp), %rdi
leaq 0x240(%rsp), %rsi
callq 0xa01640
movq 0x50(%rsp), %rdi
leaq 0x250(%rsp), %rsi
callq 0xa01610
leaq 0x250(%rsp), %rdi
callq 0x9de930
movq 0x78(%rsp), %rax
movq (%rax), %rdi
callq 0x9cfa80
testb $0x1, %al
jne 0x9f66b6
movq 0x4c8(%rsp), %rdi
callq 0x9e9cd0
movq %rax, %rdi
movl $0xbef, %esi # imm = 0xBEF
callq 0x9df320
testb $0x1, %al
jne 0x9f66b6
jmp 0x9f66c6
movl $0x1, 0x23c(%rsp)
jmp 0x9f6bfe
movq 0x4c8(%rsp), %rdi
callq 0x9e9cd0
movq %rax, %rdi
movl $0x26a, %esi # imm = 0x26A
callq 0x9df320
movq 0x4c8(%rsp), %rdi
callq 0x9e9cd0
movq %rax, %rdi
movl $0x48, %esi
callq 0x9df320
movq 0x4c8(%rsp), %rdi
callq 0x9e9cd0
movq %rax, %rdi
movl $0x12e, %esi # imm = 0x12E
callq 0x9df320
movq 0x4c8(%rsp), %rdi
callq 0x9e9cd0
movq %rax, %rdi
movl $0xc10, %esi # imm = 0xC10
callq 0x9df320
movq 0x4c8(%rsp), %rdi
callq 0x7eb280
movq %rax, %rdi
callq 0xa016c0
andb $0x1, %al
movb %al, 0x23b(%rsp)
movq 0x4c8(%rsp), %rdi
callq 0x9e9cd0
movq %rax, 0x230(%rsp)
movq 0x230(%rsp), %rsi
leaq 0x218(%rsp), %rdi
callq 0x82a0b0
movq 0x230(%rsp), %rsi
leaq 0x200(%rsp), %rdi
callq 0x82a170
movq 0x218(%rsp), %rax
movq %rax, 0x1e8(%rsp)
movq 0x220(%rsp), %rax
movq %rax, 0x1f0(%rsp)
movq 0x228(%rsp), %rax
movq %rax, 0x1f8(%rsp)
movq 0x200(%rsp), %rax
movq %rax, 0x1d0(%rsp)
movq 0x208(%rsp), %rax
movq %rax, 0x1d8(%rsp)
movq 0x210(%rsp), %rax
movq %rax, 0x1e0(%rsp)
leaq 0x1e8(%rsp), %rcx
leaq 0x1d0(%rsp), %rax
movq (%rcx), %rdx
movq %rdx, (%rsp)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
callq 0x82a230
testb $0x1, %al
jne 0x9f683c
jmp 0x9f6bf3
leaq 0x218(%rsp), %rdi
callq 0x82a2c0
movq (%rax), %rax
movq %rax, 0x1c8(%rsp)
movq 0x1c8(%rsp), %rdi
callq 0x829d00
testb $0x1, %al
jne 0x9f6bdf
movq 0x1c8(%rsp), %rdi
callq 0x7ee280
movq %rax, %rdi
movl $0x40, %esi
callq 0x837f10
testb $0x1, %al
jne 0x9f6889
jmp 0x9f688e
jmp 0x9f6be1
movq 0x1c8(%rsp), %rdi
callq 0x7ee280
movq %rax, 0x1c0(%rsp)
movq 0x1c0(%rsp), %rdi
callq 0x82f090
cmpl $0x3, %eax
jne 0x9f6a28
movb $0x0, 0x1bf(%rsp)
movq 0x4c8(%rsp), %rdi
callq 0x9e9cd0
movq %rax, %rsi
movq 0x1c0(%rsp), %rdx
leaq 0x180(%rsp), %rdi
callq 0xa01700
leaq 0x180(%rsp), %rax
movq %rax, 0x1b0(%rsp)
movq 0x1b0(%rsp), %rsi
leaq 0x168(%rsp), %rdi
callq 0x7ec890
movq 0x1b0(%rsp), %rsi
leaq 0x150(%rsp), %rdi
callq 0x7ec8c0
movq 0x168(%rsp), %rax
movq %rax, 0x138(%rsp)
movq 0x170(%rsp), %rax
movq %rax, 0x140(%rsp)
movq 0x178(%rsp), %rax
movq %rax, 0x148(%rsp)
movq 0x150(%rsp), %rax
movq %rax, 0x120(%rsp)
movq 0x158(%rsp), %rax
movq %rax, 0x128(%rsp)
movq 0x160(%rsp), %rax
movq %rax, 0x130(%rsp)
leaq 0x138(%rsp), %rcx
leaq 0x120(%rsp), %rax
movq (%rcx), %rdx
movq %rdx, (%rsp)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
callq 0x7ec8f0
testb $0x1, %al
jne 0x9f69ce
jmp 0x9f6a17
leaq 0x168(%rsp), %rdi
callq 0x7ec980
movq (%rax), %rax
movq %rax, 0x118(%rsp)
movq 0x118(%rsp), %rdi
callq 0x829d00
testb $0x1, %al
jne 0x9f69f9
jmp 0x9f6a03
movb $0x1, 0x1bf(%rsp)
jmp 0x9f6a17
jmp 0x9f6a05
leaq 0x168(%rsp), %rdi
callq 0x7eca10
jmp 0x9f6920
testb $0x1, 0x1bf(%rsp)
je 0x9f6a26
jmp 0x9f6be1
jmp 0x9f6a28
movq 0x78(%rsp), %rdi
callq 0x9df4e0
testb $0x1, %al
jne 0x9f6a38
jmp 0x9f6a75
movq 0x1c8(%rsp), %rdi
callq 0x7ee280
movq %rax, 0x48(%rsp)
leaq 0x114(%rsp), %rdi
movl $0x47, %esi
callq 0x7eba60
movq 0x48(%rsp), %rdi
movl 0x114(%rsp), %esi
callq 0x82f0e0
testb $0x1, %al
jne 0x9f6bdd
movq 0x1c8(%rsp), %rdi
callq 0x7ee280
movq %rax, %rdi
movl $0x400, %esi # imm = 0x400
callq 0x837f10
testb $0x1, %al
jne 0x9f6a98
jmp 0x9f6b66
movq 0x1c8(%rsp), %rdi
callq 0xa018f0
testb $0x1, %al
jne 0x9f6b66
testb $0x1, 0x23b(%rsp)
jne 0x9f6b66
movq 0x4c8(%rsp), %rdi
callq 0x9f5e20
movq %rax, %rdi
callq 0x87e020
testb $0x1, %al
jne 0x9f6b66
movq 0x78(%rsp), %rsi
leaq 0xf0(%rsp), %rdi
movl $0x1e5, %edx # imm = 0x1E5
callq 0x9df2d0
movq 0x1c8(%rsp), %rdi
callq 0x83b7a0
movq %rax, 0xe0(%rsp)
movq %rdx, 0xe8(%rsp)
leaq 0xf0(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
callq 0x973710
movq 0x78(%rsp), %rsi
movq %rax, 0x40(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0xa01920
movq 0x40(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x973770
leaq 0xc0(%rsp), %rdi
callq 0x73b5d0
leaq 0xf0(%rsp), %rdi
callq 0x949780
jmp 0x9f6bdb
movq 0x78(%rsp), %rsi
leaq 0xa0(%rsp), %rdi
movl $0x254, %edx # imm = 0x254
callq 0x9df2d0
movq 0x1c8(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x4c8(%rsp), %rdi
callq 0x9e9cd0
movq 0x38(%rsp), %rsi
movq %rax, %rdx
leaq 0x80(%rsp), %rdi
callq 0x83b050
leaq 0xa0(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x973770
leaq 0x80(%rsp), %rdi
callq 0x73b5d0
leaq 0xa0(%rsp), %rdi
callq 0x949780
jmp 0x9f6bdd
jmp 0x9f6bdf
jmp 0x9f6be1
leaq 0x218(%rsp), %rdi
callq 0x82a2d0
jmp 0x9f678b
movl $0x0, 0x23c(%rsp)
leaq 0x378(%rsp), %rdi
callq 0xa01950
leaq 0x440(%rsp), %rdi
callq 0x805e80
leaq 0x4b0(%rsp), %rdi
callq 0x87aa80
addq $0x4d8, %rsp # imm = 0x4D8
retq
nopl (%rax)
| /Driver/Driver.cpp |
clang::driver::Driver::DiagnoseInputExistence(llvm::opt::DerivedArgList const&, llvm::StringRef, clang::driver::types::ID, bool) const | bool Driver::DiagnoseInputExistence(const DerivedArgList &Args, StringRef Value,
types::ID Ty, bool TypoCorrect) const {
if (!getCheckInputsExist())
return true;
// stdin always exists.
if (Value == "-")
return true;
// If it's a header to be found in the system or user search path, then defer
// complaints about its absence until those searches can be done. When we
// are definitely processing headers for C++20 header units, extend this to
// allow the user to put "-fmodule-header -xc++-header vector" for example.
if (Ty == types::TY_CXXSHeader || Ty == types::TY_CXXUHeader ||
(ModulesModeCXX20 && Ty == types::TY_CXXHeader))
return true;
if (getVFS().exists(Value))
return true;
if (TypoCorrect) {
// Check if the filename is a typo for an option flag. OptTable thinks
// that all args that are not known options and that start with / are
// filenames, but e.g. `/diagnostic:caret` is more likely a typo for
// the option `/diagnostics:caret` than a reference to a file in the root
// directory.
std::string Nearest;
if (getOpts().findNearest(Value, Nearest, getOptionVisibilityMask()) <= 1) {
Diag(clang::diag::err_drv_no_such_file_with_suggestion)
<< Value << Nearest;
return false;
}
}
// In CL mode, don't error on apparently non-existent linker inputs, because
// they can be influenced by linker flags the clang driver might not
// understand.
// Examples:
// - `clang-cl main.cc ole32.lib` in a non-MSVC shell will make the driver
// module look for an MSVC installation in the registry. (We could ask
// the MSVCToolChain object if it can find `ole32.lib`, but the logic to
// look in the registry might move into lld-link in the future so that
// lld-link invocations in non-MSVC shells just work too.)
// - `clang-cl ... /link ...` can pass arbitrary flags to the linker,
// including /libpath:, which is used to find .lib and .obj files.
// So do not diagnose this on the driver level. Rely on the linker diagnosing
// it. (If we don't end up invoking the linker, this means we'll emit a
// "'linker' input unused [-Wunused-command-line-argument]" warning instead
// of an error.)
//
// Only do this skip after the typo correction step above. `/Brepo` is treated
// as TY_Object, but it's clearly a typo for `/Brepro`. It seems fine to emit
// an error if we have a flag that's within an edit distance of 1 from a
// flag. (Users can use `-Wl,` or `/linker` to launder the flag past the
// driver in the unlikely case they run into this.)
//
// Don't do this for inputs that start with a '/', else we'd pass options
// like /libpath: through to the linker silently.
//
// Emitting an error for linker inputs can also cause incorrect diagnostics
// with the gcc driver. The command
// clang -fuse-ld=lld -Wl,--chroot,some/dir /file.o
// will make lld look for some/dir/file.o, while we will diagnose here that
// `/file.o` does not exist. However, configure scripts check if
// `clang /GR-` compiles without error to see if the compiler is cl.exe,
// so we can't downgrade diagnostics for `/GR-` from an error to a warning
// in cc mode. (We can in cl mode because cl.exe itself only warns on
// unknown flags.)
if (IsCLMode() && Ty == types::TY_Object && !Value.starts_with("/"))
return true;
Diag(clang::diag::err_drv_no_such_file) << Value;
return false;
} | subq $0x128, %rsp # imm = 0x128
movb %r9b, %al
movq %rdx, 0x110(%rsp)
movq %rcx, 0x118(%rsp)
movq %rdi, 0x108(%rsp)
movq %rsi, 0x100(%rsp)
movl %r8d, 0xfc(%rsp)
andb $0x1, %al
movb %al, 0xfb(%rsp)
movq 0x108(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x9fae40
testb $0x1, %al
jne 0x9fab9e
movb $0x1, 0x127(%rsp)
jmp 0x9fae20
movq 0x110(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0x118(%rsp), %rax
movq %rax, 0xf0(%rsp)
leaq 0xd8(%rsp), %rdi
leaq 0x741ce02(%rip), %rsi # 0x7e179cf
callq 0x7eb0f0
movq 0xe8(%rsp), %rdi
movq 0xf0(%rsp), %rsi
movq 0xd8(%rsp), %rdx
movq 0xe0(%rsp), %rcx
callq 0x7ed410
testb $0x1, %al
jne 0x9fabfd
jmp 0x9fac0a
movb $0x1, 0x127(%rsp)
jmp 0x9fae20
cmpl $0x20, 0xfc(%rsp)
je 0x9fac33
cmpl $0x21, 0xfc(%rsp)
je 0x9fac33
movq 0x18(%rsp), %rax
testb $0x1, 0x24(%rax)
je 0x9fac40
cmpl $0x1d, 0xfc(%rsp)
jne 0x9fac40
movb $0x1, 0x127(%rsp)
jmp 0x9fae20
movq 0x18(%rsp), %rdi
callq 0x9ec040
movq %rax, 0x10(%rsp)
leaq 0xb0(%rsp), %rdi
leaq 0x110(%rsp), %rsi
callq 0x7f18a0
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
leaq 0xb0(%rsp), %rsi
callq *0x58(%rax)
testb $0x1, %al
jne 0x9fac7d
jmp 0x9fac8a
movb $0x1, 0x127(%rsp)
jmp 0x9fae20
testb $0x1, 0xfb(%rsp)
je 0x9fad98
leaq 0x90(%rsp), %rdi
callq 0x73b2c0
movq 0x18(%rsp), %rdi
callq 0x9e3c10
movq 0x18(%rsp), %rdi
movq %rax, 0x8(%rsp)
movq 0x110(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x118(%rsp), %rax
movq %rax, 0x88(%rsp)
movl $0x1, %esi
callq 0x9e4b70
movq 0x8(%rsp), %rdi
movl %eax, 0x7c(%rsp)
movq 0x80(%rsp), %rsi
movq 0x88(%rsp), %rdx
movl 0x7c(%rsp), %r8d
leaq 0x90(%rsp), %rcx
movl $0x4, %r9d
movl $0xffffffff, (%rsp) # imm = 0xFFFFFFFF
callq 0x831880
cmpl $0x1, %eax
ja 0x9fad72
movq 0x18(%rsp), %rsi
leaq 0x58(%rsp), %rdi
movl $0x1b6, %edx # imm = 0x1B6
callq 0x9df2d0
leaq 0x58(%rsp), %rdi
leaq 0x110(%rsp), %rsi
callq 0x9d6350
movq %rax, %rdi
leaq 0x90(%rsp), %rsi
callq 0x949720
leaq 0x58(%rsp), %rdi
callq 0x949780
movb $0x0, 0x127(%rsp)
movl $0x1, 0x54(%rsp)
jmp 0x9fad7a
movl $0x0, 0x54(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x73b5d0
movl 0x54(%rsp), %eax
testl %eax, %eax
je 0x9fad96
jmp 0x9fad91
jmp 0x9fae20
jmp 0x9fad98
movq 0x18(%rsp), %rdi
callq 0x9df4e0
testb $0x1, %al
jne 0x9fada8
jmp 0x9fade8
cmpl $0x3b, 0xfc(%rsp)
jne 0x9fade8
leaq 0x40(%rsp), %rdi
leaq 0x741d1b5(%rip), %rsi # 0x7e17f73
callq 0x7eb0f0
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
leaq 0x110(%rsp), %rdi
callq 0x7f7120
testb $0x1, %al
jne 0x9fade8
movb $0x1, 0x127(%rsp)
jmp 0x9fae20
movq 0x18(%rsp), %rsi
leaq 0x20(%rsp), %rdi
movl $0x1b5, %edx # imm = 0x1B5
callq 0x9df2d0
leaq 0x20(%rsp), %rdi
leaq 0x110(%rsp), %rsi
callq 0x9d6350
leaq 0x20(%rsp), %rdi
callq 0x949780
movb $0x0, 0x127(%rsp)
movb 0x127(%rsp), %al
andb $0x1, %al
addq $0x128, %rsp # imm = 0x128
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /Driver/Driver.cpp |
(anonymous namespace)::OffloadingActionBuilder::makeHostLinkAction() | Action *makeHostLinkAction() {
// Build a list of device linking actions.
ActionList DeviceAL;
appendDeviceLinkActions(DeviceAL);
if (DeviceAL.empty())
return nullptr;
// Let builders add host linking actions.
Action* HA = nullptr;
for (DeviceActionBuilder *SB : SpecializedBuilders) {
if (!SB->isValid())
continue;
HA = SB->appendLinkHostActions(DeviceAL);
// This created host action has no originating input argument, therefore
// needs to set its offloading kind directly.
if (HA)
HA->propagateHostOffloadInfo(SB->getAssociatedOffloadKind(),
/*BoundArch=*/nullptr);
}
return HA;
} | subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x9de440
movq 0x8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x9fec00
leaq 0x40(%rsp), %rdi
callq 0x87e020
testb $0x1, %al
jne 0x9feccc
jmp 0x9fece2
movq $0x0, 0x70(%rsp)
movl $0x1, 0x3c(%rsp)
jmp 0x9feda3
movq 0x8(%rsp), %rax
movq $0x0, 0x30(%rsp)
addq $0x70, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0xa12d30
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0xa12d40
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0x9fed91
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0xa12d80
testb $0x1, %al
jne 0x9fed40
jmp 0x9fed81
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
leaq 0x40(%rsp), %rsi
callq *0x30(%rax)
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x9fed7f
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0xa12da0
movq (%rsp), %rdi
movl %eax, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xb98a10
jmp 0x9fed81
movq 0x20(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x20(%rsp)
jmp 0x9fed17
movq 0x30(%rsp), %rax
movq %rax, 0x70(%rsp)
movl $0x1, 0x3c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x9de9f0
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
nopw (%rax,%rax)
| /Driver/Driver.cpp |
clang::driver::ToolChain const* clang::driver::Compilation::getSingleOffloadToolChain<(clang::driver::Action::OffloadKind)2>() const | const ToolChain *getSingleOffloadToolChain() const {
auto TCs = getOffloadToolChains<Kind>();
assert(TCs.first != TCs.second &&
"No tool chains of the selected kind exist!");
assert(std::next(TCs.first) == TCs.second &&
"More than one tool chain of the this kind exist.");
return TCs.first->second;
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0xa23460
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
movq %rsp, %rdi
callq 0x9e2290
movq 0x8(%rax), %rax
addq $0x18, %rsp
retq
nopl (%rax)
| /clang/Driver/Compilation.h |
(anonymous namespace)::ToolSelector::combineBackendCompile(llvm::ArrayRef<(anonymous namespace)::ToolSelector::JobActionInfo>, llvm::SmallVector<clang::driver::Action*, 3u>&, llvm::SmallVector<clang::driver::Action*, 3u>&) | const Tool *combineBackendCompile(ArrayRef<JobActionInfo> ActionInfo,
ActionList &Inputs,
ActionList &CollapsedOffloadAction) {
if (ActionInfo.size() < 2)
return nullptr;
auto *BJ = dyn_cast<BackendJobAction>(ActionInfo[0].JA);
auto *CJ = dyn_cast<CompileJobAction>(ActionInfo[1].JA);
if (!BJ || !CJ)
return nullptr;
// Check if the initial input (to the compile job or its predessor if one
// exists) is LLVM bitcode. In that case, no preprocessor step is required
// and we can still collapse the compile and backend jobs when we have
// -save-temps. I.e. there is no need for a separate compile job just to
// emit unoptimized bitcode.
bool InputIsBitcode = true;
for (size_t i = 1; i < ActionInfo.size(); i++)
if (ActionInfo[i].JA->getType() != types::TY_LLVM_BC &&
ActionInfo[i].JA->getType() != types::TY_LTO_BC) {
InputIsBitcode = false;
break;
}
if (!InputIsBitcode && !canCollapsePreprocessorAction())
return nullptr;
// Get compiler tool.
const Tool *T = TC.SelectTool(*CJ);
if (!T)
return nullptr;
// Can't collapse if we don't have codegen support unless we are
// emitting LLVM IR.
bool OutputIsLLVM = types::isLLVMIR(ActionInfo[0].JA->getType());
if (!T->hasIntegratedBackend() && !(OutputIsLLVM && T->canEmitIR()))
return nullptr;
if (T->canEmitIR() && ((SaveTemps && !InputIsBitcode) || EmbedBitcode))
return nullptr;
Inputs = CJ->getInputs();
AppendCollapsedOffloadAction(CollapsedOffloadAction, ActionInfo,
/*NumElements=*/2);
return T;
} | subq $0x78, %rsp
movq %rsi, 0x60(%rsp)
movq %rdx, 0x68(%rsp)
movq %rdi, 0x58(%rsp)
movq %rcx, 0x50(%rsp)
movq %r8, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x60(%rsp), %rdi
callq 0xa1a5d0
cmpq $0x2, %rax
jae 0xa19235
movq $0x0, 0x70(%rsp)
jmp 0xa1941c
leaq 0x60(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xa1a6e0
movq (%rax), %rdi
callq 0xa1a700
movq %rax, 0x40(%rsp)
leaq 0x60(%rsp), %rdi
movl $0x1, %esi
callq 0xa1a6e0
movq (%rax), %rdi
callq 0xa1a710
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0xa1927c
cmpq $0x0, 0x38(%rsp)
jne 0xa1928a
movq $0x0, 0x70(%rsp)
jmp 0xa1941c
movb $0x1, 0x37(%rsp)
movq $0x1, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x60(%rsp), %rdi
callq 0xa1a5d0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0xa1930a
movq 0x28(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0xa1a6e0
movq (%rax), %rdi
callq 0x9fa540
cmpl $0x2d, %eax
je 0xa192f8
movq 0x28(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0xa1a6e0
movq (%rax), %rdi
callq 0x9fa540
cmpl $0x2f, %eax
je 0xa192f8
movb $0x0, 0x37(%rsp)
jmp 0xa1930a
jmp 0xa192fa
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0xa19298
testb $0x1, 0x37(%rsp)
jne 0xa1932d
movq 0x10(%rsp), %rdi
callq 0xa1ae10
testb $0x1, %al
jne 0xa1932d
movq $0x0, 0x70(%rsp)
jmp 0xa1941c
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x38(%rsp), %rsi
movq (%rdi), %rax
callq *0x68(%rax)
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0xa1935b
movq $0x0, 0x70(%rsp)
jmp 0xa1941c
leaq 0x60(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xa1a6e0
movq (%rax), %rdi
callq 0x9fa540
movl %eax, %edi
callq 0xb94480
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
testb $0x1, %al
jne 0xa193ae
testb $0x1, 0x1f(%rsp)
je 0xa193a3
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
testb $0x1, %al
jne 0xa193ae
movq $0x0, 0x70(%rsp)
jmp 0xa1941c
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
testb $0x1, %al
jne 0xa193bf
jmp 0xa193e7
movq 0x10(%rsp), %rax
testb $0x1, 0x19(%rax)
je 0xa193d1
testb $0x1, 0x37(%rsp)
je 0xa193dc
movq 0x10(%rsp), %rax
testb $0x1, 0x1a(%rax)
je 0xa193e7
movq $0x0, 0x70(%rsp)
jmp 0xa1941c
movq 0x38(%rsp), %rdi
callq 0xa012b0
movq %rax, %rsi
movq 0x50(%rsp), %rdi
callq 0xa19430
movq 0x48(%rsp), %rdi
leaq 0x60(%rsp), %rsi
movl $0x2, %edx
callq 0xa1a720
movq 0x20(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
| /Driver/Driver.cpp |
char const** llvm::SmallVectorImpl<char const*>::insert_one_impl<char const*>(char const**, char const*&&) | iterator insert_one_impl(iterator I, ArgType &&Elt) {
// Callers ensure that ArgType is derived from T.
static_assert(
std::is_same<std::remove_const_t<std::remove_reference_t<ArgType>>,
T>::value,
"ArgType must be derived from T!");
if (I == this->end()) { // Important special case for empty vector.
this->push_back(::std::forward<ArgType>(Elt));
return this->end()-1;
}
assert(this->isReferenceToStorage(I) && "Insertion iterator is out of bounds.");
// Grow if necessary.
size_t Index = I - this->begin();
std::remove_reference_t<ArgType> *EltPtr =
this->reserveForParamAndGetAddress(Elt);
I = this->begin() + Index;
::new ((void*) this->end()) T(::std::move(this->back()));
// Push everything else over.
std::move_backward(I, this->end()-1, this->end());
this->set_size(this->size() + 1);
// If we just moved the element we're inserting, be sure to update
// the reference (never happens if TakesParamByValue).
static_assert(!TakesParamByValue || std::is_same<ArgType, T>::value,
"ArgType must be 'T' when taking by value!");
if (!TakesParamByValue && this->isReferenceToRange(EltPtr, I, this->end()))
++EltPtr;
*I = ::std::forward<ArgType>(*EltPtr);
return I;
} | subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x58(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x30(%rsp)
callq 0x7f0420
movq %rax, %rcx
movq 0x30(%rsp), %rax
cmpq %rcx, %rax
jne 0xa1c693
movq 0x28(%rsp), %rdi
movq 0x48(%rsp), %rax
movq (%rax), %rsi
callq 0x809410
movq 0x28(%rsp), %rdi
callq 0x7f0420
addq $-0x8, %rax
movq %rax, 0x60(%rsp)
jmp 0xa1c784
movq 0x28(%rsp), %rdi
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x7f0410
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movq 0x8(%rsp), %rax
subq %rcx, %rax
sarq $0x3, %rax
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rsi
movl $0x1, %edx
callq 0x809570
movq 0x28(%rsp), %rdi
movq %rax, 0x38(%rsp)
callq 0x7f0410
movq 0x28(%rsp), %rdi
movq 0x40(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x50(%rsp)
callq 0x7f0420
movq 0x28(%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0xa1c7a0
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x7f0420
movq 0x28(%rsp), %rdi
addq $-0x8, %rax
movq %rax, 0x20(%rsp)
callq 0x7f0420
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %rax, %rdx
callq 0x856f10
movq 0x28(%rsp), %rdi
callq 0x87dfe0
movq 0x28(%rsp), %rdi
movq %rax, %rsi
addq $0x1, %rsi
callq 0x87e040
movq 0x38(%rsp), %rax
movq (%rax), %rcx
movq 0x50(%rsp), %rax
movq %rcx, (%rax)
movq 0x50(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nop
| /llvm/ADT/SmallVector.h |
llvm::SmallVectorImpl<char const*>::operator=(llvm::SmallVectorImpl<char const*>&&) | SmallVectorImpl<T> &SmallVectorImpl<T>::operator=(SmallVectorImpl<T> &&RHS) {
// Avoid self-assignment.
if (this == &RHS) return *this;
// If the RHS isn't small, clear this vector and then steal its buffer.
if (!RHS.isSmall()) {
this->assignRemote(std::move(RHS));
return *this;
}
// If we already have sufficient space, assign the common elements, then
// destroy any excess.
size_t RHSSize = RHS.size();
size_t CurSize = this->size();
if (CurSize >= RHSSize) {
// Assign common elements.
iterator NewEnd = this->begin();
if (RHSSize)
NewEnd = std::move(RHS.begin(), RHS.end(), NewEnd);
// Destroy excess elements and trim the bounds.
this->destroy_range(NewEnd, this->end());
this->set_size(RHSSize);
// Clear the RHS.
RHS.clear();
return *this;
}
// If we have to grow to have enough elements, destroy the current elements.
// This allows us to avoid copying them during the grow.
// FIXME: this may not actually make any sense if we can efficiently move
// elements.
if (this->capacity() < RHSSize) {
// Destroy current elements.
this->clear();
CurSize = 0;
this->grow(RHSSize);
} else if (CurSize) {
// Otherwise, use assignment for the already-constructed elements.
std::move(RHS.begin(), RHS.begin()+CurSize, this->begin());
}
// Move-construct the new elements in place.
this->uninitialized_move(RHS.begin()+CurSize, RHS.end(),
this->begin()+CurSize);
// Set end.
this->set_size(RHSSize);
RHS.clear();
return *this;
} | subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpq 0x50(%rsp), %rax
jne 0xa1c7ee
movq 0x30(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0xa1c9d0
movq 0x50(%rsp), %rdi
callq 0x7f04a0
testb $0x1, %al
jne 0xa1c81a
movq 0x30(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0xa1c9e0
movq 0x30(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0xa1c9d0
movq 0x50(%rsp), %rdi
callq 0x87dfe0
movq 0x30(%rsp), %rdi
movq %rax, 0x48(%rsp)
callq 0x87dfe0
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
cmpq 0x48(%rsp), %rax
jb 0xa1c8d8
movq 0x30(%rsp), %rdi
callq 0x7f0410
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x48(%rsp)
je 0xa1c88f
movq 0x50(%rsp), %rdi
callq 0x7f0410
movq %rax, 0x28(%rsp)
movq 0x50(%rsp), %rdi
callq 0x7f0420
movq 0x28(%rsp), %rdi
movq %rax, %rsi
movq 0x38(%rsp), %rdx
callq 0x856bc0
movq %rax, 0x38(%rsp)
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0x7f0420
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x7f0400
movq 0x30(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x87e040
movq 0x50(%rsp), %rdi
callq 0x830940
movq 0x30(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0xa1c9d0
movq 0x30(%rsp), %rdi
callq 0x87ddf0
cmpq 0x48(%rsp), %rax
jae 0xa1c90d
movq 0x30(%rsp), %rdi
callq 0x830940
movq 0x30(%rsp), %rdi
movq $0x0, 0x40(%rsp)
movq 0x48(%rsp), %rsi
callq 0x809650
jmp 0xa1c95d
cmpq $0x0, 0x40(%rsp)
je 0xa1c95b
movq 0x50(%rsp), %rdi
callq 0x7f0410
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rdi
callq 0x7f0410
movq 0x30(%rsp), %rdi
movq 0x40(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
callq 0x7f0410
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq %rax, %rdx
callq 0x856bc0
jmp 0xa1c95d
movq 0x50(%rsp), %rdi
callq 0x7f0410
movq 0x40(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq 0x50(%rsp), %rdi
callq 0x7f0420
movq 0x30(%rsp), %rdi
movq %rax, 0x8(%rsp)
callq 0x7f0410
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
movq 0x40(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdx
callq 0x856fb0
movq 0x30(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x87e040
movq 0x50(%rsp), %rdi
callq 0x830940
movq 0x30(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nopw (%rax,%rax)
| /llvm/ADT/SmallVector.h |
clang::driver::toolchains::AMDGPUOpenMPToolChain::~AMDGPUOpenMPToolChain() | class LLVM_LIBRARY_VISIBILITY AMDGPUOpenMPToolChain final
: public ROCMToolChain {
public:
AMDGPUOpenMPToolChain(const Driver &D, const llvm::Triple &Triple,
const ToolChain &HostTC,
const llvm::opt::ArgList &Args);
const llvm::Triple *getAuxTriple() const override {
return &HostTC.getTriple();
}
llvm::opt::DerivedArgList *
TranslateArgs(const llvm::opt::DerivedArgList &Args, StringRef BoundArch,
Action::OffloadKind DeviceOffloadKind) const override;
void
addClangTargetOptions(const llvm::opt::ArgList &DriverArgs,
llvm::opt::ArgStringList &CC1Args,
Action::OffloadKind DeviceOffloadKind) const override;
void addClangWarningOptions(llvm::opt::ArgStringList &CC1Args) const override;
CXXStdlibType GetCXXStdlibType(const llvm::opt::ArgList &Args) const override;
void
AddClangSystemIncludeArgs(const llvm::opt::ArgList &DriverArgs,
llvm::opt::ArgStringList &CC1Args) const override;
void AddIAMCUIncludeArgs(const llvm::opt::ArgList &DriverArgs,
llvm::opt::ArgStringList &CC1Args) const override;
SanitizerMask getSupportedSanitizers() const override;
VersionTuple
computeMSVCVersion(const Driver *D,
const llvm::opt::ArgList &Args) const override;
llvm::SmallVector<BitCodeLibraryInfo, 12>
getDeviceLibs(const llvm::opt::ArgList &Args) const override;
const ToolChain &HostTC;
} | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0xa1ec40
popq %rax
retq
| /Driver/ToolChains/AMDGPUOpenMP.h |
clang::driver::ToolChain::GetLinkerPath[abi:cxx11](bool*) const | std::string ToolChain::GetLinkerPath(bool *LinkerIsLLD) const {
if (LinkerIsLLD)
*LinkerIsLLD = false;
// Get -fuse-ld= first to prevent -Wunused-command-line-argument. -fuse-ld= is
// considered as the linker flavor, e.g. "bfd", "gold", or "lld".
const Arg* A = Args.getLastArg(options::OPT_fuse_ld_EQ);
StringRef UseLinker = A ? A->getValue() : CLANG_DEFAULT_LINKER;
// --ld-path= takes precedence over -fuse-ld= and specifies the executable
// name. -B, COMPILER_PATH and PATH and consulted if the value does not
// contain a path component separator.
// -fuse-ld=lld can be used with --ld-path= to inform clang that the binary
// that --ld-path= points to is lld.
if (const Arg *A = Args.getLastArg(options::OPT_ld_path_EQ)) {
std::string Path(A->getValue());
if (!Path.empty()) {
if (llvm::sys::path::parent_path(Path).empty())
Path = GetProgramPath(A->getValue());
if (llvm::sys::fs::can_execute(Path)) {
if (LinkerIsLLD)
*LinkerIsLLD = UseLinker == "lld";
return std::string(Path);
}
}
getDriver().Diag(diag::err_drv_invalid_linker_name) << A->getAsString(Args);
return GetProgramPath(getDefaultLinker());
}
// If we're passed -fuse-ld= with no argument, or with the argument ld,
// then use whatever the default system linker is.
if (UseLinker.empty() || UseLinker == "ld") {
const char *DefaultLinker = getDefaultLinker();
if (llvm::sys::path::is_absolute(DefaultLinker))
return std::string(DefaultLinker);
else
return GetProgramPath(DefaultLinker);
}
// Extending -fuse-ld= to an absolute or relative path is unexpected. Checking
// for the linker flavor is brittle. In addition, prepending "ld." or "ld64."
// to a relative path is surprising. This is more complex due to priorities
// among -B, COMPILER_PATH and PATH. --ld-path= should be used instead.
if (UseLinker.contains('/'))
getDriver().Diag(diag::warn_drv_fuse_ld_path);
if (llvm::sys::path::is_absolute(UseLinker)) {
// If we're passed what looks like an absolute path, don't attempt to
// second-guess that.
if (llvm::sys::fs::can_execute(UseLinker))
return std::string(UseLinker);
} else {
llvm::SmallString<8> LinkerName;
if (Triple.isOSDarwin())
LinkerName.append("ld64.");
else
LinkerName.append("ld.");
LinkerName.append(UseLinker);
std::string LinkerPath(GetProgramPath(LinkerName.c_str()));
if (llvm::sys::fs::can_execute(LinkerPath)) {
if (LinkerIsLLD)
*LinkerIsLLD = UseLinker == "lld";
return LinkerPath;
}
}
if (A)
getDriver().Diag(diag::err_drv_invalid_linker_name) << A->getAsString(Args);
return GetProgramPath(getDefaultLinker());
} | subq $0x318, %rsp # imm = 0x318
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x310(%rsp)
movq %rsi, 0x308(%rsp)
movq %rdx, 0x300(%rsp)
movq 0x308(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x300(%rsp)
je 0xa4d9bf
movq 0x300(%rsp), %rax
movb $0x0, (%rax)
movq 0x30(%rsp), %rax
movq 0x48(%rax), %rdi
movl $0x724, %esi # imm = 0x724
callq 0x9e26c0
movq %rax, 0x2f8(%rsp)
cmpq $0x0, 0x2f8(%rsp)
je 0xa4d9fb
movq 0x2f8(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq %rax, 0x18(%rsp)
jmp 0xa4da09
leaq 0x74c5237(%rip), %rax # 0x7f12c39
movq %rax, 0x18(%rsp)
jmp 0xa4da09
movq 0x18(%rsp), %rsi
leaq 0x2e8(%rsp), %rdi
callq 0x7eb0f0
movq 0x30(%rsp), %rax
movq 0x48(%rax), %rdi
movl $0x828, %esi # imm = 0x828
callq 0x9e26c0
movq %rax, 0x2e0(%rsp)
cmpq $0x0, 0x2e0(%rsp)
je 0xa4dca2
movq 0x2e0(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq %rax, 0x10(%rsp)
leaq 0x2bf(%rsp), %rdi
callq 0x73a200
movq 0x10(%rsp), %rsi
leaq 0x2c0(%rsp), %rdi
leaq 0x2bf(%rsp), %rdx
callq 0x7e5c40
leaq 0x2bf(%rsp), %rdi
callq 0x73b530
leaq 0x2c0(%rsp), %rdi
callq 0x73b030
testb $0x1, %al
jne 0xa4dbf9
leaq 0x298(%rsp), %rdi
leaq 0x2c0(%rsp), %rsi
callq 0x7eaca0
movq 0x298(%rsp), %rdi
movq 0x2a0(%rsp), %rsi
xorl %edx, %edx
callq 0x8dc7b0
movq %rax, 0x2a8(%rsp)
movq %rdx, 0x2b0(%rsp)
leaq 0x2a8(%rsp), %rdi
callq 0x7ed530
testb $0x1, %al
jne 0xa4daf1
jmp 0xa4db37
movq 0x2e0(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq 0x30(%rsp), %rsi
movq %rax, %rdx
leaq 0x278(%rsp), %rdi
callq 0xa4d900
leaq 0x2c0(%rsp), %rdi
leaq 0x278(%rsp), %rsi
callq 0x73a330
leaq 0x278(%rsp), %rdi
callq 0x73b5d0
leaq 0x250(%rsp), %rdi
leaq 0x2c0(%rsp), %rsi
callq 0x7fcea0
leaq 0x250(%rsp), %rdi
callq 0x8e17f0
testb $0x1, %al
jne 0xa4db62
jmp 0xa4dbf7
cmpq $0x0, 0x300(%rsp)
je 0xa4dbd5
movq 0x2e8(%rsp), %rax
movq %rax, 0x240(%rsp)
movq 0x2f0(%rsp), %rax
movq %rax, 0x248(%rsp)
leaq 0x230(%rsp), %rdi
leaq 0x749d17a(%rip), %rsi # 0x7eead16
callq 0x7eb0f0
movq 0x240(%rsp), %rdi
movq 0x248(%rsp), %rsi
movq 0x230(%rsp), %rdx
movq 0x238(%rsp), %rcx
callq 0x7ed410
movb %al, %cl
movq 0x300(%rsp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movq 0x20(%rsp), %rdi
leaq 0x2c0(%rsp), %rsi
callq 0x73a040
movl $0x1, 0x22c(%rsp)
jmp 0xa4dc90
jmp 0xa4dbf9
movq 0x30(%rsp), %rdi
callq 0x9ffc60
movq %rax, %rsi
leaq 0x208(%rsp), %rdi
movl $0x17f, %edx # imm = 0x17F
callq 0x9df2d0
movq 0x30(%rsp), %rax
movq 0x2e0(%rsp), %rsi
movq 0x48(%rax), %rdx
leaq 0x1e8(%rsp), %rdi
callq 0x83b050
leaq 0x208(%rsp), %rdi
leaq 0x1e8(%rsp), %rsi
callq 0x973770
leaq 0x1e8(%rsp), %rdi
callq 0x73b5d0
leaq 0x208(%rsp), %rdi
callq 0x949780
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
callq *0x108(%rax)
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq %rax, %rdx
callq 0xa4d900
movl $0x1, 0x22c(%rsp)
leaq 0x2c0(%rsp), %rdi
callq 0x73b5d0
jmp 0xa4e0e0
leaq 0x2e8(%rsp), %rdi
callq 0x7ed530
testb $0x1, %al
jne 0xa4dd15
movq 0x2e8(%rsp), %rax
movq %rax, 0x1d8(%rsp)
movq 0x2f0(%rsp), %rax
movq %rax, 0x1e0(%rsp)
leaq 0x1c8(%rsp), %rdi
leaq 0x768b9d5(%rip), %rsi # 0x80d96b7
callq 0x7eb0f0
movq 0x1d8(%rsp), %rdi
movq 0x1e0(%rsp), %rsi
movq 0x1c8(%rsp), %rdx
movq 0x1d0(%rsp), %rcx
callq 0x7ed410
testb $0x1, %al
jne 0xa4dd15
jmp 0xa4ddb4
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
callq *0x108(%rax)
movq %rax, 0x1c0(%rsp)
movq 0x1c0(%rsp), %rsi
leaq 0x198(%rsp), %rdi
callq 0x7f1850
leaq 0x198(%rsp), %rdi
xorl %esi, %esi
callq 0x8dde00
testb $0x1, %al
jne 0xa4dd55
jmp 0xa4dd98
movq 0x1c0(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x197(%rsp), %rdi
callq 0x73a200
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq 0x197(%rsp), %rdx
callq 0x7e5c40
leaq 0x197(%rsp), %rdi
callq 0x73b530
jmp 0xa4e0e0
movq 0x30(%rsp), %rsi
movq 0x20(%rsp), %rdi
movq 0x1c0(%rsp), %rdx
callq 0xa4d900
jmp 0xa4e0e0
leaq 0x2e8(%rsp), %rdi
movl $0x2f, %esi
callq 0x8e8f10
testb $0x1, %al
jne 0xa4ddcc
jmp 0xa4ddf8
movq 0x30(%rsp), %rdi
callq 0x9ffc60
movq %rax, %rsi
leaq 0x170(%rsp), %rdi
movl $0x220, %edx # imm = 0x220
callq 0x9df2d0
leaq 0x170(%rsp), %rdi
callq 0x949780
leaq 0x148(%rsp), %rdi
leaq 0x2e8(%rsp), %rsi
callq 0x7f18a0
leaq 0x148(%rsp), %rdi
xorl %esi, %esi
callq 0x8dde00
testb $0x1, %al
jne 0xa4de22
jmp 0xa4de88
leaq 0x120(%rsp), %rdi
leaq 0x2e8(%rsp), %rsi
callq 0x7f18a0
leaq 0x120(%rsp), %rdi
callq 0x8e17f0
testb $0x1, %al
jne 0xa4de4a
jmp 0xa4de83
leaq 0x11f(%rsp), %rdi
callq 0x73a200
movq 0x20(%rsp), %rdi
leaq 0x2e8(%rsp), %rsi
leaq 0x11f(%rsp), %rdx
callq 0x7f6ce0
leaq 0x11f(%rsp), %rdi
callq 0x73b530
jmp 0xa4e0e0
jmp 0xa4e05b
leaq 0xf8(%rsp), %rdi
callq 0x830b30
movq 0x30(%rsp), %rdi
addq $0x10, %rdi
callq 0x93d1d0
testb $0x1, %al
jne 0xa4dea9
jmp 0xa4dedc
leaq 0xe8(%rsp), %rdi
leaq 0x7499cf6(%rip), %rsi # 0x7ee7bae
callq 0x7eb0f0
movq 0xe8(%rsp), %rsi
movq 0xf0(%rsp), %rdx
leaq 0xf8(%rsp), %rdi
callq 0x84b0d0
jmp 0xa4df0d
leaq 0xd8(%rsp), %rdi
leaq 0x74a014d(%rip), %rsi # 0x7eee038
callq 0x7eb0f0
movq 0xd8(%rsp), %rsi
movq 0xe0(%rsp), %rdx
leaq 0xf8(%rsp), %rdi
callq 0x84b0d0
movq 0x2e8(%rsp), %rax
movq %rax, 0xc8(%rsp)
movq 0x2f0(%rsp), %rax
movq %rax, 0xd0(%rsp)
movq 0xc8(%rsp), %rsi
movq 0xd0(%rsp), %rdx
leaq 0xf8(%rsp), %rdi
callq 0x84b0d0
movb $0x0, 0xc7(%rsp)
leaq 0xf8(%rsp), %rdi
callq 0x879c60
movq 0x30(%rsp), %rsi
movq 0x20(%rsp), %rdi
movq %rax, %rdx
callq 0xa4d900
movq 0x20(%rsp), %rsi
leaq 0x98(%rsp), %rdi
callq 0x7fcea0
leaq 0x98(%rsp), %rdi
callq 0x8e17f0
testb $0x1, %al
jne 0xa4df99
jmp 0xa4e01b
cmpq $0x0, 0x300(%rsp)
je 0xa4e006
movq 0x2e8(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x2f0(%rsp), %rax
movq %rax, 0x90(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x749cd46(%rip), %rsi # 0x7eead16
callq 0x7eb0f0
movq 0x88(%rsp), %rdi
movq 0x90(%rsp), %rsi
movq 0x78(%rsp), %rdx
movq 0x80(%rsp), %rcx
callq 0x7ed410
movb %al, %cl
movq 0x300(%rsp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movb $0x1, 0xc7(%rsp)
movl $0x1, 0x22c(%rsp)
jmp 0xa4e026
movl $0x0, 0x22c(%rsp)
testb $0x1, 0xc7(%rsp)
jne 0xa4e03a
movq 0x20(%rsp), %rdi
callq 0x73b5d0
leaq 0xf8(%rsp), %rdi
callq 0x830d70
movl 0x22c(%rsp), %eax
testl %eax, %eax
je 0xa4e059
jmp 0xa4e054
jmp 0xa4e0e0
jmp 0xa4e05b
cmpq $0x0, 0x2f8(%rsp)
je 0xa4e0c0
movq 0x30(%rsp), %rdi
callq 0x9ffc60
movq %rax, %rsi
leaq 0x58(%rsp), %rdi
movl $0x17f, %edx # imm = 0x17F
callq 0x9df2d0
movq 0x30(%rsp), %rax
movq 0x2f8(%rsp), %rsi
movq 0x48(%rax), %rdx
leaq 0x38(%rsp), %rdi
callq 0x83b050
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x973770
leaq 0x38(%rsp), %rdi
callq 0x73b5d0
leaq 0x58(%rsp), %rdi
callq 0x949780
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
callq *0x108(%rax)
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq %rax, %rdx
callq 0xa4d900
movq 0x28(%rsp), %rax
addq $0x318, %rsp # imm = 0x318
retq
nopl (%rax)
| /Driver/ToolChain.cpp |
llvm::opt::Arg* llvm::opt::ArgList::getLastArg<clang::driver::options::ID, clang::driver::options::ID, clang::driver::options::ID, clang::driver::options::ID, clang::driver::options::ID>(clang::driver::options::ID, clang::driver::options::ID, clang::driver::options::ID, clang::driver::options::ID, clang::driver::options::ID) const | Arg *getLastArg(OptSpecifiers ...Ids) const {
Arg *Res = nullptr;
for (Arg *A : filtered(Ids...)) {
Res = A;
Res->claim();
}
return Res;
} | subq $0x178, %rsp # imm = 0x178
movq %rdi, 0x170(%rsp)
movl %esi, 0x16c(%rsp)
movl %edx, 0x168(%rsp)
movl %ecx, 0x164(%rsp)
movl %r8d, 0x160(%rsp)
movl %r9d, 0x15c(%rsp)
movq 0x170(%rsp), %rsi
movq $0x0, 0x150(%rsp)
movl 0x16c(%rsp), %edx
movl 0x168(%rsp), %ecx
movl 0x164(%rsp), %r8d
movl 0x160(%rsp), %r9d
movl 0x15c(%rsp), %eax
leaq 0xf8(%rsp), %rdi
movl %eax, (%rsp)
callq 0xa54f70
leaq 0xf8(%rsp), %rax
movq %rax, 0x148(%rsp)
movq 0x148(%rsp), %rsi
leaq 0xd0(%rsp), %rdi
callq 0xa55370
movq 0x148(%rsp), %rsi
leaq 0xa8(%rsp), %rdi
callq 0xa553a0
leaq 0x80(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
movl $0x28, %edx
callq 0x73a720
leaq 0x58(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
movl $0x28, %edx
callq 0x73a720
movq 0x78(%rsp), %rcx
movq %rsp, %rax
movq %rcx, 0x48(%rax)
movups 0x58(%rsp), %xmm0
movups 0x68(%rsp), %xmm1
movups %xmm1, 0x38(%rax)
movups %xmm0, 0x28(%rax)
movq 0xa0(%rsp), %rcx
movq %rcx, 0x20(%rax)
movups 0x80(%rsp), %xmm0
movups 0x90(%rsp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xa553d0
testb $0x1, %al
jne 0xa50454
jmp 0xa50495
leaq 0xd0(%rsp), %rdi
callq 0xa55470
movq (%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x150(%rsp)
movq 0x150(%rsp), %rdi
callq 0x7ed2f0
leaq 0xd0(%rsp), %rdi
callq 0xa55480
jmp 0xa503d7
movq 0x150(%rsp), %rax
addq $0x178, %rsp # imm = 0x178
retq
nopw %cs:(%rax,%rax)
nop
| /llvm/Option/ArgList.h |
llvm::SmallVectorImpl<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::assignRemote(llvm::SmallVectorImpl<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&&) | void assignRemote(SmallVectorImpl &&RHS) {
this->destroy_range(this->begin(), this->end());
if (!this->isSmall())
free(this->begin());
this->BeginX = RHS.BeginX;
this->Size = RHS.Size;
this->Capacity = RHS.Capacity;
RHS.resetToSmall();
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x7f4b10
movq 0x10(%rsp), %rdi
movq %rax, 0x8(%rsp)
callq 0x7f4b20
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x7f4ad0
movq 0x10(%rsp), %rdi
callq 0x7f4ba0
testb $0x1, %al
jne 0xa55a49
movq 0x10(%rsp), %rdi
callq 0x7f4b10
movq %rax, %rdi
callq 0x73a760
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x18(%rsp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq 0x18(%rsp), %rdi
callq 0xa55b20
addq $0x28, %rsp
retq
nop
| /llvm/ADT/SmallVector.h |
getArchFeatures(clang::driver::Driver const&, llvm::StringRef, std::vector<llvm::StringRef, std::allocator<llvm::StringRef>>&, llvm::opt::ArgList const&) | static bool getArchFeatures(const Driver &D, StringRef Arch,
std::vector<StringRef> &Features,
const ArgList &Args) {
bool EnableExperimentalExtensions =
Args.hasArg(options::OPT_menable_experimental_extensions);
auto ISAInfo =
llvm::RISCVISAInfo::parseArchString(Arch, EnableExperimentalExtensions);
if (!ISAInfo) {
handleAllErrors(ISAInfo.takeError(), [&](llvm::StringError &ErrMsg) {
D.Diag(diag::err_drv_invalid_riscv_arch_name)
<< Arch << ErrMsg.getMessage();
});
return false;
}
for (const std::string &Str : (*ISAInfo)->toFeatures(/*AddAllExtension=*/true,
/*IgnoreUnknown=*/false))
Features.push_back(Args.MakeArgString(Str));
if (EnableExperimentalExtensions)
Features.push_back(Args.MakeArgString("+experimental"));
return true;
} | subq $0x148, %rsp # imm = 0x148
movq %rsi, 0x130(%rsp)
movq %rdx, 0x138(%rsp)
movq %rdi, 0x128(%rsp)
movq %rcx, 0x120(%rsp)
movq %r8, 0x118(%rsp)
movq 0x118(%rsp), %rdi
movl $0x8b8, %esi # imm = 0x8B8
callq 0x9df320
andb $0x1, %al
movb %al, 0x117(%rsp)
movq 0x130(%rsp), %rax
movq %rax, 0xf0(%rsp)
movq 0x138(%rsp), %rax
movq %rax, 0xf8(%rsp)
movb 0x117(%rsp), %al
movq 0xf0(%rsp), %rsi
movq 0xf8(%rsp), %rdx
leaq 0x100(%rsp), %rdi
movl $0x1, %r8d
andb $0x1, %al
movzbl %al, %ecx
callq 0x7d37530
leaq 0x100(%rsp), %rdi
callq 0xa66390
testb $0x1, %al
jne 0xa65de9
leaq 0xe8(%rsp), %rdi
leaq 0x100(%rsp), %rsi
callq 0xa0dbd0
movq 0x128(%rsp), %rax
movq %rax, 0xd8(%rsp)
leaq 0x130(%rsp), %rax
movq %rax, 0xe0(%rsp)
leaq 0xe8(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
callq 0xa664f0
leaq 0xe8(%rsp), %rdi
callq 0x7f51d0
movb $0x0, 0x147(%rsp)
movl $0x1, 0xd4(%rsp)
jmp 0xa65f7c
leaq 0x100(%rsp), %rdi
callq 0xa0dc80
movq %rax, %rdi
callq 0xa0dcb0
movq %rax, %rsi
leaq 0xb0(%rsp), %rdi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x7d35950
leaq 0xb0(%rsp), %rax
movq %rax, 0xc8(%rsp)
movq 0xc8(%rsp), %rdi
callq 0x7ec290
movq %rax, 0xa8(%rsp)
movq 0xc8(%rsp), %rdi
callq 0x7ec2c0
movq %rax, 0xa0(%rsp)
leaq 0xa8(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x7ec2f0
testb $0x1, %al
jne 0xa65e85
movl $0x2, 0xd4(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0x7e5cf0
jmp 0xa65f09
leaq 0xa8(%rsp), %rdi
callq 0x7ec330
movq %rax, 0x98(%rsp)
movq 0x120(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x118(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x98(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0x7fcea0
movq 0x18(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x829b10
movq %rax, %rsi
leaq 0x88(%rsp), %rdi
callq 0x7eb0f0
movq 0x20(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x80d780
leaq 0xa8(%rsp), %rdi
callq 0x7ec5f0
jmp 0xa65e4f
testb $0x1, 0x117(%rsp)
je 0xa65f69
movq 0x120(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x118(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x7481cab(%rip), %rsi # 0x7ee7be4
callq 0x7f1850
movq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x829b10
movq %rax, %rsi
leaq 0x50(%rsp), %rdi
callq 0x7eb0f0
movq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x80d780
movb $0x1, 0x147(%rsp)
movl $0x1, 0xd4(%rsp)
leaq 0x100(%rsp), %rdi
callq 0xa0dcd0
movb 0x147(%rsp), %al
andb $0x1, %al
addq $0x148, %rsp # imm = 0x148
retq
nopw (%rax,%rax)
| /Driver/ToolChains/Arch/RISCV.cpp |
clang::driver::tools::aix::Linker::~Linker() | class LLVM_LIBRARY_VISIBILITY Linker final : public Tool {
public:
Linker(const ToolChain &TC) : Tool("aix::Linker", "linker", TC) {}
bool hasIntegratedCPP() const override { return false; }
bool isLinkJob() const override { return true; }
void ConstructJob(Compilation &C, const JobAction &JA,
const InputInfo &Output, const InputInfoList &Inputs,
const llvm::opt::ArgList &TCArgs,
const char *LinkingOutput) const override;
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xa6a0f0
movq 0x8(%rsp), %rdi
movl $0x20, %esi
callq 0x73afc0
addq $0x18, %rsp
retq
nopl (%rax)
| /Driver/ToolChains/AIX.h |
clang::driver::tools::baremetal::StaticLibTool::~StaticLibTool() | class LLVM_LIBRARY_VISIBILITY StaticLibTool : public Tool {
public:
StaticLibTool(const ToolChain &TC)
: Tool("baremetal::StaticLibTool", "llvm-ar", TC) {}
bool hasIntegratedCPP() const override { return false; }
bool isLinkJob() const override { return true; }
void ConstructJob(Compilation &C, const JobAction &JA,
const InputInfo &Output, const InputInfoList &Inputs,
const llvm::opt::ArgList &TCArgs,
const char *LinkingOutput) const override;
} | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0xbafd70
popq %rax
retq
| /Driver/ToolChains/BareMetal.h |
llvm::SmallVectorImpl<clang::driver::Multilib>::operator=(llvm::SmallVectorImpl<clang::driver::Multilib> const&) | SmallVectorImpl<T> &SmallVectorImpl<T>::
operator=(const SmallVectorImpl<T> &RHS) {
// Avoid self-assignment.
if (this == &RHS) return *this;
// If we already have sufficient space, assign the common elements, then
// destroy any excess.
size_t RHSSize = RHS.size();
size_t CurSize = this->size();
if (CurSize >= RHSSize) {
// Assign common elements.
iterator NewEnd;
if (RHSSize)
NewEnd = std::copy(RHS.begin(), RHS.begin()+RHSSize, this->begin());
else
NewEnd = this->begin();
// Destroy excess elements.
this->destroy_range(NewEnd, this->end());
// Trim.
this->set_size(RHSSize);
return *this;
}
// If we have to grow to have enough elements, destroy the current elements.
// This allows us to avoid copying them during the grow.
// FIXME: don't do this if they're efficiently moveable.
if (this->capacity() < RHSSize) {
// Destroy current elements.
this->clear();
CurSize = 0;
this->grow(RHSSize);
} else if (CurSize) {
// Otherwise, use assignment for the already-constructed elements.
std::copy(RHS.begin(), RHS.begin()+CurSize, this->begin());
}
// Copy construct the new elements in place.
this->uninitialized_copy(RHS.begin()+CurSize, RHS.end(),
this->begin()+CurSize);
// Set end.
this->set_size(RHSSize);
return *this;
} | subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x40(%rsp)
cmpq 0x60(%rsp), %rax
jne 0xa8625e
movq 0x40(%rsp), %rax
movq %rax, 0x70(%rsp)
jmp 0xa8641f
movq 0x60(%rsp), %rdi
callq 0x87dfe0
movq 0x40(%rsp), %rdi
movq %rax, 0x58(%rsp)
callq 0x87dfe0
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
cmpq 0x58(%rsp), %rax
jb 0xa8632f
cmpq $0x0, 0x58(%rsp)
je 0xa862e1
movq 0x60(%rsp), %rdi
callq 0x9f9cd0
movq %rax, 0x30(%rsp)
movq 0x60(%rsp), %rdi
callq 0x9f9cd0
movq 0x40(%rsp), %rdi
imulq $0x98, 0x58(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x38(%rsp)
callq 0xa3d250
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq %rax, %rdx
callq 0xa86430
movq %rax, 0x48(%rsp)
jmp 0xa862f0
movq 0x40(%rsp), %rdi
callq 0xa3d250
movq %rax, 0x48(%rsp)
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rax
movq %rax, 0x28(%rsp)
callq 0xa3d260
movq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0xa40b10
movq 0x40(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x87e040
movq 0x40(%rsp), %rax
movq %rax, 0x70(%rsp)
jmp 0xa8641f
movq 0x40(%rsp), %rdi
callq 0x87ddf0
cmpq 0x58(%rsp), %rax
jae 0xa86364
movq 0x40(%rsp), %rdi
callq 0xa3cf70
movq 0x40(%rsp), %rdi
movq $0x0, 0x50(%rsp)
movq 0x58(%rsp), %rsi
callq 0xa41170
jmp 0xa863b4
cmpq $0x0, 0x50(%rsp)
je 0xa863b2
movq 0x60(%rsp), %rdi
callq 0x9f9cd0
movq %rax, 0x18(%rsp)
movq 0x60(%rsp), %rdi
callq 0x9f9cd0
movq 0x40(%rsp), %rdi
imulq $0x98, 0x50(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
callq 0xa3d250
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq %rax, %rdx
callq 0xa86430
jmp 0xa863b4
movq 0x60(%rsp), %rdi
callq 0x9f9cd0
imulq $0x98, 0x50(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %rdi
callq 0x9f9ce0
movq 0x40(%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0xa3d250
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
imulq $0x98, 0x50(%rsp), %rax
addq %rax, %rdx
callq 0xa86480
movq 0x40(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x87e040
movq 0x40(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
nopl (%rax)
| /llvm/ADT/SmallVector.h |
addCoveragePrefixMapArg(clang::driver::Driver const&, llvm::opt::ArgList const&, llvm::SmallVector<char const*, 16u>&) | static void addCoveragePrefixMapArg(const Driver &D, const ArgList &Args,
ArgStringList &CmdArgs) {
for (const Arg *A : Args.filtered(options::OPT_ffile_prefix_map_EQ,
options::OPT_fcoverage_prefix_map_EQ)) {
StringRef Map = A->getValue();
if (!Map.contains('='))
D.Diag(diag::err_drv_invalid_argument_to_option)
<< Map << A->getOption().getName();
else
CmdArgs.push_back(Args.MakeArgString("-fcoverage-prefix-map=" + Map));
A->claim();
}
} | subq $0x168, %rsp # imm = 0x168
movq %rdi, 0x160(%rsp)
movq %rsi, 0x158(%rsp)
movq %rdx, 0x150(%rsp)
movq 0x158(%rsp), %rsi
leaq 0x118(%rsp), %rdi
movl $0x2aa, %edx # imm = 0x2AA
movl $0x209, %ecx # imm = 0x209
callq 0x9faf40
leaq 0x118(%rsp), %rax
movq %rax, 0x148(%rsp)
movq 0x148(%rsp), %rsi
leaq 0x100(%rsp), %rdi
callq 0x82d030
movq 0x148(%rsp), %rsi
leaq 0xe8(%rsp), %rdi
callq 0x82d060
movq 0x100(%rsp), %rax
movq %rax, 0xd0(%rsp)
movq 0x108(%rsp), %rax
movq %rax, 0xd8(%rsp)
movq 0x110(%rsp), %rax
movq %rax, 0xe0(%rsp)
movq 0xe8(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0xc0(%rsp)
movq 0xf8(%rsp), %rax
movq %rax, 0xc8(%rsp)
leaq 0xd0(%rsp), %rcx
leaq 0xb8(%rsp), %rax
movq (%rcx), %rdx
movq %rdx, (%rsp)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rsp)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rsp)
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
callq 0x82d090
testb $0x1, %al
jne 0xa89649
jmp 0xa89775
leaq 0x100(%rsp), %rdi
callq 0x82d120
movq (%rax), %rax
movq %rax, 0xb0(%rsp)
movq 0xb0(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq %rax, %rsi
leaq 0xa0(%rsp), %rdi
callq 0x7eb0f0
leaq 0xa0(%rsp), %rdi
movl $0x3d, %esi
callq 0x8e8f10
testb $0x1, %al
jne 0xa89707
movq 0x160(%rsp), %rsi
leaq 0x80(%rsp), %rdi
movl $0x174, %edx # imm = 0x174
callq 0x9df2d0
leaq 0x80(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x9d6350
movq %rax, 0x40(%rsp)
movq 0xb0(%rsp), %rdi
callq 0x7ee280
movq %rax, %rdi
callq 0x82aaf0
movq 0x40(%rsp), %rdi
movq %rax, 0x70(%rsp)
movq %rdx, 0x78(%rsp)
leaq 0x70(%rsp), %rsi
callq 0x973710
leaq 0x80(%rsp), %rdi
callq 0x949780
jmp 0xa89756
movq 0x150(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x158(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x7439e2a(%rip), %rsi # 0x7ec3557
leaq 0xa0(%rsp), %rdx
callq 0x840960
movq 0x30(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x829b10
movq 0x38(%rsp), %rdi
movq %rax, %rsi
callq 0x809410
movq 0xb0(%rsp), %rdi
callq 0x7ed2f0
leaq 0x100(%rsp), %rdi
callq 0x82d130
jmp 0xa89598
addq $0x168, %rsp # imm = 0x168
retq
nopl (%rax)
| /Driver/ToolChains/Clang.cpp |
clang::driver::tools::Clang::AddAArch64TargetArgs(llvm::opt::ArgList const&, llvm::SmallVector<char const*, 16u>&) const | void Clang::AddAArch64TargetArgs(const ArgList &Args,
ArgStringList &CmdArgs) const {
const llvm::Triple &Triple = getToolChain().getEffectiveTriple();
if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone, true) ||
Args.hasArg(options::OPT_mkernel) ||
Args.hasArg(options::OPT_fapple_kext))
CmdArgs.push_back("-disable-red-zone");
if (!Args.hasFlag(options::OPT_mimplicit_float,
options::OPT_mno_implicit_float, true))
CmdArgs.push_back("-no-implicit-float");
RenderAArch64ABI(Triple, Args, CmdArgs);
// Forward the -mglobal-merge option for explicit control over the pass.
if (Arg *A = Args.getLastArg(options::OPT_mglobal_merge,
options::OPT_mno_global_merge)) {
CmdArgs.push_back("-mllvm");
if (A->getOption().matches(options::OPT_mno_global_merge))
CmdArgs.push_back("-aarch64-enable-global-merge=false");
else
CmdArgs.push_back("-aarch64-enable-global-merge=true");
}
// Enable/disable return address signing and indirect branch targets.
CollectARMPACBTIOptions(getToolChain(), Args, CmdArgs, true /*isAArch64*/);
if (Triple.getEnvironment() == llvm::Triple::PAuthTest)
handlePAuthABI(Args, CmdArgs);
// Handle -msve_vector_bits=<bits>
if (Arg *A = Args.getLastArg(options::OPT_msve_vector_bits_EQ)) {
StringRef Val = A->getValue();
const Driver &D = getToolChain().getDriver();
if (Val == "128" || Val == "256" || Val == "512" || Val == "1024" ||
Val == "2048" || Val == "128+" || Val == "256+" || Val == "512+" ||
Val == "1024+" || Val == "2048+") {
unsigned Bits = 0;
if (!Val.consume_back("+")) {
bool Invalid = Val.getAsInteger(10, Bits); (void)Invalid;
assert(!Invalid && "Failed to parse value");
CmdArgs.push_back(
Args.MakeArgString("-mvscale-max=" + llvm::Twine(Bits / 128)));
}
bool Invalid = Val.getAsInteger(10, Bits); (void)Invalid;
assert(!Invalid && "Failed to parse value");
CmdArgs.push_back(
Args.MakeArgString("-mvscale-min=" + llvm::Twine(Bits / 128)));
// Silently drop requests for vector-length agnostic code as it's implied.
} else if (Val != "scalable")
// Handle the unsupported values passed to msve-vector-bits.
D.Diag(diag::err_drv_unsupported_option_argument)
<< A->getSpelling() << Val;
}
AddAAPCSVolatileBitfieldArgs(Args, CmdArgs);
if (const Arg *A = Args.getLastArg(clang::driver::options::OPT_mtune_EQ)) {
CmdArgs.push_back("-tune-cpu");
if (strcmp(A->getValue(), "native") == 0)
CmdArgs.push_back(Args.MakeArgString(llvm::sys::getHostCPUName()));
else
CmdArgs.push_back(A->getValue());
}
AddUnalignedAccessWarning(CmdArgs);
Args.addOptInFlag(CmdArgs, options::OPT_fptrauth_intrinsics,
options::OPT_fno_ptrauth_intrinsics);
Args.addOptInFlag(CmdArgs, options::OPT_fptrauth_calls,
options::OPT_fno_ptrauth_calls);
Args.addOptInFlag(CmdArgs, options::OPT_fptrauth_returns,
options::OPT_fno_ptrauth_returns);
Args.addOptInFlag(CmdArgs, options::OPT_fptrauth_auth_traps,
options::OPT_fno_ptrauth_auth_traps);
Args.addOptInFlag(
CmdArgs, options::OPT_fptrauth_vtable_pointer_address_discrimination,
options::OPT_fno_ptrauth_vtable_pointer_address_discrimination);
Args.addOptInFlag(
CmdArgs, options::OPT_fptrauth_vtable_pointer_type_discrimination,
options::OPT_fno_ptrauth_vtable_pointer_type_discrimination);
Args.addOptInFlag(
CmdArgs, options::OPT_fptrauth_type_info_vtable_pointer_discrimination,
options::OPT_fno_ptrauth_type_info_vtable_pointer_discrimination);
Args.addOptInFlag(CmdArgs, options::OPT_fptrauth_init_fini,
options::OPT_fno_ptrauth_init_fini);
Args.addOptInFlag(
CmdArgs, options::OPT_fptrauth_function_pointer_type_discrimination,
options::OPT_fno_ptrauth_function_pointer_type_discrimination);
Args.addOptInFlag(CmdArgs, options::OPT_fptrauth_indirect_gotos,
options::OPT_fno_ptrauth_indirect_gotos);
} | subq $0x498, %rsp # imm = 0x498
movq %rdi, 0x490(%rsp)
movq %rsi, 0x488(%rsp)
movq %rdx, 0x480(%rsp)
movq 0x490(%rsp), %rdi
movq %rdi, 0xf0(%rsp)
callq 0xa04350
movq %rax, %rdi
callq 0xa5b4f0
movq %rax, 0x478(%rsp)
movq 0x488(%rsp), %rax
movq %rax, 0xf8(%rsp)
leaq 0x474(%rsp), %rdi
movl $0xa81, %esi # imm = 0xA81
callq 0x7eba60
leaq 0x470(%rsp), %rdi
movl $0x9fc, %esi # imm = 0x9FC
callq 0x7eba60
movq 0xf8(%rsp), %rdi
movl 0x474(%rsp), %esi
movl 0x470(%rsp), %edx
movl $0x1, %ecx
callq 0x828060
testb $0x1, %al
jne 0xa8a89e
jmp 0xa8a8cc
movq 0x488(%rsp), %rdi
movl $0x91c, %esi # imm = 0x91C
callq 0x9df320
testb $0x1, %al
jne 0xa8a8cc
movq 0x488(%rsp), %rdi
movl $0x1ab, %esi # imm = 0x1AB
callq 0x9df320
testb $0x1, %al
jne 0xa8a8cc
jmp 0xa8a8e0
movq 0x480(%rsp), %rdi
leaq 0x7435cfa(%rip), %rsi # 0x7ec05d5
callq 0x809410
movq 0x488(%rsp), %rax
movq %rax, 0xe8(%rsp)
leaq 0x46c(%rsp), %rdi
movl $0x8fe, %esi # imm = 0x8FE
callq 0x7eba60
leaq 0x468(%rsp), %rdi
movl $0x9b5, %esi # imm = 0x9B5
callq 0x7eba60
movq 0xe8(%rsp), %rdi
movl 0x46c(%rsp), %esi
movl 0x468(%rsp), %edx
movl $0x1, %ecx
callq 0x828060
testb $0x1, %al
jne 0xa8a94c
movq 0x480(%rsp), %rdi
leaq 0x745586d(%rip), %rsi # 0x7ee01b4
callq 0x809410
movq 0x478(%rsp), %rdi
movq 0x488(%rsp), %rsi
movq 0x480(%rsp), %rdx
callq 0xa8e390
movq 0x488(%rsp), %rdi
movl $0x8e4, %esi # imm = 0x8E4
movl $0x9ac, %edx # imm = 0x9AC
callq 0x9e50a0
movq %rax, 0x460(%rsp)
cmpq $0x0, 0x460(%rsp)
je 0xa8aa18
movq 0x480(%rsp), %rdi
leaq 0x7450cb1(%rip), %rsi # 0x7edb657
callq 0x809410
movq 0x460(%rsp), %rdi
callq 0x7ee280
movq %rax, 0xe0(%rsp)
leaq 0x45c(%rsp), %rdi
movl $0x9ac, %esi # imm = 0x9AC
callq 0x7eba60
movq 0xe0(%rsp), %rdi
movl 0x45c(%rsp), %esi
callq 0x82f0e0
testb $0x1, %al
jne 0xa8a9ec
jmp 0xa8aa02
movq 0x480(%rsp), %rdi
leaq 0x74617a7(%rip), %rsi # 0x7eec1a2
callq 0x809410
jmp 0xa8aa16
movq 0x480(%rsp), %rdi
leaq 0x74617b4(%rip), %rsi # 0x7eec1c5
callq 0x809410
jmp 0xa8aa18
movq 0xf0(%rsp), %rdi
callq 0xa04350
movq %rax, %rdi
movq 0x488(%rsp), %rsi
movq 0x480(%rsp), %rdx
movl $0x1, %ecx
callq 0xa89b60
movq 0x478(%rsp), %rdi
callq 0x938c20
cmpl $0x2a, %eax
jne 0xa8aa69
movq 0x488(%rsp), %rdi
movq 0x480(%rsp), %rsi
callq 0xa8e450
movq 0x488(%rsp), %rdi
movl $0xac1, %esi # imm = 0xAC1
callq 0x9e26c0
movq %rax, 0x450(%rsp)
cmpq $0x0, 0x450(%rsp)
je 0xa8b10a
movq 0x450(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq %rax, %rsi
leaq 0x440(%rsp), %rdi
callq 0x7eb0f0
movq 0xf0(%rsp), %rdi
callq 0xa04350
movq %rax, %rdi
callq 0x9ffc60
movq %rax, 0x438(%rsp)
movq 0x440(%rsp), %rax
movq %rax, 0x428(%rsp)
movq 0x448(%rsp), %rax
movq %rax, 0x430(%rsp)
leaq 0x418(%rsp), %rdi
leaq 0x93b5321(%rip), %rsi # 0x9e3fe1e
callq 0x7eb0f0
movq 0x428(%rsp), %rdi
movq 0x430(%rsp), %rsi
movq 0x418(%rsp), %rdx
movq 0x420(%rsp), %rcx
callq 0x7ed410
testb $0x1, %al
jne 0xa8ae95
movq 0x440(%rsp), %rax
movq %rax, 0x408(%rsp)
movq 0x448(%rsp), %rax
movq %rax, 0x410(%rsp)
leaq 0x3f8(%rsp), %rdi
leaq 0x93b5344(%rip), %rsi # 0x9e3fea2
callq 0x7eb0f0
movq 0x408(%rsp), %rdi
movq 0x410(%rsp), %rsi
movq 0x3f8(%rsp), %rdx
movq 0x400(%rsp), %rcx
callq 0x7ed410
testb $0x1, %al
jne 0xa8ae95
movq 0x440(%rsp), %rax
movq %rax, 0x3e8(%rsp)
movq 0x448(%rsp), %rax
movq %rax, 0x3f0(%rsp)
leaq 0x3d8(%rsp), %rdi
leaq 0x93b538f(%rip), %rsi # 0x9e3ff4e
callq 0x7eb0f0
movq 0x3e8(%rsp), %rdi
movq 0x3f0(%rsp), %rsi
movq 0x3d8(%rsp), %rdx
movq 0x3e0(%rsp), %rcx
callq 0x7ed410
testb $0x1, %al
jne 0xa8ae95
movq 0x440(%rsp), %rax
movq %rax, 0x3c8(%rsp)
movq 0x448(%rsp), %rax
movq %rax, 0x3d0(%rsp)
leaq 0x3b8(%rsp), %rdi
leaq 0x93b51d3(%rip), %rsi # 0x9e3fdf3
callq 0x7eb0f0
movq 0x3c8(%rsp), %rdi
movq 0x3d0(%rsp), %rsi
movq 0x3b8(%rsp), %rdx
movq 0x3c0(%rsp), %rcx
callq 0x7ed410
testb $0x1, %al
jne 0xa8ae95
movq 0x440(%rsp), %rax
movq %rax, 0x3a8(%rsp)
movq 0x448(%rsp), %rax
movq %rax, 0x3b0(%rsp)
leaq 0x398(%rsp), %rdi
leaq 0x93b51f6(%rip), %rsi # 0x9e3fe77
callq 0x7eb0f0
movq 0x3a8(%rsp), %rdi
movq 0x3b0(%rsp), %rsi
movq 0x398(%rsp), %rdx
movq 0x3a0(%rsp), %rcx
callq 0x7ed410
testb $0x1, %al
jne 0xa8ae95
movq 0x440(%rsp), %rax
movq %rax, 0x388(%rsp)
movq 0x448(%rsp), %rax
movq %rax, 0x390(%rsp)
leaq 0x378(%rsp), %rdi
leaq 0x7461505(%rip), %rsi # 0x7eec1e7
callq 0x7eb0f0
movq 0x388(%rsp), %rdi
movq 0x390(%rsp), %rsi
movq 0x378(%rsp), %rdx
movq 0x380(%rsp), %rcx
callq 0x7ed410
testb $0x1, %al
jne 0xa8ae95
movq 0x440(%rsp), %rax
movq %rax, 0x368(%rsp)
movq 0x448(%rsp), %rax
movq %rax, 0x370(%rsp)
leaq 0x358(%rsp), %rdi
leaq 0x74614a9(%rip), %rsi # 0x7eec1ec
callq 0x7eb0f0
movq 0x368(%rsp), %rdi
movq 0x370(%rsp), %rsi
movq 0x358(%rsp), %rdx
movq 0x360(%rsp), %rcx
callq 0x7ed410
testb $0x1, %al
jne 0xa8ae95
movq 0x440(%rsp), %rax
movq %rax, 0x348(%rsp)
movq 0x448(%rsp), %rax
movq %rax, 0x350(%rsp)
leaq 0x338(%rsp), %rdi
leaq 0x746144d(%rip), %rsi # 0x7eec1f1
callq 0x7eb0f0
movq 0x348(%rsp), %rdi
movq 0x350(%rsp), %rsi
movq 0x338(%rsp), %rdx
movq 0x340(%rsp), %rcx
callq 0x7ed410
testb $0x1, %al
jne 0xa8ae95
movq 0x440(%rsp), %rax
movq %rax, 0x328(%rsp)
movq 0x448(%rsp), %rax
movq %rax, 0x330(%rsp)
leaq 0x318(%rsp), %rdi
leaq 0x74613f1(%rip), %rsi # 0x7eec1f6
callq 0x7eb0f0
movq 0x328(%rsp), %rdi
movq 0x330(%rsp), %rsi
movq 0x318(%rsp), %rdx
movq 0x320(%rsp), %rcx
callq 0x7ed410
testb $0x1, %al
jne 0xa8ae95
movq 0x440(%rsp), %rax
movq %rax, 0x308(%rsp)
movq 0x448(%rsp), %rax
movq %rax, 0x310(%rsp)
leaq 0x2f8(%rsp), %rdi
leaq 0x746139a(%rip), %rsi # 0x7eec1fc
callq 0x7eb0f0
movq 0x308(%rsp), %rdi
movq 0x310(%rsp), %rsi
movq 0x2f8(%rsp), %rdx
movq 0x300(%rsp), %rcx
callq 0x7ed410
testb $0x1, %al
jne 0xa8ae95
jmp 0xa8b03e
movl $0x0, 0x2f4(%rsp)
leaq 0x2e0(%rsp), %rdi
leaq 0x7d2ea62(%rip), %rsi # 0x87b9911
callq 0x7eb0f0
movq 0x2e0(%rsp), %rsi
movq 0x2e8(%rsp), %rdx
leaq 0x440(%rsp), %rdi
callq 0x938c40
testb $0x1, %al
jne 0xa8af89
leaq 0x440(%rsp), %rdi
movl $0xa, %esi
leaq 0x2f4(%rsp), %rdx
callq 0x7edf10
andb $0x1, %al
movb %al, 0x2df(%rsp)
movq 0x480(%rsp), %rax
movq %rax, 0xd8(%rsp)
movq 0x488(%rsp), %rax
movq %rax, 0xd0(%rsp)
leaq 0x288(%rsp), %rdi
leaq 0x74548e3(%rip), %rsi # 0x7edf80e
callq 0x7f1850
movl 0x2f4(%rsp), %esi
shrl $0x7, %esi
leaq 0x260(%rsp), %rdi
callq 0xa6d1a0
leaq 0x2b0(%rsp), %rdi
leaq 0x288(%rsp), %rsi
leaq 0x260(%rsp), %rdx
callq 0x829f40
movq 0xd0(%rsp), %rdi
leaq 0x2b0(%rsp), %rsi
callq 0x829b10
movq 0xd8(%rsp), %rdi
movq %rax, %rsi
callq 0x809410
leaq 0x440(%rsp), %rdi
movl $0xa, %esi
leaq 0x2f4(%rsp), %rdx
callq 0x7edf10
andb $0x1, %al
movb %al, 0x25f(%rsp)
movq 0x480(%rsp), %rax
movq %rax, 0xc8(%rsp)
movq 0x488(%rsp), %rax
movq %rax, 0xc0(%rsp)
leaq 0x208(%rsp), %rdi
leaq 0x74548a8(%rip), %rsi # 0x7edf883
callq 0x7f1850
movl 0x2f4(%rsp), %esi
shrl $0x7, %esi
leaq 0x1e0(%rsp), %rdi
callq 0xa6d1a0
leaq 0x230(%rsp), %rdi
leaq 0x208(%rsp), %rsi
leaq 0x1e0(%rsp), %rdx
callq 0x829f40
movq 0xc0(%rsp), %rdi
leaq 0x230(%rsp), %rsi
callq 0x829b10
movq 0xc8(%rsp), %rdi
movq %rax, %rsi
callq 0x809410
jmp 0xa8b108
movq 0x440(%rsp), %rax
movq %rax, 0x1d0(%rsp)
movq 0x448(%rsp), %rax
movq %rax, 0x1d8(%rsp)
leaq 0x1c0(%rsp), %rdi
leaq 0x7535279(%rip), %rsi # 0x7fc02e6
callq 0x7eb0f0
movq 0x1d0(%rsp), %rdi
movq 0x1d8(%rsp), %rsi
movq 0x1c0(%rsp), %rdx
movq 0x1c8(%rsp), %rcx
callq 0x7f20f0
testb $0x1, %al
jne 0xa8b09d
jmp 0xa8b106
movq 0x438(%rsp), %rsi
leaq 0x1a0(%rsp), %rdi
movl $0x1e7, %edx # imm = 0x1E7
callq 0x9df2d0
movq 0x450(%rsp), %rdi
callq 0x83b7a0
movq %rax, 0x190(%rsp)
movq %rdx, 0x198(%rsp)
leaq 0x1a0(%rsp), %rdi
leaq 0x190(%rsp), %rsi
callq 0x973710
movq %rax, %rdi
leaq 0x440(%rsp), %rsi
callq 0x9d6350
leaq 0x1a0(%rsp), %rdi
callq 0x949780
jmp 0xa8b108
jmp 0xa8b10a
movq 0x488(%rsp), %rdi
movq 0x480(%rsp), %rsi
callq 0xa897b0
movq 0x488(%rsp), %rdi
movl $0xad5, %esi # imm = 0xAD5
callq 0x9e26c0
movq %rax, 0x188(%rsp)
cmpq $0x0, 0x188(%rsp)
je 0xa8b221
movq 0x480(%rsp), %rdi
leaq 0x7458b12(%rip), %rsi # 0x7ee3c69
callq 0x809410
movq 0x188(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq %rax, %rdi
leaq 0x7d20c6c(%rip), %rsi # 0x87abde1
callq 0x73a8a0
cmpl $0x0, %eax
jne 0xa8b1f0
movq 0x480(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq 0x488(%rsp), %rax
movq %rax, 0xb0(%rsp)
callq 0x929d60
movq %rax, 0x150(%rsp)
movq %rdx, 0x158(%rsp)
leaq 0x160(%rsp), %rdi
leaq 0x150(%rsp), %rsi
callq 0x7f18a0
movq 0xb0(%rsp), %rdi
leaq 0x160(%rsp), %rsi
callq 0x829b10
movq 0xb8(%rsp), %rdi
movq %rax, %rsi
callq 0x809410
jmp 0xa8b21f
movq 0x480(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0x188(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq 0xa8(%rsp), %rdi
movq %rax, %rsi
callq 0x809410
jmp 0xa8b221
movq 0x480(%rsp), %rdi
callq 0xa8a560
movq 0x488(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x480(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x14c(%rsp), %rdi
movl $0x640, %esi # imm = 0x640
callq 0x7eba60
leaq 0x148(%rsp), %rdi
movl $0x4f5, %esi # imm = 0x4F5
callq 0x7eba60
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0x14c(%rsp), %edx
movl 0x148(%rsp), %ecx
callq 0x828c20
movq 0x488(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x480(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x144(%rsp), %rdi
movl $0x63c, %esi # imm = 0x63C
callq 0x7eba60
leaq 0x140(%rsp), %rdi
movl $0x4f1, %esi # imm = 0x4F1
callq 0x7eba60
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x144(%rsp), %edx
movl 0x140(%rsp), %ecx
callq 0x828c20
movq 0x488(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x480(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x13c(%rsp), %rdi
movl $0x641, %esi # imm = 0x641
callq 0x7eba60
leaq 0x138(%rsp), %rdi
movl $0x4f6, %esi # imm = 0x4F6
callq 0x7eba60
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
movl 0x13c(%rsp), %edx
movl 0x138(%rsp), %ecx
callq 0x828c20
movq 0x488(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x480(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x134(%rsp), %rdi
movl $0x63b, %esi # imm = 0x63B
callq 0x7eba60
leaq 0x130(%rsp), %rdi
movl $0x4f0, %esi # imm = 0x4F0
callq 0x7eba60
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rsi
movl 0x134(%rsp), %edx
movl 0x130(%rsp), %ecx
callq 0x828c20
movq 0x488(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x480(%rsp), %rax
movq %rax, 0x50(%rsp)
leaq 0x12c(%rsp), %rdi
movl $0x643, %esi # imm = 0x643
callq 0x7eba60
leaq 0x128(%rsp), %rdi
movl $0x4f8, %esi # imm = 0x4F8
callq 0x7eba60
movq 0x48(%rsp), %rdi
movq 0x50(%rsp), %rsi
movl 0x12c(%rsp), %edx
movl 0x128(%rsp), %ecx
callq 0x828c20
movq 0x488(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x480(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x124(%rsp), %rdi
movl $0x644, %esi # imm = 0x644
callq 0x7eba60
leaq 0x120(%rsp), %rdi
movl $0x4f9, %esi # imm = 0x4F9
callq 0x7eba60
movq 0x58(%rsp), %rdi
movq 0x60(%rsp), %rsi
movl 0x124(%rsp), %edx
movl 0x120(%rsp), %ecx
callq 0x828c20
movq 0x488(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x480(%rsp), %rax
movq %rax, 0x70(%rsp)
leaq 0x11c(%rsp), %rdi
movl $0x642, %esi # imm = 0x642
callq 0x7eba60
leaq 0x118(%rsp), %rdi
movl $0x4f7, %esi # imm = 0x4F7
callq 0x7eba60
movq 0x68(%rsp), %rdi
movq 0x70(%rsp), %rsi
movl 0x11c(%rsp), %edx
movl 0x118(%rsp), %ecx
callq 0x828c20
movq 0x488(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x480(%rsp), %rax
movq %rax, 0x80(%rsp)
leaq 0x114(%rsp), %rdi
movl $0x63f, %esi # imm = 0x63F
callq 0x7eba60
leaq 0x110(%rsp), %rdi
movl $0x4f4, %esi # imm = 0x4F4
callq 0x7eba60
movq 0x78(%rsp), %rdi
movq 0x80(%rsp), %rsi
movl 0x114(%rsp), %edx
movl 0x110(%rsp), %ecx
callq 0x828c20
movq 0x488(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x480(%rsp), %rax
movq %rax, 0x90(%rsp)
leaq 0x10c(%rsp), %rdi
movl $0x63d, %esi # imm = 0x63D
callq 0x7eba60
leaq 0x108(%rsp), %rdi
movl $0x4f2, %esi # imm = 0x4F2
callq 0x7eba60
movq 0x88(%rsp), %rdi
movq 0x90(%rsp), %rsi
movl 0x10c(%rsp), %edx
movl 0x108(%rsp), %ecx
callq 0x828c20
movq 0x488(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x480(%rsp), %rax
movq %rax, 0xa0(%rsp)
leaq 0x104(%rsp), %rdi
movl $0x63e, %esi # imm = 0x63E
callq 0x7eba60
leaq 0x100(%rsp), %rdi
movl $0x4f3, %esi # imm = 0x4F3
callq 0x7eba60
movq 0x98(%rsp), %rdi
movq 0xa0(%rsp), %rsi
movl 0x104(%rsp), %edx
movl 0x100(%rsp), %ecx
callq 0x828c20
addq $0x498, %rsp # imm = 0x498
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /Driver/ToolChains/Clang.cpp |
addPGOAndCoverageFlags(clang::driver::ToolChain const&, clang::driver::Compilation&, clang::driver::JobAction const&, clang::driver::InputInfo const&, llvm::opt::ArgList const&, clang::driver::SanitizerArgs&, llvm::SmallVector<char const*, 16u>&) | static void addPGOAndCoverageFlags(const ToolChain &TC, Compilation &C,
const JobAction &JA, const InputInfo &Output,
const ArgList &Args, SanitizerArgs &SanArgs,
ArgStringList &CmdArgs) {
const Driver &D = TC.getDriver();
auto *PGOGenerateArg = Args.getLastArg(options::OPT_fprofile_generate,
options::OPT_fprofile_generate_EQ,
options::OPT_fno_profile_generate);
if (PGOGenerateArg &&
PGOGenerateArg->getOption().matches(options::OPT_fno_profile_generate))
PGOGenerateArg = nullptr;
auto *CSPGOGenerateArg = getLastCSProfileGenerateArg(Args);
auto *ProfileGenerateArg = Args.getLastArg(
options::OPT_fprofile_instr_generate,
options::OPT_fprofile_instr_generate_EQ,
options::OPT_fno_profile_instr_generate);
if (ProfileGenerateArg &&
ProfileGenerateArg->getOption().matches(
options::OPT_fno_profile_instr_generate))
ProfileGenerateArg = nullptr;
if (PGOGenerateArg && ProfileGenerateArg)
D.Diag(diag::err_drv_argument_not_allowed_with)
<< PGOGenerateArg->getSpelling() << ProfileGenerateArg->getSpelling();
auto *ProfileUseArg = getLastProfileUseArg(Args);
if (PGOGenerateArg && ProfileUseArg)
D.Diag(diag::err_drv_argument_not_allowed_with)
<< ProfileUseArg->getSpelling() << PGOGenerateArg->getSpelling();
if (ProfileGenerateArg && ProfileUseArg)
D.Diag(diag::err_drv_argument_not_allowed_with)
<< ProfileGenerateArg->getSpelling() << ProfileUseArg->getSpelling();
if (CSPGOGenerateArg && PGOGenerateArg) {
D.Diag(diag::err_drv_argument_not_allowed_with)
<< CSPGOGenerateArg->getSpelling() << PGOGenerateArg->getSpelling();
PGOGenerateArg = nullptr;
}
if (TC.getTriple().isOSAIX()) {
if (Arg *ProfileSampleUseArg = getLastProfileSampleUseArg(Args))
D.Diag(diag::err_drv_unsupported_opt_for_target)
<< ProfileSampleUseArg->getSpelling() << TC.getTriple().str();
}
if (ProfileGenerateArg) {
if (ProfileGenerateArg->getOption().matches(
options::OPT_fprofile_instr_generate_EQ))
CmdArgs.push_back(Args.MakeArgString(Twine("-fprofile-instrument-path=") +
ProfileGenerateArg->getValue()));
// The default is to use Clang Instrumentation.
CmdArgs.push_back("-fprofile-instrument=clang");
if (TC.getTriple().isWindowsMSVCEnvironment() &&
Args.hasFlag(options::OPT_frtlib_defaultlib,
options::OPT_fno_rtlib_defaultlib, true)) {
// Add dependent lib for clang_rt.profile
CmdArgs.push_back(Args.MakeArgString(
"--dependent-lib=" + TC.getCompilerRTBasename(Args, "profile")));
}
}
Arg *PGOGenArg = nullptr;
if (PGOGenerateArg) {
assert(!CSPGOGenerateArg);
PGOGenArg = PGOGenerateArg;
CmdArgs.push_back("-fprofile-instrument=llvm");
}
if (CSPGOGenerateArg) {
assert(!PGOGenerateArg);
PGOGenArg = CSPGOGenerateArg;
CmdArgs.push_back("-fprofile-instrument=csllvm");
}
if (PGOGenArg) {
if (TC.getTriple().isWindowsMSVCEnvironment() &&
Args.hasFlag(options::OPT_frtlib_defaultlib,
options::OPT_fno_rtlib_defaultlib, true)) {
// Add dependent lib for clang_rt.profile
CmdArgs.push_back(Args.MakeArgString(
"--dependent-lib=" + TC.getCompilerRTBasename(Args, "profile")));
}
if (PGOGenArg->getOption().matches(
PGOGenerateArg ? options::OPT_fprofile_generate_EQ
: options::OPT_fcs_profile_generate_EQ)) {
SmallString<128> Path(PGOGenArg->getValue());
llvm::sys::path::append(Path, "default_%m.profraw");
CmdArgs.push_back(
Args.MakeArgString(Twine("-fprofile-instrument-path=") + Path));
}
}
if (ProfileUseArg) {
if (ProfileUseArg->getOption().matches(options::OPT_fprofile_instr_use_EQ))
CmdArgs.push_back(Args.MakeArgString(
Twine("-fprofile-instrument-use-path=") + ProfileUseArg->getValue()));
else if ((ProfileUseArg->getOption().matches(
options::OPT_fprofile_use_EQ) ||
ProfileUseArg->getOption().matches(
options::OPT_fprofile_instr_use))) {
SmallString<128> Path(
ProfileUseArg->getNumValues() == 0 ? "" : ProfileUseArg->getValue());
if (Path.empty() || llvm::sys::fs::is_directory(Path))
llvm::sys::path::append(Path, "default.profdata");
CmdArgs.push_back(
Args.MakeArgString(Twine("-fprofile-instrument-use-path=") + Path));
}
}
bool EmitCovNotes = Args.hasFlag(options::OPT_ftest_coverage,
options::OPT_fno_test_coverage, false) ||
Args.hasArg(options::OPT_coverage);
bool EmitCovData = TC.needsGCovInstrumentation(Args);
if (Args.hasFlag(options::OPT_fcoverage_mapping,
options::OPT_fno_coverage_mapping, false)) {
if (!ProfileGenerateArg)
D.Diag(clang::diag::err_drv_argument_only_allowed_with)
<< "-fcoverage-mapping"
<< "-fprofile-instr-generate";
CmdArgs.push_back("-fcoverage-mapping");
}
if (Args.hasFlag(options::OPT_fmcdc_coverage, options::OPT_fno_mcdc_coverage,
false)) {
if (!Args.hasFlag(options::OPT_fcoverage_mapping,
options::OPT_fno_coverage_mapping, false))
D.Diag(clang::diag::err_drv_argument_only_allowed_with)
<< "-fcoverage-mcdc"
<< "-fcoverage-mapping";
CmdArgs.push_back("-fcoverage-mcdc");
}
if (Arg *A = Args.getLastArg(options::OPT_ffile_compilation_dir_EQ,
options::OPT_fcoverage_compilation_dir_EQ)) {
if (A->getOption().matches(options::OPT_ffile_compilation_dir_EQ))
CmdArgs.push_back(Args.MakeArgString(
Twine("-fcoverage-compilation-dir=") + A->getValue()));
else
A->render(Args, CmdArgs);
} else if (llvm::ErrorOr<std::string> CWD =
D.getVFS().getCurrentWorkingDirectory()) {
CmdArgs.push_back(Args.MakeArgString("-fcoverage-compilation-dir=" + *CWD));
}
if (Args.hasArg(options::OPT_fprofile_exclude_files_EQ)) {
auto *Arg = Args.getLastArg(options::OPT_fprofile_exclude_files_EQ);
if (!Args.hasArg(options::OPT_coverage))
D.Diag(clang::diag::err_drv_argument_only_allowed_with)
<< "-fprofile-exclude-files="
<< "--coverage";
StringRef v = Arg->getValue();
CmdArgs.push_back(
Args.MakeArgString(Twine("-fprofile-exclude-files=" + v)));
}
if (Args.hasArg(options::OPT_fprofile_filter_files_EQ)) {
auto *Arg = Args.getLastArg(options::OPT_fprofile_filter_files_EQ);
if (!Args.hasArg(options::OPT_coverage))
D.Diag(clang::diag::err_drv_argument_only_allowed_with)
<< "-fprofile-filter-files="
<< "--coverage";
StringRef v = Arg->getValue();
CmdArgs.push_back(Args.MakeArgString(Twine("-fprofile-filter-files=" + v)));
}
if (const auto *A = Args.getLastArg(options::OPT_fprofile_update_EQ)) {
StringRef Val = A->getValue();
if (Val == "atomic" || Val == "prefer-atomic")
CmdArgs.push_back("-fprofile-update=atomic");
else if (Val != "single")
D.Diag(diag::err_drv_unsupported_option_argument)
<< A->getSpelling() << Val;
}
int FunctionGroups = 1;
int SelectedFunctionGroup = 0;
if (const auto *A = Args.getLastArg(options::OPT_fprofile_function_groups)) {
StringRef Val = A->getValue();
if (Val.getAsInteger(0, FunctionGroups) || FunctionGroups < 1)
D.Diag(diag::err_drv_invalid_int_value) << A->getAsString(Args) << Val;
}
if (const auto *A =
Args.getLastArg(options::OPT_fprofile_selected_function_group)) {
StringRef Val = A->getValue();
if (Val.getAsInteger(0, SelectedFunctionGroup) ||
SelectedFunctionGroup < 0 || SelectedFunctionGroup >= FunctionGroups)
D.Diag(diag::err_drv_invalid_int_value) << A->getAsString(Args) << Val;
}
if (FunctionGroups != 1)
CmdArgs.push_back(Args.MakeArgString("-fprofile-function-groups=" +
Twine(FunctionGroups)));
if (SelectedFunctionGroup != 0)
CmdArgs.push_back(Args.MakeArgString("-fprofile-selected-function-group=" +
Twine(SelectedFunctionGroup)));
// Leave -fprofile-dir= an unused argument unless .gcda emission is
// enabled. To be polite, with '-fprofile-arcs -fno-profile-arcs' consider
// the flag used. There is no -fno-profile-dir, so the user has no
// targeted way to suppress the warning.
Arg *FProfileDir = nullptr;
if (Args.hasArg(options::OPT_fprofile_arcs) ||
Args.hasArg(options::OPT_coverage))
FProfileDir = Args.getLastArg(options::OPT_fprofile_dir);
// TODO: Don't claim -c/-S to warn about -fsyntax-only -c/-S, -E -c/-S,
// like we warn about -fsyntax-only -E.
(void)(Args.hasArg(options::OPT_c) || Args.hasArg(options::OPT_S));
// Put the .gcno and .gcda files (if needed) next to the primary output file,
// or fall back to a file in the current directory for `clang -c --coverage
// d/a.c` in the absence of -o.
if (EmitCovNotes || EmitCovData) {
SmallString<128> CoverageFilename;
if (Arg *DumpDir = Args.getLastArgNoClaim(options::OPT_dumpdir)) {
// Form ${dumpdir}${basename}.gcno. Note that dumpdir may not end with a
// path separator.
CoverageFilename = DumpDir->getValue();
CoverageFilename += llvm::sys::path::filename(Output.getBaseInput());
} else if (Arg *FinalOutput =
C.getArgs().getLastArg(options::OPT__SLASH_Fo)) {
CoverageFilename = FinalOutput->getValue();
} else if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o)) {
CoverageFilename = FinalOutput->getValue();
} else {
CoverageFilename = llvm::sys::path::filename(Output.getBaseInput());
}
if (llvm::sys::path::is_relative(CoverageFilename))
(void)D.getVFS().makeAbsolute(CoverageFilename);
llvm::sys::path::replace_extension(CoverageFilename, "gcno");
if (EmitCovNotes) {
CmdArgs.push_back(
Args.MakeArgString("-coverage-notes-file=" + CoverageFilename));
}
if (EmitCovData) {
if (FProfileDir) {
SmallString<128> Gcno = std::move(CoverageFilename);
CoverageFilename = FProfileDir->getValue();
llvm::sys::path::append(CoverageFilename, Gcno);
}
llvm::sys::path::replace_extension(CoverageFilename, "gcda");
CmdArgs.push_back(
Args.MakeArgString("-coverage-data-file=" + CoverageFilename));
}
}
} | subq $0x10e8, %rsp # imm = 0x10E8
movq 0x10f0(%rsp), %rax
movq %rdi, 0x10e0(%rsp)
movq %rsi, 0x10d8(%rsp)
movq %rdx, 0x10d0(%rsp)
movq %rcx, 0x10c8(%rsp)
movq %r8, 0x10c0(%rsp)
movq %r9, 0x10b8(%rsp)
movq 0x10e0(%rsp), %rdi
callq 0x9ffc60
movq %rax, 0x10b0(%rsp)
movq 0x10c0(%rsp), %rdi
movl $0x625, %esi # imm = 0x625
movl $0x624, %edx # imm = 0x624
movl $0x4e5, %ecx # imm = 0x4E5
callq 0x9f16c0
movq %rax, 0x10a8(%rsp)
cmpq $0x0, 0x10a8(%rsp)
je 0xaac1b0
movq 0x10a8(%rsp), %rdi
callq 0x7ee280
movq %rax, 0x1a8(%rsp)
leaq 0x10a4(%rsp), %rdi
movl $0x4e5, %esi # imm = 0x4E5
callq 0x7eba60
movq 0x1a8(%rsp), %rdi
movl 0x10a4(%rsp), %esi
callq 0x82f0e0
testb $0x1, %al
jne 0xaac1a4
jmp 0xaac1b0
movq $0x0, 0x10a8(%rsp)
movq 0x10c0(%rsp), %rdi
callq 0xaccac0
movq %rax, 0x1098(%rsp)
movq 0x10c0(%rsp), %rdi
movl $0x627, %esi # imm = 0x627
movl $0x626, %edx # imm = 0x626
movl $0x4e6, %ecx # imm = 0x4E6
callq 0x9f16c0
movq %rax, 0x1090(%rsp)
cmpq $0x0, 0x1090(%rsp)
je 0xaac241
movq 0x1090(%rsp), %rdi
callq 0x7ee280
movq %rax, 0x1a0(%rsp)
leaq 0x108c(%rsp), %rdi
movl $0x4e6, %esi # imm = 0x4E6
callq 0x7eba60
movq 0x1a0(%rsp), %rdi
movl 0x108c(%rsp), %esi
callq 0x82f0e0
testb $0x1, %al
jne 0xaac235
jmp 0xaac241
movq $0x0, 0x1090(%rsp)
cmpq $0x0, 0x10a8(%rsp)
je 0xaac2f2
cmpq $0x0, 0x1090(%rsp)
je 0xaac2f2
movq 0x10b0(%rsp), %rsi
leaq 0x1068(%rsp), %rdi
movl $0x143, %edx # imm = 0x143
callq 0x9df2d0
movq 0x10a8(%rsp), %rdi
callq 0x83b7a0
movq %rax, 0x1058(%rsp)
movq %rdx, 0x1060(%rsp)
leaq 0x1068(%rsp), %rdi
leaq 0x1058(%rsp), %rsi
callq 0x973710
movq %rax, 0x198(%rsp)
movq 0x1090(%rsp), %rdi
callq 0x83b7a0
movq 0x198(%rsp), %rdi
movq %rax, 0x1048(%rsp)
movq %rdx, 0x1050(%rsp)
leaq 0x1048(%rsp), %rsi
callq 0x973710
leaq 0x1068(%rsp), %rdi
callq 0x949780
movq 0x10c0(%rsp), %rdi
callq 0xaccb40
movq %rax, 0x1040(%rsp)
cmpq $0x0, 0x10a8(%rsp)
je 0xaac3b8
cmpq $0x0, 0x1040(%rsp)
je 0xaac3b8
movq 0x10b0(%rsp), %rsi
leaq 0x1020(%rsp), %rdi
movl $0x143, %edx # imm = 0x143
callq 0x9df2d0
movq 0x1040(%rsp), %rdi
callq 0x83b7a0
movq %rax, 0x1010(%rsp)
movq %rdx, 0x1018(%rsp)
leaq 0x1020(%rsp), %rdi
leaq 0x1010(%rsp), %rsi
callq 0x973710
movq %rax, 0x190(%rsp)
movq 0x10a8(%rsp), %rdi
callq 0x83b7a0
movq 0x190(%rsp), %rdi
movq %rax, 0x1000(%rsp)
movq %rdx, 0x1008(%rsp)
leaq 0x1000(%rsp), %rsi
callq 0x973710
leaq 0x1020(%rsp), %rdi
callq 0x949780
cmpq $0x0, 0x1090(%rsp)
je 0xaac469
cmpq $0x0, 0x1040(%rsp)
je 0xaac469
movq 0x10b0(%rsp), %rsi
leaq 0xfe0(%rsp), %rdi
movl $0x143, %edx # imm = 0x143
callq 0x9df2d0
movq 0x1090(%rsp), %rdi
callq 0x83b7a0
movq %rax, 0xfd0(%rsp)
movq %rdx, 0xfd8(%rsp)
leaq 0xfe0(%rsp), %rdi
leaq 0xfd0(%rsp), %rsi
callq 0x973710
movq %rax, 0x188(%rsp)
movq 0x1040(%rsp), %rdi
callq 0x83b7a0
movq 0x188(%rsp), %rdi
movq %rax, 0xfc0(%rsp)
movq %rdx, 0xfc8(%rsp)
leaq 0xfc0(%rsp), %rsi
callq 0x973710
leaq 0xfe0(%rsp), %rdi
callq 0x949780
cmpq $0x0, 0x1098(%rsp)
je 0xaac526
cmpq $0x0, 0x10a8(%rsp)
je 0xaac526
movq 0x10b0(%rsp), %rsi
leaq 0xfa0(%rsp), %rdi
movl $0x143, %edx # imm = 0x143
callq 0x9df2d0
movq 0x1098(%rsp), %rdi
callq 0x83b7a0
movq %rax, 0xf90(%rsp)
movq %rdx, 0xf98(%rsp)
leaq 0xfa0(%rsp), %rdi
leaq 0xf90(%rsp), %rsi
callq 0x973710
movq %rax, 0x180(%rsp)
movq 0x10a8(%rsp), %rdi
callq 0x83b7a0
movq 0x180(%rsp), %rdi
movq %rax, 0xf80(%rsp)
movq %rdx, 0xf88(%rsp)
leaq 0xf80(%rsp), %rsi
callq 0x973710
leaq 0xfa0(%rsp), %rdi
callq 0x949780
movq $0x0, 0x10a8(%rsp)
movq 0x10e0(%rsp), %rdi
callq 0x9df070
movq %rax, %rdi
callq 0x93d250
testb $0x1, %al
jne 0xaac544
jmp 0xaac5f0
movq 0x10c0(%rsp), %rdi
callq 0xacc9e0
movq %rax, 0xf78(%rsp)
cmpq $0x0, 0xf78(%rsp)
je 0xaac5ee
movq 0x10b0(%rsp), %rsi
leaq 0xf58(%rsp), %rdi
movl $0x1e5, %edx # imm = 0x1E5
callq 0x9df2d0
movq 0xf78(%rsp), %rdi
callq 0x83b7a0
movq %rax, 0xf48(%rsp)
movq %rdx, 0xf50(%rsp)
leaq 0xf58(%rsp), %rdi
leaq 0xf48(%rsp), %rsi
callq 0x973710
movq %rax, 0x178(%rsp)
movq 0x10e0(%rsp), %rdi
callq 0x9df070
movq %rax, %rdi
callq 0x92f640
movq 0x178(%rsp), %rdi
movq %rax, %rsi
callq 0x949720
leaq 0xf58(%rsp), %rdi
callq 0x949780
jmp 0xaac5f0
cmpq $0x0, 0x1090(%rsp)
je 0xaac860
movq 0x1090(%rsp), %rdi
callq 0x7ee280
movq %rax, 0x170(%rsp)
leaq 0xf44(%rsp), %rdi
movl $0x626, %esi # imm = 0x626
callq 0x7eba60
movq 0x170(%rsp), %rdi
movl 0xf44(%rsp), %esi
callq 0x82f0e0
testb $0x1, %al
jne 0xaac643
jmp 0xaac6d8
movq 0x10f0(%rsp), %rax
movq %rax, 0x168(%rsp)
movq 0x10c0(%rsp), %rax
movq %rax, 0x160(%rsp)
leaq 0xef0(%rsp), %rdi
leaq 0x74251ae(%rip), %rsi # 0x7ed1820
callq 0x7f1850
movq 0x1090(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq %rax, %rsi
leaq 0xec8(%rsp), %rdi
callq 0x7f1850
leaq 0xf18(%rsp), %rdi
leaq 0xef0(%rsp), %rsi
leaq 0xec8(%rsp), %rdx
callq 0x829f40
movq 0x160(%rsp), %rdi
leaq 0xf18(%rsp), %rsi
callq 0x829b10
movq 0x168(%rsp), %rdi
movq %rax, %rsi
callq 0x809410
movq 0x10f0(%rsp), %rdi
leaq 0x7440b4e(%rip), %rsi # 0x7eed235
callq 0x809410
movq 0x10e0(%rsp), %rdi
callq 0x9df070
movq %rax, %rdi
callq 0x9f7a00
testb $0x1, %al
jne 0xaac70a
jmp 0xaac85e
movq 0x10c0(%rsp), %rax
movq %rax, 0x158(%rsp)
leaq 0xec4(%rsp), %rdi
movl $0x668, %esi # imm = 0x668
callq 0x7eba60
leaq 0xec0(%rsp), %rdi
movl $0x516, %esi # imm = 0x516
callq 0x7eba60
movq 0x158(%rsp), %rdi
movl 0xec4(%rsp), %esi
movl 0xec0(%rsp), %edx
movl $0x1, %ecx
callq 0x828060
testb $0x1, %al
jne 0xaac767
jmp 0xaac85e
movq 0x10f0(%rsp), %rax
movq %rax, 0x150(%rsp)
movq 0x10c0(%rsp), %rax
movq %rax, 0x148(%rsp)
movq 0x10e0(%rsp), %rax
movq %rax, 0x138(%rsp)
movq 0x10c0(%rsp), %rax
movq %rax, 0x140(%rsp)
leaq 0xe48(%rsp), %rdi
leaq 0x939249b(%rip), %rsi # 0x9e3ec51
callq 0x7eb0f0
movq 0x138(%rsp), %rsi
movq 0x140(%rsp), %rdx
movq 0xe48(%rsp), %rcx
movq 0xe50(%rsp), %r8
leaq 0xe58(%rsp), %rdi
movl $0x1, %r9d
callq 0xa4bb30
leaq 0xe78(%rsp), %rdi
leaq 0x7413975(%rip), %rsi # 0x7ec0172
leaq 0xe58(%rsp), %rdx
callq 0x87e5e0
leaq 0xe98(%rsp), %rdi
leaq 0xe78(%rsp), %rsi
callq 0x7fcea0
movq 0x148(%rsp), %rdi
leaq 0xe98(%rsp), %rsi
callq 0x829b10
movq 0x150(%rsp), %rdi
movq %rax, %rsi
callq 0x809410
leaq 0xe78(%rsp), %rdi
callq 0x73b5d0
leaq 0xe58(%rsp), %rdi
callq 0x73b5d0
jmp 0xaac860
movq $0x0, 0xe40(%rsp)
cmpq $0x0, 0x10a8(%rsp)
je 0xaac89b
movq 0x10a8(%rsp), %rax
movq %rax, 0xe40(%rsp)
movq 0x10f0(%rsp), %rdi
leaq 0x74409ba(%rip), %rsi # 0x7eed250
callq 0x809410
cmpq $0x0, 0x1098(%rsp)
je 0xaac8ca
movq 0x1098(%rsp), %rax
movq %rax, 0xe40(%rsp)
movq 0x10f0(%rsp), %rdi
leaq 0x74409a5(%rip), %rsi # 0x7eed26a
callq 0x809410
cmpq $0x0, 0xe40(%rsp)
je 0xaacbf6
movq 0x10e0(%rsp), %rdi
callq 0x9df070
movq %rax, %rdi
callq 0x9f7a00
testb $0x1, %al
jne 0xaac8f7
jmp 0xaaca4b
movq 0x10c0(%rsp), %rax
movq %rax, 0x130(%rsp)
leaq 0xe3c(%rsp), %rdi
movl $0x668, %esi # imm = 0x668
callq 0x7eba60
leaq 0xe38(%rsp), %rdi
movl $0x516, %esi # imm = 0x516
callq 0x7eba60
movq 0x130(%rsp), %rdi
movl 0xe3c(%rsp), %esi
movl 0xe38(%rsp), %edx
movl $0x1, %ecx
callq 0x828060
testb $0x1, %al
jne 0xaac954
jmp 0xaaca4b
movq 0x10f0(%rsp), %rax
movq %rax, 0x128(%rsp)
movq 0x10c0(%rsp), %rax
movq %rax, 0x120(%rsp)
movq 0x10e0(%rsp), %rax
movq %rax, 0x110(%rsp)
movq 0x10c0(%rsp), %rax
movq %rax, 0x118(%rsp)
leaq 0xdc0(%rsp), %rdi
leaq 0x93922ae(%rip), %rsi # 0x9e3ec51
callq 0x7eb0f0
movq 0x110(%rsp), %rsi
movq 0x118(%rsp), %rdx
movq 0xdc0(%rsp), %rcx
movq 0xdc8(%rsp), %r8
leaq 0xdd0(%rsp), %rdi
movl $0x1, %r9d
callq 0xa4bb30
leaq 0xdf0(%rsp), %rdi
leaq 0x7413788(%rip), %rsi # 0x7ec0172
leaq 0xdd0(%rsp), %rdx
callq 0x87e5e0
leaq 0xe10(%rsp), %rdi
leaq 0xdf0(%rsp), %rsi
callq 0x7fcea0
movq 0x120(%rsp), %rdi
leaq 0xe10(%rsp), %rsi
callq 0x829b10
movq 0x128(%rsp), %rdi
movq %rax, %rsi
callq 0x809410
leaq 0xdf0(%rsp), %rdi
callq 0x73b5d0
leaq 0xdd0(%rsp), %rdi
callq 0x73b5d0
movq 0xe40(%rsp), %rdi
callq 0x7ee280
movq %rax, 0x108(%rsp)
movq 0x10a8(%rsp), %rcx
movl $0x20f, %esi # imm = 0x20F
movl $0x624, %eax # imm = 0x624
cmpq $0x0, %rcx
cmovnel %eax, %esi
leaq 0xdbc(%rsp), %rdi
callq 0x7eba60
movq 0x108(%rsp), %rdi
movl 0xdbc(%rsp), %esi
callq 0x82f0e0
testb $0x1, %al
jne 0xaacaa3
jmp 0xaacbf4
movq 0xe40(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq %rax, %rsi
leaq 0xd10(%rsp), %rdi
callq 0x7eb0f0
movq 0xd10(%rsp), %rsi
movq 0xd18(%rsp), %rdx
leaq 0xd20(%rsp), %rdi
callq 0x89c250
leaq 0xce8(%rsp), %rdi
leaq 0x74410f4(%rip), %rsi # 0x7eedbe2
callq 0x7f1850
leaq 0xcc0(%rsp), %rdi
leaq 0x7466137(%rip), %rsi # 0x7f12c39
callq 0x7f1850
leaq 0xc98(%rsp), %rdi
leaq 0x7466123(%rip), %rsi # 0x7f12c39
callq 0x7f1850
leaq 0xc70(%rsp), %rdi
leaq 0x746610f(%rip), %rsi # 0x7f12c39
callq 0x7f1850
leaq 0xd20(%rsp), %rdi
leaq 0xce8(%rsp), %rsi
leaq 0xcc0(%rsp), %rdx
leaq 0xc98(%rsp), %rcx
leaq 0xc70(%rsp), %r8
callq 0x8dc680
movq 0x10f0(%rsp), %rax
movq %rax, 0x100(%rsp)
movq 0x10c0(%rsp), %rax
movq %rax, 0xf8(%rsp)
leaq 0xc20(%rsp), %rdi
leaq 0x7424c95(%rip), %rsi # 0x7ed1820
callq 0x7f1850
leaq 0xbf8(%rsp), %rdi
leaq 0xd20(%rsp), %rsi
callq 0x820ac0
leaq 0xc48(%rsp), %rdi
leaq 0xc20(%rsp), %rsi
leaq 0xbf8(%rsp), %rdx
callq 0x829f40
movq 0xf8(%rsp), %rdi
leaq 0xc48(%rsp), %rsi
callq 0x829b10
movq 0x100(%rsp), %rdi
movq %rax, %rsi
callq 0x809410
leaq 0xd20(%rsp), %rdi
callq 0x7f6e10
jmp 0xaacbf6
cmpq $0x0, 0x1040(%rsp)
je 0xaacf3e
movq 0x1040(%rsp), %rdi
callq 0x7ee280
movq %rax, 0xf0(%rsp)
leaq 0xbf4(%rsp), %rdi
movl $0x628, %esi # imm = 0x628
callq 0x7eba60
movq 0xf0(%rsp), %rdi
movl 0xbf4(%rsp), %esi
callq 0x82f0e0
testb $0x1, %al
jne 0xaacc49
jmp 0xaacce3
movq 0x10f0(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0x10c0(%rsp), %rax
movq %rax, 0xe0(%rsp)
leaq 0xba0(%rsp), %rdi
leaq 0x7424bc3(%rip), %rsi # 0x7ed183b
callq 0x7f1850
movq 0x1040(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq %rax, %rsi
leaq 0xb78(%rsp), %rdi
callq 0x7f1850
leaq 0xbc8(%rsp), %rdi
leaq 0xba0(%rsp), %rsi
leaq 0xb78(%rsp), %rdx
callq 0x829f40
movq 0xe0(%rsp), %rdi
leaq 0xbc8(%rsp), %rsi
callq 0x829b10
movq 0xe8(%rsp), %rdi
movq %rax, %rsi
callq 0x809410
jmp 0xaacf3c
movq 0x1040(%rsp), %rdi
callq 0x7ee280
movq %rax, 0xd8(%rsp)
leaq 0xb74(%rsp), %rdi
movl $0x635, %esi # imm = 0x635
callq 0x7eba60
movq 0xd8(%rsp), %rdi
movl 0xb74(%rsp), %esi
callq 0x82f0e0
testb $0x1, %al
jne 0xaacd66
movq 0x1040(%rsp), %rdi
callq 0x7ee280
movq %rax, 0xd0(%rsp)
leaq 0xb70(%rsp), %rdi
movl $0x629, %esi # imm = 0x629
callq 0x7eba60
movq 0xd0(%rsp), %rdi
movl 0xb70(%rsp), %esi
callq 0x82f0e0
testb $0x1, %al
jne 0xaacd66
jmp 0xaacf3a
movq 0x1040(%rsp), %rdi
callq 0x83b7c0
cmpl $0x0, %eax
jne 0xaacd89
leaq 0x7465eba(%rip), %rax # 0x7f12c39
movq %rax, 0xc8(%rsp)
jmp 0xaacda0
movq 0x1040(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq %rax, 0xc8(%rsp)
movq 0xc8(%rsp), %rsi
leaq 0xac8(%rsp), %rdi
callq 0x7eb0f0
movq 0xac8(%rsp), %rsi
movq 0xad0(%rsp), %rdx
leaq 0xad8(%rsp), %rdi
callq 0x89c250
leaq 0xad8(%rsp), %rdi
callq 0x87e350
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0xc7(%rsp)
jne 0xaace18
leaq 0xaa0(%rsp), %rdi
leaq 0xad8(%rsp), %rsi
callq 0x820ac0
leaq 0xaa0(%rsp), %rdi
callq 0xa07b10
movb %al, 0xc7(%rsp)
movb 0xc7(%rsp), %al
testb $0x1, %al
jne 0xaace25
jmp 0xaacea2
leaq 0xa78(%rsp), %rdi
leaq 0x7440452(%rip), %rsi # 0x7eed286
callq 0x7f1850
leaq 0xa50(%rsp), %rdi
leaq 0x7465df1(%rip), %rsi # 0x7f12c39
callq 0x7f1850
leaq 0xa28(%rsp), %rdi
leaq 0x7465ddd(%rip), %rsi # 0x7f12c39
callq 0x7f1850
leaq 0xa00(%rsp), %rdi
leaq 0x7465dc9(%rip), %rsi # 0x7f12c39
callq 0x7f1850
leaq 0xad8(%rsp), %rdi
leaq 0xa78(%rsp), %rsi
leaq 0xa50(%rsp), %rdx
leaq 0xa28(%rsp), %rcx
leaq 0xa00(%rsp), %r8
callq 0x8dc680
movq 0x10f0(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq 0x10c0(%rsp), %rax
movq %rax, 0xb0(%rsp)
leaq 0x9b0(%rsp), %rdi
leaq 0x742496a(%rip), %rsi # 0x7ed183b
callq 0x7f1850
leaq 0x988(%rsp), %rdi
leaq 0xad8(%rsp), %rsi
callq 0x820ac0
leaq 0x9d8(%rsp), %rdi
leaq 0x9b0(%rsp), %rsi
leaq 0x988(%rsp), %rdx
callq 0x829f40
movq 0xb0(%rsp), %rdi
leaq 0x9d8(%rsp), %rsi
callq 0x829b10
movq 0xb8(%rsp), %rdi
movq %rax, %rsi
callq 0x809410
leaq 0xad8(%rsp), %rdi
callq 0x7f6e10
jmp 0xaacf3c
jmp 0xaacf3e
movq 0x10c0(%rsp), %rax
movq %rax, 0xa0(%rsp)
leaq 0x980(%rsp), %rdi
movl $0x6f0, %esi # imm = 0x6F0
callq 0x7eba60
leaq 0x97c(%rsp), %rdi
movl $0x565, %esi # imm = 0x565
callq 0x7eba60
movq 0xa0(%rsp), %rdi
movl 0x980(%rsp), %esi
movl 0x97c(%rsp), %edx
xorl %ecx, %ecx
callq 0x828060
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0xaf(%rsp)
jne 0xaacfb8
movq 0x10c0(%rsp), %rdi
movl $0xec, %esi
callq 0x9df320
movb %al, 0xaf(%rsp)
movb 0xaf(%rsp), %al
andb $0x1, %al
movb %al, 0x987(%rsp)
movq 0x10c0(%rsp), %rdi
callq 0xa4d730
andb $0x1, %al
movb %al, 0x97b(%rsp)
movq 0x10c0(%rsp), %rax
movq %rax, 0x98(%rsp)
leaq 0x974(%rsp), %rdi
movl $0x207, %esi # imm = 0x207
callq 0x7eba60
leaq 0x970(%rsp), %rdi
movl $0x408, %esi # imm = 0x408
callq 0x7eba60
movq 0x98(%rsp), %rdi
movl 0x974(%rsp), %esi
movl 0x970(%rsp), %edx
xorl %ecx, %ecx
callq 0x828060
testb $0x1, %al
jne 0xaad035
jmp 0xaad09e
cmpq $0x0, 0x1090(%rsp)
jne 0xaad08a
movq 0x10b0(%rsp), %rsi
leaq 0x950(%rsp), %rdi
movl $0x144, %edx # imm = 0x144
callq 0x9df2d0
leaq 0x950(%rsp), %rdi
leaq 0x741645c(%rip), %rsi # 0x7ec34c5
callq 0x9ec060
movq %rax, %rdi
leaq 0x742469c(%rip), %rsi # 0x7ed1714
callq 0x9ed590
leaq 0x950(%rsp), %rdi
callq 0x949780
movq 0x10f0(%rsp), %rdi
leaq 0x741642c(%rip), %rsi # 0x7ec34c5
callq 0x809410
movq 0x10c0(%rsp), %rax
movq %rax, 0x90(%rsp)
leaq 0x94c(%rsp), %rdi
movl $0x208, %esi # imm = 0x208
callq 0x7eba60
leaq 0x948(%rsp), %rdi
movl $0x409, %esi # imm = 0x409
callq 0x7eba60
movq 0x90(%rsp), %rdi
movl 0x94c(%rsp), %esi
movl 0x948(%rsp), %edx
xorl %ecx, %ecx
callq 0x828060
testb $0x1, %al
jne 0xaad0f8
jmp 0xaad1ab
movq 0x10c0(%rsp), %rax
movq %rax, 0x88(%rsp)
leaq 0x944(%rsp), %rdi
movl $0x207, %esi # imm = 0x207
callq 0x7eba60
leaq 0x940(%rsp), %rdi
movl $0x408, %esi # imm = 0x408
callq 0x7eba60
movq 0x88(%rsp), %rdi
movl 0x944(%rsp), %esi
movl 0x940(%rsp), %edx
xorl %ecx, %ecx
callq 0x828060
testb $0x1, %al
jne 0xaad197
movq 0x10b0(%rsp), %rsi
leaq 0x920(%rsp), %rdi
movl $0x144, %edx # imm = 0x144
callq 0x9df2d0
leaq 0x920(%rsp), %rdi
leaq 0x741639d(%rip), %rsi # 0x7ec3513
callq 0xabec50
movq %rax, %rdi
leaq 0x7416340(%rip), %rsi # 0x7ec34c5
callq 0x9ec060
leaq 0x920(%rsp), %rdi
callq 0x949780
movq 0x10f0(%rsp), %rdi
leaq 0x741636d(%rip), %rsi # 0x7ec3513
callq 0x809410
movq 0x10c0(%rsp), %rdi
movl $0x2a9, %esi # imm = 0x2A9
movl $0x206, %edx # imm = 0x206
callq 0x9e50a0
movq %rax, 0x918(%rsp)
cmpq $0x0, 0x918(%rsp)
je 0xaad2ca
movq 0x918(%rsp), %rdi
callq 0x7ee280
movq %rax, 0x80(%rsp)
leaq 0x914(%rsp), %rdi
movl $0x2a9, %esi # imm = 0x2A9
callq 0x7eba60
movq 0x80(%rsp), %rdi
movl 0x914(%rsp), %esi
callq 0x82f0e0
testb $0x1, %al
jne 0xaad21d
jmp 0xaad2a8
movq 0x10f0(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x10c0(%rsp), %rax
movq %rax, 0x70(%rsp)
leaq 0x8c0(%rsp), %rdi
leaq 0x7416227(%rip), %rsi # 0x7ec346d
callq 0x7f1850
movq 0x918(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq %rax, %rsi
leaq 0x898(%rsp), %rdi
callq 0x7f1850
leaq 0x8e8(%rsp), %rdi
leaq 0x8c0(%rsp), %rsi
leaq 0x898(%rsp), %rdx
callq 0x829f40
movq 0x70(%rsp), %rdi
leaq 0x8e8(%rsp), %rsi
callq 0x829b10
movq 0x78(%rsp), %rdi
movq %rax, %rsi
callq 0x809410
jmp 0xaad2c5
movq 0x918(%rsp), %rdi
movq 0x10c0(%rsp), %rsi
movq 0x10f0(%rsp), %rdx
callq 0x83b250
jmp 0xaad387
movq 0x10b0(%rsp), %rdi
callq 0x9ec040
movq %rax, %rsi
movq (%rsi), %rax
leaq 0x870(%rsp), %rdi
callq *0x48(%rax)
leaq 0x870(%rsp), %rdi
callq 0x841730
testb $0x1, %al
jne 0xaad2fb
jmp 0xaad37a
movq 0x10f0(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x10c0(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x870(%rsp), %rdi
callq 0x841750
movq %rax, %rdx
leaq 0x828(%rsp), %rdi
leaq 0x7416139(%rip), %rsi # 0x7ec346d
callq 0x81d810
leaq 0x848(%rsp), %rdi
leaq 0x828(%rsp), %rsi
callq 0x7fcea0
movq 0x60(%rsp), %rdi
leaq 0x848(%rsp), %rsi
callq 0x829b10
movq 0x68(%rsp), %rdi
movq %rax, %rsi
callq 0x809410
leaq 0x828(%rsp), %rdi
callq 0x73b5d0
leaq 0x870(%rsp), %rdi
callq 0x81a3b0
movq 0x10c0(%rsp), %rdi
movl $0x620, %esi # imm = 0x620
callq 0x9df320
testb $0x1, %al
jne 0xaad3a2
jmp 0xaad490
movq 0x10c0(%rsp), %rdi
movl $0x620, %esi # imm = 0x620
callq 0x9e26c0
movq %rax, 0x820(%rsp)
movq 0x10c0(%rsp), %rdi
movl $0xec, %esi
callq 0x9df320
testb $0x1, %al
jne 0xaad41c
movq 0x10b0(%rsp), %rsi
leaq 0x800(%rsp), %rdi
movl $0x144, %edx # imm = 0x144
callq 0x9df2d0
leaq 0x800(%rsp), %rdi
leaq 0x7423fc7(%rip), %rsi # 0x7ed13c2
callq 0x9ed590
movq %rax, %rdi
leaq 0x743fe8d(%rip), %rsi # 0x7eed297
callq 0xab5930
leaq 0x800(%rsp), %rdi
callq 0x949780
movq 0x820(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq %rax, %rsi
leaq 0x7f0(%rsp), %rdi
callq 0x7eb0f0
movq 0x10f0(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x10c0(%rsp), %rax
movq %rax, 0x50(%rsp)
leaq 0x7c8(%rsp), %rdi
leaq 0x7423f5e(%rip), %rsi # 0x7ed13c2
leaq 0x7f0(%rsp), %rdx
callq 0x840960
movq 0x50(%rsp), %rdi
leaq 0x7c8(%rsp), %rsi
callq 0x829b10
movq 0x58(%rsp), %rdi
movq %rax, %rsi
callq 0x809410
movq 0x10c0(%rsp), %rdi
movl $0x621, %esi # imm = 0x621
callq 0x9df320
testb $0x1, %al
jne 0xaad4ab
jmp 0xaad599
movq 0x10c0(%rsp), %rdi
movl $0x621, %esi # imm = 0x621
callq 0x9e26c0
movq %rax, 0x7c0(%rsp)
movq 0x10c0(%rsp), %rdi
movl $0xec, %esi
callq 0x9df320
testb $0x1, %al
jne 0xaad525
movq 0x10b0(%rsp), %rsi
leaq 0x7a0(%rsp), %rdi
movl $0x144, %edx # imm = 0x144
callq 0x9df2d0
leaq 0x7a0(%rsp), %rdi
leaq 0x7423f3e(%rip), %rsi # 0x7ed1442
callq 0xaabfb0
movq %rax, %rdi
leaq 0x743fd84(%rip), %rsi # 0x7eed297
callq 0xab5930
leaq 0x7a0(%rsp), %rdi
callq 0x949780
movq 0x7c0(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq %rax, %rsi
leaq 0x790(%rsp), %rdi
callq 0x7eb0f0
movq 0x10f0(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x10c0(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x768(%rsp), %rdi
leaq 0x7423ed5(%rip), %rsi # 0x7ed1442
leaq 0x790(%rsp), %rdx
callq 0x840960
movq 0x40(%rsp), %rdi
leaq 0x768(%rsp), %rsi
callq 0x829b10
movq 0x48(%rsp), %rdi
movq %rax, %rsi
callq 0x809410
movq 0x10c0(%rsp), %rdi
movl $0x634, %esi # imm = 0x634
callq 0x9e26c0
movq %rax, 0x760(%rsp)
cmpq $0x0, 0x760(%rsp)
je 0xaad782
movq 0x760(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq %rax, %rsi
leaq 0x750(%rsp), %rdi
callq 0x7eb0f0
movq 0x750(%rsp), %rax
movq %rax, 0x740(%rsp)
movq 0x758(%rsp), %rax
movq %rax, 0x748(%rsp)
leaq 0x730(%rsp), %rdi
leaq 0x7535d76(%rip), %rsi # 0x7fe3386
callq 0x7eb0f0
movq 0x740(%rsp), %rdi
movq 0x748(%rsp), %rsi
movq 0x730(%rsp), %rdx
movq 0x738(%rsp), %rcx
callq 0x7ed410
testb $0x1, %al
jne 0xaad69d
movq 0x750(%rsp), %rax
movq %rax, 0x720(%rsp)
movq 0x758(%rsp), %rax
movq %rax, 0x728(%rsp)
leaq 0x710(%rsp), %rdi
leaq 0x743d289(%rip), %rsi # 0x7eea8f6
callq 0x7eb0f0
movq 0x720(%rsp), %rdi
movq 0x728(%rsp), %rsi
movq 0x710(%rsp), %rdx
movq 0x718(%rsp), %rcx
callq 0x7ed410
testb $0x1, %al
jne 0xaad69d
jmp 0xaad6b6
movq 0x10f0(%rsp), %rdi
leaq 0x743fbf6(%rip), %rsi # 0x7eed2a2
callq 0x809410
jmp 0xaad780
movq 0x750(%rsp), %rax
movq %rax, 0x700(%rsp)
movq 0x758(%rsp), %rax
movq %rax, 0x708(%rsp)
leaq 0x6f0(%rsp), %rdi
leaq 0x92786ab(%rip), %rsi # 0x9d25d90
callq 0x7eb0f0
movq 0x700(%rsp), %rdi
movq 0x708(%rsp), %rsi
movq 0x6f0(%rsp), %rdx
movq 0x6f8(%rsp), %rcx
callq 0x7f20f0
testb $0x1, %al
jne 0xaad715
jmp 0xaad77e
movq 0x10b0(%rsp), %rsi
leaq 0x6d0(%rsp), %rdi
movl $0x1e7, %edx # imm = 0x1E7
callq 0x9df2d0
movq 0x760(%rsp), %rdi
callq 0x83b7a0
movq %rax, 0x6c0(%rsp)
movq %rdx, 0x6c8(%rsp)
leaq 0x6d0(%rsp), %rdi
leaq 0x6c0(%rsp), %rsi
callq 0x973710
movq %rax, %rdi
leaq 0x750(%rsp), %rsi
callq 0x9d6350
leaq 0x6d0(%rsp), %rdi
callq 0x949780
jmp 0xaad780
jmp 0xaad782
movl $0x1, 0x6bc(%rsp)
movl $0x0, 0x6b8(%rsp)
movq 0x10c0(%rsp), %rdi
movl $0x622, %esi # imm = 0x622
callq 0x9e26c0
movq %rax, 0x6b0(%rsp)
cmpq $0x0, 0x6b0(%rsp)
je 0xaad87d
movq 0x6b0(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq %rax, %rsi
leaq 0x6a0(%rsp), %rdi
callq 0x7eb0f0
leaq 0x6a0(%rsp), %rdi
xorl %esi, %esi
leaq 0x6bc(%rsp), %rdx
callq 0x8436d0
testb $0x1, %al
jne 0xaad805
cmpl $0x1, 0x6bc(%rsp)
jge 0xaad87b
movq 0x10b0(%rsp), %rsi
leaq 0x680(%rsp), %rdi
movl $0x17e, %edx # imm = 0x17E
callq 0x9df2d0
movq 0x6b0(%rsp), %rsi
movq 0x10c0(%rsp), %rdx
leaq 0x660(%rsp), %rdi
callq 0x83b050
leaq 0x680(%rsp), %rdi
leaq 0x660(%rsp), %rsi
callq 0x973770
movq %rax, %rdi
leaq 0x6a0(%rsp), %rsi
callq 0x9d6350
leaq 0x660(%rsp), %rdi
callq 0x73b5d0
leaq 0x680(%rsp), %rdi
callq 0x949780
jmp 0xaad87d
movq 0x10c0(%rsp), %rdi
movl $0x633, %esi # imm = 0x633
callq 0x9e26c0
movq %rax, 0x658(%rsp)
cmpq $0x0, 0x658(%rsp)
je 0xaad972
movq 0x658(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq %rax, %rsi
leaq 0x648(%rsp), %rdi
callq 0x7eb0f0
leaq 0x648(%rsp), %rdi
xorl %esi, %esi
leaq 0x6b8(%rsp), %rdx
callq 0x8436d0
testb $0x1, %al
jne 0xaad8fa
cmpl $0x0, 0x6b8(%rsp)
jl 0xaad8fa
movl 0x6b8(%rsp), %eax
cmpl 0x6bc(%rsp), %eax
jl 0xaad970
movq 0x10b0(%rsp), %rsi
leaq 0x628(%rsp), %rdi
movl $0x17e, %edx # imm = 0x17E
callq 0x9df2d0
movq 0x658(%rsp), %rsi
movq 0x10c0(%rsp), %rdx
leaq 0x608(%rsp), %rdi
callq 0x83b050
leaq 0x628(%rsp), %rdi
leaq 0x608(%rsp), %rsi
callq 0x973770
movq %rax, %rdi
leaq 0x648(%rsp), %rsi
callq 0x9d6350
leaq 0x608(%rsp), %rdi
callq 0x73b5d0
leaq 0x628(%rsp), %rdi
callq 0x949780
jmp 0xaad972
cmpl $0x1, 0x6bc(%rsp)
je 0xaad9fa
movq 0x10f0(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x10c0(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x5b8(%rsp), %rdi
leaq 0x7423b10(%rip), %rsi # 0x7ed14b5
callq 0x7f1850
movl 0x6bc(%rsp), %esi
leaq 0x590(%rsp), %rdi
callq 0xab60d0
leaq 0x5e0(%rsp), %rdi
leaq 0x5b8(%rsp), %rsi
leaq 0x590(%rsp), %rdx
callq 0x829f40
movq 0x30(%rsp), %rdi
leaq 0x5e0(%rsp), %rsi
callq 0x829b10
movq 0x38(%rsp), %rdi
movq %rax, %rsi
callq 0x809410
cmpl $0x0, 0x6b8(%rsp)
je 0xaada82
movq 0x10f0(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x10c0(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x540(%rsp), %rdi
leaq 0x7424058(%rip), %rsi # 0x7ed1a85
callq 0x7f1850
movl 0x6b8(%rsp), %esi
leaq 0x518(%rsp), %rdi
callq 0xab60d0
leaq 0x568(%rsp), %rdi
leaq 0x540(%rsp), %rsi
leaq 0x518(%rsp), %rdx
callq 0x829f40
movq 0x20(%rsp), %rdi
leaq 0x568(%rsp), %rsi
callq 0x829b10
movq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x809410
movq $0x0, 0x510(%rsp)
movq 0x10c0(%rsp), %rdi
movl $0x61d, %esi # imm = 0x61D
callq 0x9df320
testb $0x1, %al
jne 0xaadabc
movq 0x10c0(%rsp), %rdi
movl $0xec, %esi
callq 0x9df320
testb $0x1, %al
jne 0xaadabc
jmp 0xaadad6
movq 0x10c0(%rsp), %rdi
movl $0x61f, %esi # imm = 0x61F
callq 0x9e26c0
movq %rax, 0x510(%rsp)
movq 0x10c0(%rsp), %rdi
movl $0xfe, %esi
callq 0x9df320
testb $0x1, %al
jne 0xaadafe
movq 0x10c0(%rsp), %rdi
movl $0xc62, %esi # imm = 0xC62
callq 0x9df320
testb $0x1, 0x987(%rsp)
jne 0xaadb16
testb $0x1, 0x97b(%rsp)
je 0xaadfcb
leaq 0x478(%rsp), %rdi
callq 0x7f6d80
movq 0x10c0(%rsp), %rdi
movl $0x134, %esi # imm = 0x134
callq 0x9fb1a0
movq %rax, 0x470(%rsp)
cmpq $0x0, 0x470(%rsp)
je 0xaadbee
movq 0x470(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq %rax, %rsi
leaq 0x460(%rsp), %rdi
callq 0x7eb0f0
movq 0x460(%rsp), %rsi
movq 0x468(%rsp), %rdx
leaq 0x478(%rsp), %rdi
callq 0x841760
movq 0x10c8(%rsp), %rdi
callq 0xa041c0
movq %rax, %rsi
leaq 0x440(%rsp), %rdi
callq 0x7eb0f0
movq 0x440(%rsp), %rdi
movq 0x448(%rsp), %rsi
xorl %edx, %edx
callq 0x8dd800
movq %rax, 0x450(%rsp)
movq %rdx, 0x458(%rsp)
movq 0x450(%rsp), %rsi
movq 0x458(%rsp), %rdx
leaq 0x478(%rsp), %rdi
callq 0x849db0
jmp 0xaadd2c
movq 0x10d8(%rsp), %rdi
callq 0x9e9cd0
movq %rax, %rdi
movl $0x5f2, %esi # imm = 0x5F2
callq 0x9e26c0
movq %rax, 0x438(%rsp)
cmpq $0x0, 0x438(%rsp)
je 0xaadc5c
movq 0x438(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq %rax, %rsi
leaq 0x428(%rsp), %rdi
callq 0x7eb0f0
movq 0x428(%rsp), %rsi
movq 0x430(%rsp), %rdx
leaq 0x478(%rsp), %rdi
callq 0x841760
jmp 0xaadd2a
movq 0x10d8(%rsp), %rdi
callq 0x9e9cd0
movq %rax, %rdi
movl $0xb9e, %esi # imm = 0xB9E
callq 0x9e26c0
movq %rax, 0x420(%rsp)
cmpq $0x0, 0x420(%rsp)
je 0xaadcc7
movq 0x420(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq %rax, %rsi
leaq 0x410(%rsp), %rdi
callq 0x7eb0f0
movq 0x410(%rsp), %rsi
movq 0x418(%rsp), %rdx
leaq 0x478(%rsp), %rdi
callq 0x841760
jmp 0xaadd28
movq 0x10c8(%rsp), %rdi
callq 0xa041c0
movq %rax, %rsi
leaq 0x3f0(%rsp), %rdi
callq 0x7eb0f0
movq 0x3f0(%rsp), %rdi
movq 0x3f8(%rsp), %rsi
xorl %edx, %edx
callq 0x8dd800
movq %rax, 0x400(%rsp)
movq %rdx, 0x408(%rsp)
movq 0x400(%rsp), %rsi
movq 0x408(%rsp), %rdx
leaq 0x478(%rsp), %rdi
callq 0x841760
jmp 0xaadd2a
jmp 0xaadd2c
leaq 0x3c8(%rsp), %rdi
leaq 0x478(%rsp), %rsi
callq 0x820ac0
leaq 0x3c8(%rsp), %rdi
xorl %esi, %esi
callq 0x8de000
testb $0x1, %al
jne 0xaadd56
jmp 0xaadd83
movq 0x10b0(%rsp), %rdi
callq 0x9ec040
movq %rax, %rdi
movq (%rdi), %rax
leaq 0x478(%rsp), %rsi
callq *0x68(%rax)
movl %eax, 0x3b8(%rsp)
movq %rdx, 0x3c0(%rsp)
leaq 0x390(%rsp), %rdi
leaq 0x743f528(%rip), %rsi # 0x7eed2ba
callq 0x7f1850
leaq 0x478(%rsp), %rdi
leaq 0x390(%rsp), %rsi
xorl %edx, %edx
callq 0x8dca00
testb $0x1, 0x987(%rsp)
je 0xaade2a
movq 0x10f0(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x10c0(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x478(%rsp), %rdi
callq 0x83f4f0
movq %rax, 0x358(%rsp)
movq %rdx, 0x360(%rsp)
leaq 0x368(%rsp), %rdi
leaq 0x7411a45(%rip), %rsi # 0x7ebf843
leaq 0x358(%rsp), %rdx
callq 0x840960
movq 0x10(%rsp), %rdi
leaq 0x368(%rsp), %rsi
callq 0x829b10
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x809410
testb $0x1, 0x97b(%rsp)
je 0xaadfbe
cmpq $0x0, 0x510(%rsp)
je 0xaadf23
leaq 0x2c0(%rsp), %rdi
leaq 0x478(%rsp), %rsi
callq 0x8a72b0
movq 0x510(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq %rax, %rsi
leaq 0x2b0(%rsp), %rdi
callq 0x7eb0f0
movq 0x2b0(%rsp), %rsi
movq 0x2b8(%rsp), %rdx
leaq 0x478(%rsp), %rdi
callq 0x841760
leaq 0x288(%rsp), %rdi
leaq 0x2c0(%rsp), %rsi
callq 0x820ac0
leaq 0x260(%rsp), %rdi
leaq 0x7464d7d(%rip), %rsi # 0x7f12c39
callq 0x7f1850
leaq 0x238(%rsp), %rdi
leaq 0x7464d69(%rip), %rsi # 0x7f12c39
callq 0x7f1850
leaq 0x210(%rsp), %rdi
leaq 0x7464d55(%rip), %rsi # 0x7f12c39
callq 0x7f1850
leaq 0x478(%rsp), %rdi
leaq 0x288(%rsp), %rsi
leaq 0x260(%rsp), %rdx
leaq 0x238(%rsp), %rcx
leaq 0x210(%rsp), %r8
callq 0x8dc680
leaq 0x2c0(%rsp), %rdi
callq 0x7f6e10
leaq 0x1e8(%rsp), %rdi
leaq 0x971c486(%rip), %rsi # 0xa1ca3b8
callq 0x7f1850
leaq 0x478(%rsp), %rdi
leaq 0x1e8(%rsp), %rsi
xorl %edx, %edx
callq 0x8dca00
movq 0x10f0(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10c0(%rsp), %rax
movq %rax, (%rsp)
leaq 0x478(%rsp), %rdi
callq 0x83f4f0
movq %rax, 0x1b0(%rsp)
movq %rdx, 0x1b8(%rsp)
leaq 0x1c0(%rsp), %rdi
leaq 0x741189b(%rip), %rsi # 0x7ebf82e
leaq 0x1b0(%rsp), %rdx
callq 0x840960
movq (%rsp), %rdi
leaq 0x1c0(%rsp), %rsi
callq 0x829b10
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x809410
leaq 0x478(%rsp), %rdi
callq 0x7f6e10
addq $0x10e8, %rsp # imm = 0x10E8
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /Driver/ToolChains/Clang.cpp |
parseClangCLEHFlags(clang::driver::Driver const&, llvm::opt::ArgList const&, bool) | static EHFlags parseClangCLEHFlags(const Driver &D, const ArgList &Args,
bool isWindowsMSVC) {
EHFlags EH;
std::vector<std::string> EHArgs =
Args.getAllArgValues(options::OPT__SLASH_EH);
for (const auto &EHVal : EHArgs) {
for (size_t I = 0, E = EHVal.size(); I != E; ++I) {
switch (EHVal[I]) {
case 'a':
EH.Asynch = maybeConsumeDash(EHVal, I);
if (EH.Asynch) {
// Async exceptions are Windows MSVC only.
if (!isWindowsMSVC) {
EH.Asynch = false;
D.Diag(clang::diag::warn_drv_unused_argument) << "/EHa" << EHVal;
continue;
}
EH.Synch = false;
}
continue;
case 'c':
EH.NoUnwindC = maybeConsumeDash(EHVal, I);
continue;
case 's':
EH.Synch = maybeConsumeDash(EHVal, I);
if (EH.Synch)
EH.Asynch = false;
continue;
default:
break;
}
D.Diag(clang::diag::err_drv_invalid_value) << "/EH" << EHVal;
break;
}
}
// The /GX, /GX- flags are only processed if there are not /EH flags.
// The default is that /GX is not specified.
if (EHArgs.empty() &&
Args.hasFlag(options::OPT__SLASH_GX, options::OPT__SLASH_GX_,
/*Default=*/false)) {
EH.Synch = true;
EH.NoUnwindC = true;
}
if (Args.hasArg(options::OPT__SLASH_kernel)) {
EH.Synch = false;
EH.NoUnwindC = false;
EH.Asynch = false;
}
return EH;
} | subq $0xd8, %rsp
movb %dl, %al
movq %rdi, 0xc8(%rsp)
movq %rsi, 0xc0(%rsp)
andb $0x1, %al
movb %al, 0xbf(%rsp)
leaq 0xd5(%rsp), %rdi
callq 0xac29a0
movq 0xc0(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x9c(%rsp), %rdi
movl $0x14b, %esi # imm = 0x14B
callq 0x7eba60
movq 0x10(%rsp), %rsi
movl 0x9c(%rsp), %edx
leaq 0xa0(%rsp), %rdi
callq 0x828890
leaq 0xa0(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x90(%rsp), %rdi
callq 0x7ec290
movq %rax, 0x88(%rsp)
movq 0x90(%rsp), %rdi
callq 0x7ec2c0
movq %rax, 0x80(%rsp)
leaq 0x88(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x7ec2f0
testb $0x1, %al
jne 0xab61af
jmp 0xab635c
leaq 0x88(%rsp), %rdi
callq 0x7ec330
movq %rax, 0x78(%rsp)
movq $0x0, 0x70(%rsp)
movq 0x78(%rsp), %rdi
callq 0x73a2d0
movq %rax, 0x68(%rsp)
movq 0x70(%rsp), %rax
cmpq 0x68(%rsp), %rax
je 0xab6348
movq 0x78(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0x73a6e0
movsbl (%rax), %eax
movl %eax, 0xc(%rsp)
subl $0x61, %eax
je 0xab6227
jmp 0xab6206
movl 0xc(%rsp), %eax
subl $0x63, %eax
je 0xab62ac
jmp 0xab6215
movl 0xc(%rsp), %eax
subl $0x73, %eax
je 0xab62c6
jmp 0xab62f2
movq 0x78(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xac29c0
andb $0x1, %al
movb %al, 0xd6(%rsp)
testb $0x1, 0xd6(%rsp)
je 0xab62a7
testb $0x1, 0xbf(%rsp)
jne 0xab629f
movb $0x0, 0xd6(%rsp)
movq 0xc8(%rsp), %rsi
leaq 0x48(%rsp), %rdi
movl $0x254, %edx # imm = 0x254
callq 0x9df2d0
leaq 0x48(%rsp), %rdi
leaq 0x74372af(%rip), %rsi # 0x7eed52d
callq 0xa165e0
movq %rax, %rdi
movq 0x78(%rsp), %rsi
callq 0x949720
leaq 0x48(%rsp), %rdi
callq 0x949780
jmp 0xab6335
movb $0x0, 0xd5(%rsp)
jmp 0xab6335
movq 0x78(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xac29c0
andb $0x1, %al
movb %al, 0xd7(%rsp)
jmp 0xab6335
movq 0x78(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xac29c0
andb $0x1, %al
movb %al, 0xd5(%rsp)
testb $0x1, 0xd5(%rsp)
je 0xab62f0
movb $0x0, 0xd6(%rsp)
jmp 0xab6335
jmp 0xab62f4
movq 0xc8(%rsp), %rsi
leaq 0x28(%rsp), %rdi
movl $0x190, %edx # imm = 0x190
callq 0x9df2d0
leaq 0x28(%rsp), %rdi
leaq 0x740a88b(%rip), %rsi # 0x7ec0ba2
callq 0x9e8730
movq %rax, %rdi
movq 0x78(%rsp), %rsi
callq 0x949720
leaq 0x28(%rsp), %rdi
callq 0x949780
jmp 0xab6348
movq 0x70(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x70(%rsp)
jmp 0xab61d9
jmp 0xab634a
leaq 0x88(%rsp), %rdi
callq 0x7ec5f0
jmp 0xab6191
leaq 0xa0(%rsp), %rdi
callq 0x7ec610
testb $0x1, %al
jne 0xab636f
jmp 0xab63c2
movq 0xc0(%rsp), %rax
movq %rax, (%rsp)
leaq 0x24(%rsp), %rdi
movl $0x7c6, %esi # imm = 0x7C6
callq 0x7eba60
leaq 0x20(%rsp), %rdi
movl $0x7c4, %esi # imm = 0x7C4
callq 0x7eba60
movq (%rsp), %rdi
movl 0x24(%rsp), %esi
movl 0x20(%rsp), %edx
xorl %ecx, %ecx
callq 0x828060
testb $0x1, %al
jne 0xab63b2
jmp 0xab63c2
movb $0x1, 0xd5(%rsp)
movb $0x1, 0xd7(%rsp)
movq 0xc0(%rsp), %rdi
movl $0x822, %esi # imm = 0x822
callq 0x9df320
testb $0x1, %al
jne 0xab63da
jmp 0xab63f2
movb $0x0, 0xd5(%rsp)
movb $0x0, 0xd7(%rsp)
movb $0x0, 0xd6(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x7e5cf0
movb 0xd7(%rsp), %al
movb %al, 0x1e(%rsp)
movw 0xd5(%rsp), %ax
movw %ax, 0x1c(%rsp)
movzbl 0x1e(%rsp), %ecx
shll $0x10, %ecx
movzwl 0x1c(%rsp), %eax
orl %ecx, %eax
addq $0xd8, %rsp
retq
nop
| /Driver/ToolChains/Clang.cpp |
clang::driver::tools::OffloadBundler::~OffloadBundler() | class LLVM_LIBRARY_VISIBILITY OffloadBundler final : public Tool {
public:
OffloadBundler(const ToolChain &TC)
: Tool("offload bundler", "clang-offload-bundler", TC) {}
bool hasIntegratedCPP() const override { return false; }
void ConstructJob(Compilation &C, const JobAction &JA,
const InputInfo &Output, const InputInfoList &Inputs,
const llvm::opt::ArgList &TCArgs,
const char *LinkingOutput) const override;
void ConstructJobMultipleOutputs(Compilation &C, const JobAction &JA,
const InputInfoList &Outputs,
const InputInfoList &Inputs,
const llvm::opt::ArgList &TCArgs,
const char *LinkingOutput) const override;
} | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0xbafd70
popq %rax
retq
| /Driver/ToolChains/Clang.h |
llvm::parseDenormalFPAttributeComponent(llvm::StringRef) | inline DenormalMode::DenormalModeKind
parseDenormalFPAttributeComponent(StringRef Str) {
// Assume ieee on unspecified attribute.
return StringSwitch<DenormalMode::DenormalModeKind>(Str)
.Cases("", "ieee", DenormalMode::IEEE)
.Case("preserve-sign", DenormalMode::PreserveSign)
.Case("positive-zero", DenormalMode::PositiveZero)
.Case("dynamic", DenormalMode::Dynamic)
.Default(DenormalMode::Invalid);
} | subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movq %rsi, 0xa0(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x70(%rsp), %rsi
movq 0x78(%rsp), %rdx
leaq 0x80(%rsp), %rdi
callq 0xac0450
leaq 0x60(%rsp), %rdi
leaq 0x74528c5(%rip), %rsi # 0x7f12c39
callq 0x96d580
leaq 0x50(%rsp), %rdi
leaq 0x741b939(%rip), %rsi # 0x7edbcbe
callq 0x7ec120
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rdx
movq 0x50(%rsp), %rcx
movq 0x58(%rsp), %r8
leaq 0x80(%rsp), %rdi
xorl %r9d, %r9d
callq 0xac0490
movq %rax, 0x8(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x742ca10(%rip), %rsi # 0x7eecdcf
callq 0x7ec450
movq 0x8(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
movl $0x1, %ecx
callq 0xac0520
movq %rax, 0x10(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x742c9ef(%rip), %rsi # 0x7eecddd
callq 0x7ec450
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
movl $0x2, %ecx
callq 0xac0520
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x7527764(%rip), %rsi # 0x7fe7b81
callq 0x929990
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movl $0x3, %ecx
callq 0xac0520
movq %rax, %rdi
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0xac05c0
addq $0xa8, %rsp
retq
| /llvm/ADT/FloatingPointMode.h |
hasMultipleInvocations(llvm::Triple const&, llvm::opt::ArgList const&) | static bool hasMultipleInvocations(const llvm::Triple &Triple,
const ArgList &Args) {
// Supported only on Darwin where we invoke the compiler multiple times
// followed by an invocation to lipo.
if (!Triple.isOSDarwin())
return false;
// If more than one "-arch <arch>" is specified, we're targeting multiple
// architectures resulting in a fat binary.
return Args.getAllArgValues(options::OPT_arch).size() > 1;
} | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x93d1d0
testb $0x1, %al
jne 0xac28e3
movb $0x0, 0x47(%rsp)
jmp 0xac2930
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x14(%rsp), %rdi
movl $0x81, %esi
callq 0x7eba60
movq 0x8(%rsp), %rsi
movl 0x14(%rsp), %edx
leaq 0x18(%rsp), %rdi
callq 0x828890
leaq 0x18(%rsp), %rdi
callq 0x7eb500
cmpq $0x1, %rax
seta %al
andb $0x1, %al
movb %al, 0x47(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x7e5cf0
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopl (%rax,%rax)
| /Driver/ToolChains/Clang.cpp |
clang::driver::tools::getStatsFileName(llvm::opt::ArgList const&, clang::driver::InputInfo const&, clang::driver::InputInfo const&, clang::driver::Driver const&) | SmallString<128> tools::getStatsFileName(const llvm::opt::ArgList &Args,
const InputInfo &Output,
const InputInfo &Input,
const Driver &D) {
const Arg *A = Args.getLastArg(options::OPT_save_stats_EQ);
if (!A && !D.CCPrintInternalStats)
return {};
SmallString<128> StatsFile;
if (A) {
StringRef SaveStats = A->getValue();
if (SaveStats == "obj" && Output.isFilename()) {
StatsFile.assign(Output.getFilename());
llvm::sys::path::remove_filename(StatsFile);
} else if (SaveStats != "cwd") {
D.Diag(diag::err_drv_invalid_value) << A->getAsString(Args) << SaveStats;
return {};
}
StringRef BaseName = llvm::sys::path::filename(Input.getBaseInput());
llvm::sys::path::append(StatsFile, BaseName);
llvm::sys::path::replace_extension(StatsFile, "stats");
} else {
assert(D.CCPrintInternalStats);
StatsFile.assign(D.CCPrintInternalStatReportFilename.empty()
? "-"
: D.CCPrintInternalStatReportFilename);
}
return StatsFile;
} | subq $0x2a8, %rsp # imm = 0x2A8
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x2a0(%rsp)
movq %rsi, 0x298(%rsp)
movq %rdx, 0x290(%rsp)
movq %rcx, 0x288(%rsp)
movq %r8, 0x280(%rsp)
movq 0x298(%rsp), %rdi
movl $0xc16, %esi # imm = 0xC16
callq 0x9e26c0
movq %rax, 0x278(%rsp)
cmpq $0x0, 0x278(%rsp)
jne 0xaccc5c
movq 0x280(%rsp), %rax
movb 0x380(%rax), %al
shrb $0x3, %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xaccc5c
movq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x98, %edx
callq 0x73aa90
movq 0x8(%rsp), %rdi
callq 0x7f6d80
jmp 0xacd010
leaq 0x1e0(%rsp), %rdi
callq 0x7f6d80
cmpq $0x0, 0x278(%rsp)
je 0xaccf42
movq 0x278(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq %rax, %rsi
leaq 0x1d0(%rsp), %rdi
callq 0x7eb0f0
movq 0x1d0(%rsp), %rax
movq %rax, 0x1c0(%rsp)
movq 0x1d8(%rsp), %rax
movq %rax, 0x1c8(%rsp)
leaq 0x1b0(%rsp), %rdi
leaq 0x741ff18(%rip), %rsi # 0x7eecbde
callq 0x7eb0f0
movq 0x1c0(%rsp), %rdi
movq 0x1c8(%rsp), %rsi
movq 0x1b0(%rsp), %rdx
movq 0x1b8(%rsp), %rcx
callq 0x7ed410
testb $0x1, %al
jne 0xacccf6
jmp 0xaccd57
movq 0x290(%rsp), %rdi
callq 0xa04220
testb $0x1, %al
jne 0xaccd09
jmp 0xaccd57
movq 0x290(%rsp), %rdi
callq 0xa04240
movq %rax, %rsi
leaq 0x1a0(%rsp), %rdi
callq 0x7eb0f0
movq 0x1a0(%rsp), %rsi
movq 0x1a8(%rsp), %rdx
leaq 0x1e0(%rsp), %rdi
callq 0x842560
leaq 0x1e0(%rsp), %rdi
xorl %esi, %esi
callq 0x8dc990
jmp 0xacce5c
movq 0x1d0(%rsp), %rax
movq %rax, 0x190(%rsp)
movq 0x1d8(%rsp), %rax
movq %rax, 0x198(%rsp)
leaq 0x180(%rsp), %rdi
leaq 0x73fc870(%rip), %rsi # 0x7ec95f6
callq 0x7eb0f0
movq 0x190(%rsp), %rdi
movq 0x198(%rsp), %rsi
movq 0x180(%rsp), %rdx
movq 0x188(%rsp), %rcx
callq 0x7f20f0
testb $0x1, %al
jne 0xaccdb9
jmp 0xacce5a
movq 0x280(%rsp), %rsi
leaq 0x160(%rsp), %rdi
movl $0x190, %edx # imm = 0x190
callq 0x9df2d0
movq 0x278(%rsp), %rsi
movq 0x298(%rsp), %rdx
leaq 0x140(%rsp), %rdi
callq 0x83b050
leaq 0x160(%rsp), %rdi
leaq 0x140(%rsp), %rsi
callq 0x973770
movq %rax, %rdi
leaq 0x1d0(%rsp), %rsi
callq 0x9d6350
leaq 0x140(%rsp), %rdi
callq 0x73b5d0
leaq 0x160(%rsp), %rdi
callq 0x949780
movq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x98, %edx
callq 0x73aa90
movq 0x8(%rsp), %rdi
callq 0x7f6d80
movl $0x1, 0x13c(%rsp)
jmp 0xacd003
jmp 0xacce5c
movq 0x288(%rsp), %rdi
callq 0xa041c0
movq %rax, %rsi
leaq 0x118(%rsp), %rdi
callq 0x7eb0f0
movq 0x118(%rsp), %rdi
movq 0x120(%rsp), %rsi
xorl %edx, %edx
callq 0x8dd800
movq %rax, 0x128(%rsp)
movq %rdx, 0x130(%rsp)
leaq 0xf0(%rsp), %rdi
leaq 0x128(%rsp), %rsi
callq 0x7f18a0
leaq 0xc8(%rsp), %rdi
leaq 0x7445d75(%rip), %rsi # 0x7f12c39
callq 0x7f1850
leaq 0xa0(%rsp), %rdi
leaq 0x7445d61(%rip), %rsi # 0x7f12c39
callq 0x7f1850
leaq 0x78(%rsp), %rdi
leaq 0x7445d50(%rip), %rsi # 0x7f12c39
callq 0x7f1850
leaq 0x1e0(%rsp), %rdi
leaq 0xf0(%rsp), %rsi
leaq 0xc8(%rsp), %rdx
leaq 0xa0(%rsp), %rcx
leaq 0x78(%rsp), %r8
callq 0x8dc680
leaq 0x50(%rsp), %rdi
leaq 0x99dd19d(%rip), %rsi # 0xa4aa0c1
callq 0x7f1850
leaq 0x1e0(%rsp), %rdi
leaq 0x50(%rsp), %rsi
xorl %edx, %edx
callq 0x8dca00
jmp 0xaccfe6
movq 0x280(%rsp), %rdi
addq $0x2d0, %rdi # imm = 0x2D0
callq 0x73b030
movb $0x0, 0x1e(%rsp)
testb $0x1, %al
jne 0xaccf61
jmp 0xaccf88
leaq 0x1f(%rsp), %rdi
callq 0x73a200
movb $0x1, 0x1e(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x734aa53(%rip), %rsi # 0x7e179cf
leaq 0x1f(%rsp), %rdx
callq 0x7e5c40
jmp 0xaccfa1
movq 0x280(%rsp), %rsi
addq $0x2d0, %rsi # imm = 0x2D0
leaq 0x20(%rsp), %rdi
callq 0x73a040
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x7eaca0
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
leaq 0x1e0(%rsp), %rdi
callq 0x842560
leaq 0x20(%rsp), %rdi
callq 0x73b5d0
testb $0x1, 0x1e(%rsp)
jne 0xaccfda
jmp 0xaccfe4
leaq 0x1f(%rsp), %rdi
callq 0x73b530
jmp 0xaccfe6
movq 0x8(%rsp), %rdi
leaq 0x1e0(%rsp), %rsi
callq 0x8a72b0
movl $0x1, 0x13c(%rsp)
leaq 0x1e0(%rsp), %rdi
callq 0x7f6e10
movq 0x10(%rsp), %rax
addq $0x2a8, %rsp # imm = 0x2A8
retq
nopl (%rax)
| /Driver/ToolChains/CommonArgs.cpp |
clang::driver::tools::addOffloadCompressArgs(llvm::opt::ArgList const&, llvm::SmallVector<char const*, 16u>&) | void tools::addOffloadCompressArgs(const llvm::opt::ArgList &TCArgs,
llvm::opt::ArgStringList &CmdArgs) {
if (TCArgs.hasFlag(options::OPT_offload_compress,
options::OPT_no_offload_compress, false))
CmdArgs.push_back("-compress");
if (TCArgs.hasArg(options::OPT_v))
CmdArgs.push_back("-verbose");
if (auto *Arg = TCArgs.getLastArg(options::OPT_offload_compression_level_EQ))
CmdArgs.push_back(
TCArgs.MakeArgString(Twine("-compression-level=") + Arg->getValue()));
} | subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0xa4(%rsp), %rdi
movl $0xb7f, %esi # imm = 0xB7F
callq 0x7eba60
leaq 0xa0(%rsp), %rdi
movl $0xb2f, %esi # imm = 0xB2F
callq 0x7eba60
movq 0x18(%rsp), %rdi
movl 0xa4(%rsp), %esi
movl 0xa0(%rsp), %edx
xorl %ecx, %ecx
callq 0x828060
testb $0x1, %al
jne 0xad8368
jmp 0xad837c
movq 0xa8(%rsp), %rdi
leaq 0x7408f9f(%rip), %rsi # 0x7ee1316
callq 0x809410
movq 0xb0(%rsp), %rdi
movl $0xcaf, %esi # imm = 0xCAF
callq 0x9df320
testb $0x1, %al
jne 0xad8394
jmp 0xad83a8
movq 0xa8(%rsp), %rdi
leaq 0x740be9e(%rip), %rsi # 0x7ee4241
callq 0x809410
movq 0xb0(%rsp), %rdi
movl $0xb7e, %esi # imm = 0xB7E
callq 0x9e26c0
movq %rax, 0x98(%rsp)
cmpq $0x0, 0x98(%rsp)
je 0xad8444
movq 0xa8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x7408ecd(%rip), %rsi # 0x7ee12c0
callq 0x7f1850
movq 0x98(%rsp), %rdi
xorl %esi, %esi
callq 0x7ebdf0
movq %rax, %rsi
leaq 0x20(%rsp), %rdi
callq 0x7f1850
leaq 0x70(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x829f40
movq 0x8(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x829b10
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x809410
addq $0xb8, %rsp
retq
nopl (%rax)
| /Driver/ToolChains/CommonArgs.cpp |
findOHOSMuslMultilibs(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, clang::driver::DetectedMultilibs&) | static bool findOHOSMuslMultilibs(const Multilib::flags_list &Flags,
DetectedMultilibs &Result) {
MultilibSet Multilibs;
Multilibs.push_back(Multilib());
// -mcpu=cortex-a7
// -mfloat-abi=soft -mfloat-abi=softfp -mfloat-abi=hard
// -mfpu=neon-vfpv4
Multilibs.push_back(
Multilib("/a7_soft", {}, {}, {"-mcpu=cortex-a7", "-mfloat-abi=soft"}));
Multilibs.push_back(
Multilib("/a7_softfp_neon-vfpv4", {}, {},
{"-mcpu=cortex-a7", "-mfloat-abi=softfp", "-mfpu=neon-vfpv4"}));
Multilibs.push_back(
Multilib("/a7_hard_neon-vfpv4", {}, {},
{"-mcpu=cortex-a7", "-mfloat-abi=hard", "-mfpu=neon-vfpv4"}));
if (Multilibs.select(Flags, Result.SelectedMultilibs)) {
Result.Multilibs = Multilibs;
return true;
}
return false;
} | subq $0x628, %rsp # imm = 0x628
movq %rdi, 0x618(%rsp)
movq %rsi, 0x610(%rsp)
leaq 0x5a0(%rsp), %rdi
callq 0xa47b00
leaq 0x4f8(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x73aa90
leaq 0x4f8(%rsp), %rdi
callq 0x80d290
leaq 0x4e8(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x73aa90
leaq 0x4e8(%rsp), %rdi
callq 0x80d290
leaq 0x4d8(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x73aa90
leaq 0x4d8(%rsp), %rdi
callq 0x80d290
leaq 0x4c0(%rsp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x73aa90
leaq 0x4c0(%rsp), %rdi
callq 0x7e5ce0
leaq 0x4b0(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x73aa90
leaq 0x4b0(%rsp), %rdi
callq 0x80d290
movq 0x4f8(%rsp), %rsi
movq 0x500(%rsp), %rdx
movq 0x4e8(%rsp), %rcx
movq 0x4f0(%rsp), %r8
leaq 0x508(%rsp), %rdi
leaq 0x4d8(%rsp), %r10
leaq 0x4c0(%rsp), %r9
leaq 0x4b0(%rsp), %rax
movq (%r10), %r11
movq %r11, (%rsp)
movq 0x8(%r10), %r10
movq %r10, 0x8(%rsp)
movq (%rax), %r10
movq %r10, 0x10(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0xa3c340
leaq 0x5a0(%rsp), %rdi
leaq 0x508(%rsp), %rsi
callq 0xa3c990
leaq 0x508(%rsp), %rdi
callq 0xa3f510
leaq 0x4c0(%rsp), %rdi
callq 0x7e5cf0
leaq 0x408(%rsp), %rdi
leaq 0x7376923(%rip), %rsi # 0x7ef5590
callq 0x7eb0f0
leaq 0x3f8(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x73aa90
leaq 0x3f8(%rsp), %rdi
callq 0x80d290
leaq 0x3e8(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x73aa90
leaq 0x3e8(%rsp), %rdi
callq 0x80d290
leaq 0x37f(%rsp), %rdi
callq 0x73a200
leaq 0x380(%rsp), %rdi
leaq 0x73768b0(%rip), %rsi # 0x7ef5580
leaq 0x37f(%rsp), %rdx
callq 0x7e5c40
leaq 0x380(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x78(%rsp)
leaq 0x37e(%rsp), %rdi
callq 0x73a200
movq 0x78(%rsp), %rdi
leaq 0x736b16f(%rip), %rsi # 0x7ee9e76
leaq 0x37e(%rsp), %rdx
callq 0x7e5c40
leaq 0x380(%rsp), %rax
movq %rax, 0x3c0(%rsp)
movq $0x2, 0x3c8(%rsp)
leaq 0x37d(%rsp), %rdi
callq 0x7f2c30
movq 0x3c0(%rsp), %rsi
movq 0x3c8(%rsp), %rdx
leaq 0x3d0(%rsp), %rdi
leaq 0x37d(%rsp), %rcx
callq 0x7f2c40
leaq 0x368(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x73aa90
leaq 0x368(%rsp), %rdi
callq 0x80d290
movq 0x408(%rsp), %rsi
movq 0x410(%rsp), %rdx
movq 0x3f8(%rsp), %rcx
movq 0x400(%rsp), %r8
leaq 0x418(%rsp), %rdi
leaq 0x3e8(%rsp), %r10
leaq 0x3d0(%rsp), %r9
leaq 0x368(%rsp), %rax
movq (%r10), %r11
movq %r11, (%rsp)
movq 0x8(%r10), %r10
movq %r10, 0x8(%rsp)
movq (%rax), %r10
movq %r10, 0x10(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0xa3c340
leaq 0x5a0(%rsp), %rdi
leaq 0x418(%rsp), %rsi
callq 0xa3c990
leaq 0x418(%rsp), %rdi
callq 0xa3f510
leaq 0x3d0(%rsp), %rdi
callq 0x7e5cf0
leaq 0x37d(%rsp), %rdi
callq 0x7f2420
leaq 0x380(%rsp), %rax
movq %rax, 0x80(%rsp)
addq $0x40, %rax
movq %rax, 0x88(%rsp)
movq 0x88(%rsp), %rdi
addq $-0x20, %rdi
movq %rdi, 0x70(%rsp)
callq 0x73b5d0
movq 0x80(%rsp), %rcx
movq 0x70(%rsp), %rax
cmpq %rcx, %rax
movq %rax, 0x88(%rsp)
jne 0xb7ee41
leaq 0x37e(%rsp), %rdi
callq 0x73b530
leaq 0x37f(%rsp), %rdi
callq 0x73b530
leaq 0x2c0(%rsp), %rdi
leaq 0x73766ff(%rip), %rsi # 0x7ef5599
callq 0x7eb0f0
leaq 0x2b0(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x73aa90
leaq 0x2b0(%rsp), %rdi
callq 0x80d290
leaq 0x2a0(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x73aa90
leaq 0x2a0(%rsp), %rdi
callq 0x80d290
leaq 0x217(%rsp), %rdi
callq 0x73a200
leaq 0x218(%rsp), %rdi
leaq 0x7376683(%rip), %rsi # 0x7ef5580
leaq 0x217(%rsp), %rdx
callq 0x7e5c40
leaq 0x218(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x50(%rsp)
leaq 0x216(%rsp), %rdi
callq 0x73a200
movq 0x50(%rsp), %rdi
leaq 0x736af53(%rip), %rsi # 0x7ee9e87
leaq 0x216(%rsp), %rdx
callq 0x7e5c40
leaq 0x218(%rsp), %rax
addq $0x40, %rax
movq %rax, 0x58(%rsp)
leaq 0x215(%rsp), %rdi
callq 0x73a200
movq 0x58(%rsp), %rdi
leaq 0x736aebd(%rip), %rsi # 0x7ee9e28
leaq 0x215(%rsp), %rdx
callq 0x7e5c40
leaq 0x218(%rsp), %rax
movq %rax, 0x278(%rsp)
movq $0x3, 0x280(%rsp)
leaq 0x214(%rsp), %rdi
callq 0x7f2c30
movq 0x278(%rsp), %rsi
movq 0x280(%rsp), %rdx
leaq 0x288(%rsp), %rdi
leaq 0x214(%rsp), %rcx
callq 0x7f2c40
leaq 0x200(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x73aa90
leaq 0x200(%rsp), %rdi
callq 0x80d290
movq 0x2c0(%rsp), %rsi
movq 0x2c8(%rsp), %rdx
movq 0x2b0(%rsp), %rcx
movq 0x2b8(%rsp), %r8
leaq 0x2d0(%rsp), %rdi
leaq 0x2a0(%rsp), %r10
leaq 0x288(%rsp), %r9
leaq 0x200(%rsp), %rax
movq (%r10), %r11
movq %r11, (%rsp)
movq 0x8(%r10), %r10
movq %r10, 0x8(%rsp)
movq (%rax), %r10
movq %r10, 0x10(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0xa3c340
leaq 0x5a0(%rsp), %rdi
leaq 0x2d0(%rsp), %rsi
callq 0xa3c990
leaq 0x2d0(%rsp), %rdi
callq 0xa3f510
leaq 0x288(%rsp), %rdi
callq 0x7e5cf0
leaq 0x214(%rsp), %rdi
callq 0x7f2420
leaq 0x218(%rsp), %rax
movq %rax, 0x60(%rsp)
addq $0x60, %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rdi
addq $-0x20, %rdi
movq %rdi, 0x48(%rsp)
callq 0x73b5d0
movq 0x60(%rsp), %rcx
movq 0x48(%rsp), %rax
cmpq %rcx, %rax
movq %rax, 0x68(%rsp)
jne 0xb7f09f
leaq 0x215(%rsp), %rdi
callq 0x73b530
leaq 0x216(%rsp), %rdi
callq 0x73b530
leaq 0x217(%rsp), %rdi
callq 0x73b530
leaq 0x158(%rsp), %rdi
leaq 0x73764b3(%rip), %rsi # 0x7ef55af
callq 0x7eb0f0
leaq 0x148(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x73aa90
leaq 0x148(%rsp), %rdi
callq 0x80d290
leaq 0x138(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x73aa90
leaq 0x138(%rsp), %rdi
callq 0x80d290
leaq 0xaf(%rsp), %rdi
callq 0x73a200
leaq 0xb0(%rsp), %rdi
leaq 0x7376421(%rip), %rsi # 0x7ef5580
leaq 0xaf(%rsp), %rdx
callq 0x7e5c40
leaq 0xb0(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x28(%rsp)
leaq 0xae(%rsp), %rdi
callq 0x73a200
movq 0x28(%rsp), %rdi
leaq 0x736ad04(%rip), %rsi # 0x7ee9e9a
leaq 0xae(%rsp), %rdx
callq 0x7e5c40
leaq 0xb0(%rsp), %rax
addq $0x40, %rax
movq %rax, 0x30(%rsp)
leaq 0xad(%rsp), %rdi
callq 0x73a200
movq 0x30(%rsp), %rdi
leaq 0x736ac5b(%rip), %rsi # 0x7ee9e28
leaq 0xad(%rsp), %rdx
callq 0x7e5c40
leaq 0xb0(%rsp), %rax
movq %rax, 0x110(%rsp)
movq $0x3, 0x118(%rsp)
leaq 0xac(%rsp), %rdi
callq 0x7f2c30
movq 0x110(%rsp), %rsi
movq 0x118(%rsp), %rdx
leaq 0x120(%rsp), %rdi
leaq 0xac(%rsp), %rcx
callq 0x7f2c40
leaq 0x98(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x73aa90
leaq 0x98(%rsp), %rdi
callq 0x80d290
movq 0x158(%rsp), %rsi
movq 0x160(%rsp), %rdx
movq 0x148(%rsp), %rcx
movq 0x150(%rsp), %r8
leaq 0x168(%rsp), %rdi
leaq 0x138(%rsp), %r10
leaq 0x120(%rsp), %r9
leaq 0x98(%rsp), %rax
movq (%r10), %r11
movq %r11, (%rsp)
movq 0x8(%r10), %r10
movq %r10, 0x8(%rsp)
movq (%rax), %r10
movq %r10, 0x10(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
callq 0xa3c340
leaq 0x5a0(%rsp), %rdi
leaq 0x168(%rsp), %rsi
callq 0xa3c990
leaq 0x168(%rsp), %rdi
callq 0xa3f510
leaq 0x120(%rsp), %rdi
callq 0x7e5cf0
leaq 0xac(%rsp), %rdi
callq 0x7f2420
leaq 0xb0(%rsp), %rax
movq %rax, 0x38(%rsp)
addq $0x60, %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
addq $-0x20, %rdi
movq %rdi, 0x20(%rsp)
callq 0x73b5d0
movq 0x38(%rsp), %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
movq %rax, 0x40(%rsp)
jne 0xb7f301
leaq 0xad(%rsp), %rdi
callq 0x73b530
leaq 0xae(%rsp), %rdi
callq 0x73b530
leaq 0xaf(%rsp), %rdi
callq 0x73b530
movq 0x618(%rsp), %rsi
movq 0x610(%rsp), %rdx
addq $0x70, %rdx
leaq 0x5a0(%rsp), %rdi
callq 0xa3ca40
testb $0x1, %al
jne 0xb7f376
jmp 0xb7f3a0
movq 0x610(%rsp), %rdi
leaq 0x5a0(%rsp), %rsi
callq 0xa807a0
movb $0x1, 0x627(%rsp)
movl $0x1, 0x94(%rsp)
jmp 0xb7f3b3
movb $0x0, 0x627(%rsp)
movl $0x1, 0x94(%rsp)
leaq 0x5a0(%rsp), %rdi
callq 0xa3dbb0
movb 0x627(%rsp), %al
andb $0x1, %al
addq $0x628, %rsp # imm = 0x628
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /Driver/ToolChains/OHOS.cpp |
clang::driver::toolchains::OpenBSD::AddCXXStdlibLibArgs(llvm::opt::ArgList const&, llvm::SmallVector<char const*, 16u>&) const | void OpenBSD::AddCXXStdlibLibArgs(const ArgList &Args,
ArgStringList &CmdArgs) const {
bool Profiling = Args.hasArg(options::OPT_pg);
CmdArgs.push_back(Profiling ? "-lc++_p" : "-lc++");
if (Args.hasArg(options::OPT_fexperimental_library))
CmdArgs.push_back("-lc++experimental");
CmdArgs.push_back(Profiling ? "-lc++abi_p" : "-lc++abi");
CmdArgs.push_back(Profiling ? "-lpthread_p" : "-lpthread");
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl $0xbab, %esi # imm = 0xBAB
callq 0x9df320
andb $0x1, %al
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rdi
movb 0xf(%rsp), %cl
leaq 0x73667b2(%rip), %rsi # 0x7ee7bda
leaq 0x736e8b8(%rip), %rax # 0x7eefce7
testb $0x1, %cl
cmovneq %rax, %rsi
callq 0x809410
movq 0x18(%rsp), %rdi
movl $0x291, %esi # imm = 0x291
callq 0x9df320
testb $0x1, %al
jne 0xb81450
jmp 0xb81461
movq 0x10(%rsp), %rdi
leaq 0x7366784(%rip), %rsi # 0x7ee7be0
callq 0x809410
movq 0x10(%rsp), %rdi
movb 0xf(%rsp), %cl
leaq 0x736947c(%rip), %rsi # 0x7eea8ed
leaq 0x7374221(%rip), %rax # 0x7ef5699
testb $0x1, %cl
cmovneq %rax, %rsi
callq 0x809410
movq 0x10(%rsp), %rdi
movb 0xf(%rsp), %cl
leaq 0x73693b2(%rip), %rsi # 0x7eea846
leaq 0x736e81d(%rip), %rax # 0x7eefcb8
testb $0x1, %cl
cmovneq %rax, %rsi
callq 0x809410
addq $0x28, %rsp
retq
nopl (%rax)
| /Driver/ToolChains/OpenBSD.cpp |
clang::driver::tools::openbsd::Assembler::~Assembler() | class LLVM_LIBRARY_VISIBILITY Assembler final : public Tool {
public:
Assembler(const ToolChain &TC)
: Tool("openbsd::Assembler", "assembler", TC) {}
bool hasIntegratedCPP() const override { return false; }
void ConstructJob(Compilation &C, const JobAction &JA,
const InputInfo &Output, const InputInfoList &Inputs,
const llvm::opt::ArgList &TCArgs,
const char *LinkingOutput) const override;
} | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0xbafd70
popq %rax
retq
| /Driver/ToolChains/OpenBSD.h |
clang::driver::tools::openbsd::Linker::~Linker() | class LLVM_LIBRARY_VISIBILITY Linker final : public Tool {
public:
Linker(const ToolChain &TC) : Tool("openbsd::Linker", "linker", TC) {}
bool hasIntegratedCPP() const override { return false; }
bool isLinkJob() const override { return true; }
void ConstructJob(Compilation &C, const JobAction &JA,
const InputInfo &Output, const InputInfoList &Inputs,
const llvm::opt::ArgList &TCArgs,
const char *LinkingOutput) const override;
} | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0xbafd70
popq %rax
retq
| /Driver/ToolChains/OpenBSD.h |
llvm::DenseMap<clang::FileEntryRef, llvm::SmallVector<clang::FileEntryRef, 2u>, llvm::DenseMapInfo<clang::FileEntryRef, void>, llvm::detail::DenseMapPair<clang::FileEntryRef, llvm::SmallVector<clang::FileEntryRef, 2u>>>::init(unsigned int) | void init(unsigned InitNumEntries) {
auto InitBuckets = BaseT::getMinBucketToReserveForEntries(InitNumEntries);
if (allocateBuckets(InitBuckets)) {
this->BaseT::initEmpty();
} else {
NumEntries = 0;
NumTombstones = 0;
}
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movl 0xc(%rsp), %esi
callq 0xcb6050
movq (%rsp), %rdi
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %esi
callq 0xcb60a0
testb $0x1, %al
jne 0xcb6026
jmp 0xcb6031
movq (%rsp), %rdi
callq 0xcb6110
jmp 0xcb6043
movq (%rsp), %rax
movl $0x0, 0x8(%rax)
movl $0x0, 0xc(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
| /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<clang::FileEntryRef, llvm::SmallVector<clang::FileEntryRef, 2u>, llvm::DenseMapInfo<clang::FileEntryRef, void>, llvm::detail::DenseMapPair<clang::FileEntryRef, llvm::SmallVector<clang::FileEntryRef, 2u>>>, clang::FileEntryRef, llvm::SmallVector<clang::FileEntryRef, 2u>, llvm::DenseMapInfo<clang::FileEntryRef, void>, llvm::detail::DenseMapPair<clang::FileEntryRef, llvm::SmallVector<clang::FileEntryRef, 2u>>>::getMinBucketToReserveForEntries(unsigned int) | unsigned getMinBucketToReserveForEntries(unsigned NumEntries) {
// Ensure that "NumEntries * 4 < NumBuckets * 3"
if (NumEntries == 0)
return 0;
// +1 is required because of the strict equality.
// For example if NumEntries is 48, we need to return 401.
return NextPowerOf2(NumEntries * 4 / 3 + 1);
} | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0xcb606e
movl $0x0, 0x14(%rsp)
jmp 0xcb608e
movl 0x4(%rsp), %eax
shll $0x2, %eax
movl $0x3, %ecx
xorl %edx, %edx
divl %ecx
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x7f65b0
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
| /llvm/ADT/DenseMap.h |
clang::LogDiagnosticPrinter::HandleDiagnostic(clang::DiagnosticsEngine::Level, clang::Diagnostic const&) | void LogDiagnosticPrinter::HandleDiagnostic(DiagnosticsEngine::Level Level,
const Diagnostic &Info) {
// Default implementation (Warnings/errors count).
DiagnosticConsumer::HandleDiagnostic(Level, Info);
// Initialize the main file name, if we haven't already fetched it.
if (MainFilename.empty() && Info.hasSourceManager()) {
const SourceManager &SM = Info.getSourceManager();
FileID FID = SM.getMainFileID();
if (FID.isValid()) {
if (OptionalFileEntryRef FE = SM.getFileEntryRefForID(FID))
MainFilename = std::string(FE->getName());
}
}
// Create the diag entry.
DiagEntry DE;
DE.DiagnosticID = Info.getID();
DE.DiagnosticLevel = Level;
DE.WarningOption =
std::string(DiagnosticIDs::getWarningOptionForDiag(DE.DiagnosticID));
// Format the message.
SmallString<100> MessageStr;
Info.FormatDiagnostic(MessageStr);
DE.Message = std::string(MessageStr);
// Set the location information.
DE.Filename = "";
DE.Line = DE.Column = 0;
if (Info.getLocation().isValid() && Info.hasSourceManager()) {
const SourceManager &SM = Info.getSourceManager();
PresumedLoc PLoc = SM.getPresumedLoc(Info.getLocation());
if (PLoc.isInvalid()) {
// At least print the file name if available:
FileID FID = SM.getFileID(Info.getLocation());
if (FID.isValid()) {
if (OptionalFileEntryRef FE = SM.getFileEntryRefForID(FID))
DE.Filename = std::string(FE->getName());
}
} else {
DE.Filename = PLoc.getFilename();
DE.Line = PLoc.getLine();
DE.Column = PLoc.getColumn();
}
}
// Record the diagnostic entry.
Entries.push_back(DE);
} | subq $0x258, %rsp # imm = 0x258
movq %rdi, 0x250(%rsp)
movl %esi, 0x24c(%rsp)
movq %rdx, 0x240(%rsp)
movq 0x250(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl 0x24c(%rsp), %esi
movq 0x240(%rsp), %rdx
callq 0x94b5e0
movq 0x18(%rsp), %rdi
addq $0x418, %rdi # imm = 0x418
callq 0x73b030
testb $0x1, %al
jne 0xcebed9
jmp 0xcebff4
movq 0x240(%rsp), %rdi
callq 0xcec310
testb $0x1, %al
jne 0xcebeef
jmp 0xcebff4
movq 0x240(%rsp), %rdi
callq 0x94e120
movq %rax, 0x238(%rsp)
movq 0x238(%rsp), %rdi
callq 0x9a9ae0
movl %eax, 0x234(%rsp)
leaq 0x234(%rsp), %rdi
callq 0x94a0d0
testb $0x1, %al
jne 0xcebf2e
jmp 0xcebff2
movq 0x238(%rsp), %rdi
movl 0x234(%rsp), %eax
movl %eax, 0x224(%rsp)
movl 0x224(%rsp), %esi
callq 0x9720d0
movq %rax, 0x228(%rsp)
leaq 0x228(%rsp), %rdi
callq 0x972400
testb $0x1, %al
jne 0xcebf6e
jmp 0xcebff0
leaq 0x228(%rsp), %rdi
callq 0x977320
movq %rax, %rdi
callq 0x9736d0
movq %rax, 0x1f0(%rsp)
movq %rdx, 0x1f8(%rsp)
leaq 0x1ef(%rsp), %rdi
callq 0x73a200
leaq 0x200(%rsp), %rdi
leaq 0x1f0(%rsp), %rsi
leaq 0x1ef(%rsp), %rdx
callq 0x7f6ce0
movq 0x18(%rsp), %rdi
addq $0x418, %rdi # imm = 0x418
leaq 0x200(%rsp), %rsi
callq 0x73a330
leaq 0x200(%rsp), %rdi
callq 0x73b5d0
leaq 0x1ef(%rsp), %rdi
callq 0x73b530
jmp 0xcebff2
jmp 0xcebff4
leaq 0x170(%rsp), %rdi
callq 0xcec330
movq 0x240(%rsp), %rdi
callq 0x94b500
movl %eax, 0x1b8(%rsp)
movl 0x24c(%rsp), %eax
movl %eax, 0x1e0(%rsp)
movl 0x1b8(%rsp), %edi
callq 0x958b50
movq %rax, 0x140(%rsp)
movq %rdx, 0x148(%rsp)
leaq 0x13f(%rsp), %rdi
callq 0x73a200
leaq 0x150(%rsp), %rdi
leaq 0x140(%rsp), %rsi
leaq 0x13f(%rsp), %rdx
callq 0x7f6ce0
leaq 0x170(%rsp), %rdi
addq $0x50, %rdi
leaq 0x150(%rsp), %rsi
callq 0x73a330
leaq 0x150(%rsp), %rdi
callq 0x73b5d0
leaq 0x13f(%rsp), %rdi
callq 0x73b530
leaq 0xb8(%rsp), %rdi
callq 0xcec370
movq 0x240(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x94b640
leaq 0x98(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0xcec380
leaq 0x170(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x73a330
leaq 0x98(%rsp), %rdi
callq 0x73b5d0
leaq 0x170(%rsp), %rdi
addq $0x20, %rdi
leaq 0x7226b31(%rip), %rsi # 0x7f12c39
callq 0x73a0b0
movl $0x0, 0x1b4(%rsp)
movl $0x0, 0x1b0(%rsp)
movq 0x240(%rsp), %rdi
callq 0x94b520
movq %rax, %rdi
callq 0x94e100
testb $0x1, %al
jne 0xcec141
jmp 0xcec2d4
movq 0x240(%rsp), %rdi
callq 0xcec310
testb $0x1, %al
jne 0xcec157
jmp 0xcec2d4
movq 0x240(%rsp), %rdi
callq 0x94e120
movq %rax, 0x90(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x240(%rsp), %rdi
callq 0x94b520
movq 0x10(%rsp), %rsi
movl (%rax), %eax
movl %eax, 0x74(%rsp)
movl 0x74(%rsp), %edx
leaq 0x78(%rsp), %rdi
movl $0x1, %ecx
callq 0x97a8f0
leaq 0x78(%rsp), %rdi
callq 0x95b2e0
testb $0x1, %al
jne 0xcec1b7
jmp 0xcec292
movq 0x90(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x240(%rsp), %rdi
callq 0x94b520
movq 0x8(%rsp), %rdi
movl (%rax), %eax
movl %eax, 0x6c(%rsp)
movl 0x6c(%rsp), %esi
callq 0x94f740
movl %eax, 0x70(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x94a0d0
testb $0x1, %al
jne 0xcec1fc
jmp 0xcec290
movq 0x90(%rsp), %rdi
movl 0x70(%rsp), %eax
movl %eax, 0x5c(%rsp)
movl 0x5c(%rsp), %esi
callq 0x9720d0
movq %rax, 0x60(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x972400
testb $0x1, %al
jne 0xcec22a
jmp 0xcec28e
leaq 0x60(%rsp), %rdi
callq 0x977320
movq %rax, %rdi
callq 0x9736d0
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
leaq 0x27(%rsp), %rdi
callq 0x73a200
leaq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x27(%rsp), %rdx
callq 0x7f6ce0
leaq 0x170(%rsp), %rdi
addq $0x20, %rdi
leaq 0x38(%rsp), %rsi
callq 0x73a330
leaq 0x38(%rsp), %rdi
callq 0x73b5d0
leaq 0x27(%rsp), %rdi
callq 0x73b530
jmp 0xcec290
jmp 0xcec2d2
leaq 0x78(%rsp), %rdi
callq 0x95b300
movq %rax, %rsi
leaq 0x170(%rsp), %rdi
addq $0x20, %rdi
callq 0x73a0b0
leaq 0x78(%rsp), %rdi
callq 0x971210
movl %eax, 0x1b0(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x971220
movl %eax, 0x1b4(%rsp)
jmp 0xcec2d4
movq 0x18(%rsp), %rdi
addq $0x48, %rdi
leaq 0x170(%rsp), %rsi
callq 0xcec400
leaq 0xb8(%rsp), %rdi
callq 0xcec470
leaq 0x170(%rsp), %rdi
callq 0xcec480
addq $0x258, %rsp # imm = 0x258
retq
nopl (%rax)
| /Frontend/LogDiagnosticPrinter.cpp |
clang::LogDiagnosticPrinter::DiagEntry const* llvm::SmallVectorTemplateCommon<clang::LogDiagnosticPrinter::DiagEntry, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<clang::LogDiagnosticPrinter::DiagEntry, false>>(llvm::SmallVectorTemplateBase<clang::LogDiagnosticPrinter::DiagEntry, false>*, clang::LogDiagnosticPrinter::DiagEntry const&, unsigned long) | static const T *reserveForParamAndGetAddressImpl(U *This, const T &Elt,
size_t N) {
size_t NewSize = This->size() + N;
if (LLVM_LIKELY(NewSize <= This->capacity()))
return &Elt;
bool ReferencesStorage = false;
int64_t Index = -1;
if (!U::TakesParamByValue) {
if (LLVM_UNLIKELY(This->isReferenceToStorage(&Elt))) {
ReferencesStorage = true;
Index = &Elt - This->begin();
}
}
This->grow(NewSize);
return ReferencesStorage ? This->begin() + Index : &Elt;
} | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rdi
callq 0x87dfe0
addq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
callq 0x87ddf0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
ja 0xcec8f7
movq 0x40(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0xcec991
movb $0x0, 0x2f(%rsp)
movq $-0x1, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0xcec9a0
testb $0x1, %al
jne 0xcec91a
jmp 0xcec94d
movb $0x1, 0x2f(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
callq 0xcebe30
movq %rax, %rcx
movq 0x10(%rsp), %rax
subq %rcx, %rax
movl $0x78, %ecx
cqto
idivq %rcx
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xceca00
testb $0x1, 0x2f(%rsp)
je 0xcec97d
movq 0x48(%rsp), %rdi
callq 0xcebe30
imulq $0x78, 0x20(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
jmp 0xcec987
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
| /llvm/ADT/SmallVector.h |
(anonymous namespace)::ModuleDependencyListener::visitInputFile(llvm::StringRef, bool, bool, bool) | bool visitInputFile(StringRef Filename, bool IsSystem, bool IsOverridden,
bool IsExplicitModule) override {
// Run this through the FileManager in order to respect 'use-external-name'
// in case we have a VFS overlay.
if (auto FE = FileMgr.getOptionalFileRef(Filename))
Filename = FE->getName();
Collector.addFile(Filename);
return true;
} | subq $0x88, %rsp
movl %r8d, 0x8(%rsp)
movl %ecx, %eax
movl 0x8(%rsp), %ecx
movl %eax, 0xc(%rsp)
movq %rdx, %rax
movl 0xc(%rsp), %edx
movq %rax, 0x10(%rsp)
movq %rsi, %r8
movq 0x10(%rsp), %rsi
movb %r9b, %al
movq %r8, 0x78(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdi, 0x70(%rsp)
andb $0x1, %dl
movb %dl, 0x6f(%rsp)
andb $0x1, %cl
movb %cl, 0x6e(%rsp)
andb $0x1, %al
movb %al, 0x6d(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rax), %rdi
movq 0x78(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0xbdc130
movq %rax, 0x60(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x972400
testb $0x1, %al
jne 0xcee3c4
jmp 0xcee3f7
leaq 0x60(%rsp), %rdi
callq 0x977320
movq %rax, %rdi
callq 0x9736d0
movq %rax, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x73aa90
leaq 0x20(%rsp), %rdi
callq 0x80d290
movq (%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %r8
movq (%rdi), %rax
callq *0x48(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x88, %rsp
retq
| /Frontend/ModuleDependencyCollector.cpp |
llvm::DenseMap<unsigned int, unsigned int, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, unsigned int>>::init(unsigned int) | void init(unsigned InitNumEntries) {
auto InitBuckets = BaseT::getMinBucketToReserveForEntries(InitNumEntries);
if (allocateBuckets(InitBuckets)) {
this->BaseT::initEmpty();
} else {
NumEntries = 0;
NumTombstones = 0;
}
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movl 0xc(%rsp), %esi
callq 0xcf7940
movq (%rsp), %rdi
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %esi
callq 0xcf7990
testb $0x1, %al
jne 0xcf7916
jmp 0xcf7921
movq (%rsp), %rdi
callq 0xcf7a00
jmp 0xcf7933
movq (%rsp), %rax
movl $0x0, 0x8(%rax)
movl $0x0, 0xc(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
| /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<unsigned int, unsigned int, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, unsigned int>>, unsigned int, unsigned int, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, unsigned int>>::getMinBucketToReserveForEntries(unsigned int) | unsigned getMinBucketToReserveForEntries(unsigned NumEntries) {
// Ensure that "NumEntries * 4 < NumBuckets * 3"
if (NumEntries == 0)
return 0;
// +1 is required because of the strict equality.
// For example if NumEntries is 48, we need to return 401.
return NextPowerOf2(NumEntries * 4 / 3 + 1);
} | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0xcf795e
movl $0x0, 0x14(%rsp)
jmp 0xcf797e
movl 0x4(%rsp), %eax
shll $0x2, %eax
movl $0x3, %ecx
xorl %edx, %edx
divl %ecx
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x7f65b0
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
| /llvm/ADT/DenseMap.h |
llvm::DenseMap<unsigned int, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseSetPair<unsigned int>>::init(unsigned int) | void init(unsigned InitNumEntries) {
auto InitBuckets = BaseT::getMinBucketToReserveForEntries(InitNumEntries);
if (allocateBuckets(InitBuckets)) {
this->BaseT::initEmpty();
} else {
NumEntries = 0;
NumTombstones = 0;
}
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movl 0xc(%rsp), %esi
callq 0xcf7c40
movq (%rsp), %rdi
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %esi
callq 0xcf7c90
testb $0x1, %al
jne 0xcf7c16
jmp 0xcf7c21
movq (%rsp), %rdi
callq 0xcf7d00
jmp 0xcf7c33
movq (%rsp), %rax
movl $0x0, 0x8(%rax)
movl $0x0, 0xc(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
| /llvm/ADT/DenseMap.h |
llvm::BitstreamWriter::ExitBlock() | void ExitBlock() {
assert(!BlockScope.empty() && "Block scope imbalance!");
const Block &B = BlockScope.back();
// Block tail:
// [END_BLOCK, <align4bytes>]
EmitCode(bitc::END_BLOCK);
FlushToWord();
// Compute the size of the block, in words, not counting the size field.
size_t SizeInWords = GetWordIndex() - B.StartSizeWord - 1;
uint64_t BitNo = uint64_t(B.StartSizeWord) * 32;
// Update the block size field in the header of this sub-block.
BackpatchWord(BitNo, SizeInWords);
// Restore the inner block's code size and abbrev table.
CurCodeSize = B.PrevCodeSize;
CurAbbrevs = std::move(B.PrevAbbrevs);
BlockScope.pop_back();
FlushToFile();
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x68, %rdi
callq 0xcfaed0
movq (%rsp), %rdi
movq %rax, 0x18(%rsp)
xorl %esi, %esi
callq 0xcfad40
movq (%rsp), %rdi
callq 0xcf8b50
movq (%rsp), %rdi
callq 0xcfae10
movq (%rsp), %rdi
movq 0x18(%rsp), %rcx
subq 0x8(%rcx), %rax
subq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
shlq $0x5, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rax
movl %eax, %edx
callq 0xd016a0
movq (%rsp), %rdi
movq 0x18(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x38(%rdi)
movq 0x18(%rsp), %rsi
addq $0x10, %rsi
addq $0x40, %rdi
callq 0xd016f0
movq (%rsp), %rdi
addq $0x68, %rdi
callq 0xd019b0
movq (%rsp), %rdi
xorl %esi, %esi
callq 0xcf8b90
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /llvm/Bitstream/BitstreamWriter.h |
llvm::DenseMapIterator<unsigned int, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseSetPair<unsigned int>, false>::DenseMapIterator(llvm::detail::DenseSetPair<unsigned int>*, llvm::detail::DenseSetPair<unsigned int>*, llvm::DebugEpochBase const&, bool) | DenseMapIterator(pointer Pos, pointer E, const DebugEpochBase &Epoch,
bool NoAdvance = false)
: DebugEpochBase::HandleBase(&Epoch), Ptr(Pos), End(E) {
assert(isHandleInSync() && "invalid construction!");
if (NoAdvance) return;
if (shouldReverseIterate<KeyT>()) {
RetreatPastEmptyBuckets();
return;
}
AdvancePastEmptyBuckets();
} | subq $0x38, %rsp
movb %r8b, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rsi
callq 0x8148c0
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%rax)
testb $0x1, 0x17(%rsp)
je 0xd039f4
jmp 0xd03a15
callq 0x82c200
testb $0x1, %al
jne 0xd039ff
jmp 0xd03a0b
movq 0x8(%rsp), %rdi
callq 0xd03a20
jmp 0xd03a15
movq 0x8(%rsp), %rdi
callq 0xd03ae0
addq $0x38, %rsp
retq
nopw (%rax,%rax)
| /llvm/ADT/DenseMap.h |
(anonymous namespace)::SDiagsWriter::getEmitDiagnosticFlag(llvm::StringRef) | unsigned SDiagsWriter::getEmitDiagnosticFlag(StringRef FlagName) {
if (FlagName.empty())
return 0;
// Here we assume that FlagName points to static data whose pointer
// value is fixed. This allows us to unique by diagnostic groups.
const void *data = FlagName.data();
std::pair<unsigned, StringRef> &entry = State->DiagFlags[data];
if (entry.first == 0) {
entry.first = State->DiagFlags.size();
entry.second = FlagName;
// Lazily emit the string in a separate record.
RecordData::value_type Record[] = {RECORD_DIAG_FLAG, entry.first,
FlagName.size()};
State->Stream.EmitRecordWithBlob(State->Abbrevs.get(RECORD_DIAG_FLAG),
Record, FlagName);
}
return entry.first;
} | subq $0x68, %rsp
movq %rsi, 0x50(%rsp)
movq %rdx, 0x58(%rsp)
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x7ed530
testb $0x1, %al
jne 0xd03fcd
jmp 0xd03fda
movl $0x0, 0x64(%rsp)
jmp 0xd040f2
leaq 0x50(%rsp), %rdi
callq 0x7ed2e0
movq 0x8(%rsp), %rdi
movq %rax, 0x40(%rsp)
addq $0x20, %rdi
callq 0xcf96b0
movq %rax, %rdi
addq $0x848, %rdi # imm = 0x848
leaq 0x40(%rsp), %rsi
callq 0xd04100
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
cmpl $0x0, (%rax)
jne 0xd040e7
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
callq 0xcf96b0
movq %rax, %rdi
addq $0x848, %rdi # imm = 0x848
callq 0xd04130
movl %eax, %ecx
movq 0x38(%rsp), %rax
movl %ecx, (%rax)
movq 0x38(%rsp), %rax
movq 0x50(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x58(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq $0x4, 0x20(%rsp)
movq 0x38(%rsp), %rax
movl (%rax), %eax
movq %rax, 0x28(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x7ed2d0
movq 0x8(%rsp), %rdi
movq %rax, 0x30(%rsp)
addq $0x20, %rdi
callq 0xcf96b0
movq 0x8(%rsp), %rdi
addq $0x420, %rax # imm = 0x420
movq %rax, (%rsp)
addq $0x20, %rdi
callq 0xcf96b0
movq %rax, %rdi
addq $0x4d8, %rdi # imm = 0x4D8
movl $0x4, %esi
callq 0xd026e0
movq (%rsp), %rdi
movl %eax, %esi
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %r8
leaq 0x20(%rsp), %rdx
callq 0xd033a0
movq 0x38(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopl (%rax,%rax)
| /Frontend/SerializedDiagnosticPrinter.cpp |
(anonymous namespace)::SDiagsWriter::AddLocToRecord(clang::FullSourceLoc, clang::PresumedLoc, llvm::SmallVectorImpl<unsigned long>&, unsigned int) | void SDiagsWriter::AddLocToRecord(FullSourceLoc Loc, PresumedLoc PLoc,
RecordDataImpl &Record, unsigned TokSize) {
if (PLoc.isInvalid()) {
// Emit a "sentinel" location.
Record.push_back((unsigned)0); // File.
Record.push_back((unsigned)0); // Line.
Record.push_back((unsigned)0); // Column.
Record.push_back((unsigned)0); // Offset.
return;
}
Record.push_back(getEmitFile(PLoc.getFilename()));
Record.push_back(PLoc.getLine());
Record.push_back(PLoc.getColumn()+TokSize);
Record.push_back(Loc.getFileOffset());
} | subq $0x58, %rsp
movq %rdi, %rax
leaq 0x60(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movl %esi, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
movq %rax, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movl %r8d, 0x34(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
callq 0x95b2e0
testb $0x1, %al
jne 0xd057ce
jmp 0xd0580b
movq 0x38(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xce5850
movq 0x38(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xce5850
movq 0x38(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xce5850
movq 0x38(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xce5850
jmp 0xd058a2
movq 0x20(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
callq 0x95b300
movq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0xd04920
movq (%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0xce5850
movq 0x20(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x971210
movq 0x8(%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0xce5850
movq 0x20(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x971220
movq 0x10(%rsp), %rdi
addl 0x34(%rsp), %eax
movl %eax, %eax
movl %eax, %esi
callq 0xce5850
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x971f10
movq 0x18(%rsp), %rdi
movl %eax, %eax
movl %eax, %esi
callq 0xce5850
addq $0x58, %rsp
retq
nopw (%rax,%rax)
| /Frontend/SerializedDiagnosticPrinter.cpp |
clang::serialized_diags::SerializedDiagnosticReader::skipUntilRecordOrBlock(llvm::BitstreamCursor&, unsigned int&) | llvm::ErrorOr<SerializedDiagnosticReader::Cursor>
SerializedDiagnosticReader::skipUntilRecordOrBlock(
llvm::BitstreamCursor &Stream, unsigned &BlockOrRecordID) {
BlockOrRecordID = 0;
while (!Stream.AtEndOfStream()) {
unsigned Code;
if (Expected<unsigned> Res = Stream.ReadCode())
Code = Res.get();
else
return llvm::errorToErrorCode(Res.takeError());
if (Code >= static_cast<unsigned>(llvm::bitc::FIRST_APPLICATION_ABBREV)) {
// We found a record.
BlockOrRecordID = Code;
return Cursor::Record;
}
switch (static_cast<llvm::bitc::FixedAbbrevIDs>(Code)) {
case llvm::bitc::ENTER_SUBBLOCK:
if (Expected<unsigned> Res = Stream.ReadSubBlockID())
BlockOrRecordID = Res.get();
else
return llvm::errorToErrorCode(Res.takeError());
return Cursor::BlockBegin;
case llvm::bitc::END_BLOCK:
if (Stream.ReadBlockEnd())
return SDError::InvalidDiagnostics;
return Cursor::BlockEnd;
case llvm::bitc::DEFINE_ABBREV:
if (llvm::Error Err = Stream.ReadAbbrevRecord())
return llvm::errorToErrorCode(std::move(Err));
continue;
case llvm::bitc::UNABBREV_RECORD:
return SDError::UnsupportedConstruct;
case llvm::bitc::FIRST_APPLICATION_ABBREV:
llvm_unreachable("Unexpected abbrev id.");
}
}
return SDError::InvalidDiagnostics;
} | subq $0xc8, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movq %rcx, 0xa8(%rsp)
movq 0xa8(%rsp), %rax
movl $0x0, (%rax)
movq 0xb0(%rsp), %rdi
callq 0xd07430
xorb $-0x1, %al
testb $0x1, %al
jne 0xd08efa
jmp 0xd091d3
movq 0xb0(%rsp), %rsi
leaq 0x90(%rsp), %rdi
callq 0xd07720
leaq 0x90(%rsp), %rdi
callq 0x878a10
testb $0x1, %al
jne 0xd08f22
jmp 0xd08f3a
leaq 0x90(%rsp), %rdi
callq 0xbc6ba0
movl (%rax), %eax
movl %eax, 0xa4(%rsp)
jmp 0xd08f92
leaq 0x78(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x878a60
leaq 0x78(%rsp), %rdi
callq 0x863e60
movq 0x10(%rsp), %rdi
movl %eax, 0x80(%rsp)
movq %rdx, 0x88(%rsp)
movl 0x80(%rsp), %esi
movq 0x88(%rsp), %rdx
callq 0xd09200
leaq 0x78(%rsp), %rdi
callq 0x7f51d0
movl $0x1, 0x74(%rsp)
jmp 0xd08f9a
movl $0x0, 0x74(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x878b10
movl 0x74(%rsp), %eax
testl %eax, %eax
je 0xd08fb6
jmp 0xd08fb1
jmp 0xd091e6
cmpl $0x4, 0xa4(%rsp)
jb 0xd08ff1
movq 0x10(%rsp), %rdi
movl 0xa4(%rsp), %ecx
movq 0xa8(%rsp), %rax
movl %ecx, (%rax)
movl $0x1, 0x70(%rsp)
leaq 0x70(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xd09240
jmp 0xd091e6
movl 0xa4(%rsp), %eax
movq %rax, 0x8(%rsp)
subq $0x4, %rax
ja 0xd091ce
movq 0x8(%rsp), %rax
leaq 0x71f86b9(%rip), %rcx # 0x7f016cc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0xb0(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0xd07780
leaq 0x60(%rsp), %rdi
callq 0x878a10
testb $0x1, %al
jne 0xd0903e
jmp 0xd09056
leaq 0x60(%rsp), %rdi
callq 0xbc6ba0
movl (%rax), %ecx
movq 0xa8(%rsp), %rax
movl %ecx, (%rax)
jmp 0xd0909f
leaq 0x48(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x878a60
leaq 0x48(%rsp), %rdi
callq 0x863e60
movq 0x10(%rsp), %rdi
movl %eax, 0x50(%rsp)
movq %rdx, 0x58(%rsp)
movl 0x50(%rsp), %esi
movq 0x58(%rsp), %rdx
callq 0xd09200
leaq 0x48(%rsp), %rdi
callq 0x7f51d0
movl $0x1, 0x74(%rsp)
jmp 0xd090a7
movl $0x0, 0x74(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x878b10
movl 0x74(%rsp), %eax
testl %eax, %eax
je 0xd090c0
jmp 0xd090bb
jmp 0xd091e6
movq 0x10(%rsp), %rdi
movl $0x3, 0x44(%rsp)
leaq 0x44(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xd09240
jmp 0xd091e6
movq 0xb0(%rsp), %rdi
callq 0xd09280
testb $0x1, %al
jne 0xd090f3
jmp 0xd0910b
movq 0x10(%rsp), %rdi
movl $0x3, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xd092d0
jmp 0xd091e6
movq 0x10(%rsp), %rdi
movl $0x2, 0x40(%rsp)
leaq 0x40(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0xd09240
jmp 0xd091e6
movq 0xb0(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x7bc38d0
leaq 0x38(%rsp), %rdi
callq 0x7f7980
testb $0x1, %al
jne 0xd0914d
jmp 0xd09196
leaq 0x20(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x7f7940
leaq 0x20(%rsp), %rdi
callq 0x863e60
movq 0x10(%rsp), %rdi
movl %eax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movl 0x28(%rsp), %esi
movq 0x30(%rsp), %rdx
callq 0xd09200
leaq 0x20(%rsp), %rdi
callq 0x7f51d0
movl $0x1, 0x74(%rsp)
jmp 0xd0919e
movl $0x0, 0x74(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x7f51d0
movl 0x74(%rsp), %eax
testl %eax, %eax
je 0xd091b4
jmp 0xd091b2
jmp 0xd091e6
jmp 0xd08ee2
movq 0x10(%rsp), %rdi
movl $0xc, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xd092d0
jmp 0xd091e6
jmp 0xd08ee2
movq 0x10(%rsp), %rdi
movl $0x3, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xd092d0
movq 0x18(%rsp), %rax
addq $0xc8, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /Frontend/SerializedDiagnosticReader.cpp |
clang::TextDiagnosticPrinter::HandleDiagnostic(clang::DiagnosticsEngine::Level, clang::Diagnostic const&) | void TextDiagnosticPrinter::HandleDiagnostic(DiagnosticsEngine::Level Level,
const Diagnostic &Info) {
// Default implementation (Warnings/errors count).
DiagnosticConsumer::HandleDiagnostic(Level, Info);
// Render the diagnostic message into a temporary buffer eagerly. We'll use
// this later as we print out the diagnostic to the terminal.
SmallString<100> OutStr;
Info.FormatDiagnostic(OutStr);
llvm::raw_svector_ostream DiagMessageStream(OutStr);
printDiagnosticOptions(DiagMessageStream, Level, Info, *DiagOpts);
// Keeps track of the starting position of the location
// information (e.g., "foo.c:10:4:") that precedes the error
// message. We use this information to determine how long the
// file+line+column number prefix is.
uint64_t StartOfLocationInfo = OS.tell();
if (!Prefix.empty())
OS << Prefix << ": ";
// Use a dedicated, simpler path for diagnostics without a valid location.
// This is important as if the location is missing, we may be emitting
// diagnostics in a context that lacks language options, a source manager, or
// other infrastructure necessary when emitting more rich diagnostics.
if (!Info.getLocation().isValid()) {
TextDiagnostic::printDiagnosticLevel(OS, Level, DiagOpts->ShowColors);
TextDiagnostic::printDiagnosticMessage(
OS, /*IsSupplemental=*/Level == DiagnosticsEngine::Note,
DiagMessageStream.str(), OS.tell() - StartOfLocationInfo,
DiagOpts->MessageLength, DiagOpts->ShowColors);
OS.flush();
return;
}
// Assert that the rest of our infrastructure is setup properly.
assert(DiagOpts && "Unexpected diagnostic without options set");
assert(Info.hasSourceManager() &&
"Unexpected diagnostic with no source manager");
assert(TextDiag && "Unexpected diagnostic outside source file processing");
TextDiag->emitDiagnostic(
FullSourceLoc(Info.getLocation(), Info.getSourceManager()), Level,
DiagMessageStream.str(), Info.getRanges(), Info.getFixItHints());
OS.flush();
} | pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rdi, 0x1a8(%rsp)
movl %esi, 0x1a4(%rsp)
movq %rdx, 0x198(%rsp)
movq 0x1a8(%rsp), %rdi
movq %rdi, 0x68(%rsp)
movl 0x1a4(%rsp), %esi
movq 0x198(%rsp), %rdx
callq 0x94b5e0
leaq 0x118(%rsp), %rdi
callq 0xcec370
movq 0x198(%rsp), %rdi
leaq 0x118(%rsp), %rsi
callq 0x94b640
leaq 0xe0(%rsp), %rdi
leaq 0x118(%rsp), %rsi
callq 0x83b200
movq 0x68(%rsp), %rdi
movl 0x1a4(%rsp), %eax
movl %eax, 0x5c(%rsp)
movq 0x198(%rsp), %rax
movq %rax, 0x60(%rsp)
addq $0x18, %rdi
callq 0x808f90
movl 0x5c(%rsp), %esi
movq 0x60(%rsp), %rdx
movq %rax, %rcx
leaq 0xe0(%rsp), %rdi
callq 0xd100b0
movq 0x68(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x8d70e0
movq 0x68(%rsp), %rdi
movq %rax, 0xd8(%rsp)
addq $0x28, %rdi
callq 0x73b030
testb $0x1, %al
jne 0xd0fdff
movq 0x68(%rsp), %rsi
movq 0x10(%rsi), %rdi
addq $0x28, %rsi
callq 0x7e6bb0
movq %rax, %rdi
leaq 0x71ebe27(%rip), %rsi # 0x7efbc21
callq 0x7e6c00
movq 0x198(%rsp), %rdi
callq 0x94b520
movq %rax, %rdi
callq 0x94e100
testb $0x1, %al
jne 0xd0ff53
movq 0x68(%rsp), %rdi
movq 0x10(%rdi), %rax
movq %rax, 0x38(%rsp)
movl 0x1a4(%rsp), %eax
movl %eax, 0x44(%rsp)
addq $0x18, %rdi
callq 0xcce240
movq 0x38(%rsp), %rdi
movl 0x44(%rsp), %esi
movq 0x4(%rax), %rax
shrq $0x12, %rax
andq $0x1, %rax
cmpl $0x0, %eax
setne %al
movzbl %al, %edx
andl $0x1, %edx
callq 0xd6d190
movq 0x68(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x48(%rsp)
cmpl $0x1, 0x1a4(%rsp)
sete %al
movb %al, 0x5b(%rsp)
leaq 0xe0(%rsp), %rdi
callq 0x83b5e0
movq %rax, %rcx
movq 0x68(%rsp), %rax
movq %rcx, 0xc8(%rsp)
movq %rdx, 0xd0(%rsp)
movq 0x10(%rax), %rdi
callq 0x8d70e0
movq 0x68(%rsp), %rdi
subq 0xd8(%rsp), %rax
movl %eax, 0x50(%rsp)
addq $0x18, %rdi
callq 0xcce240
movq 0x68(%rsp), %rdi
movq 0x24(%rax), %rax
shrq $0x20, %rax
movl %eax, 0x54(%rsp)
addq $0x18, %rdi
callq 0xcce240
movq 0x48(%rsp), %rdi
movl 0x50(%rsp), %r8d
movl 0x54(%rsp), %r9d
movq %rax, %rcx
movb 0x5b(%rsp), %al
movq 0x4(%rcx), %rcx
shrq $0x12, %rcx
andq $0x1, %rcx
cmpl $0x0, %ecx
setne %sil
movq 0xc8(%rsp), %rdx
movq 0xd0(%rsp), %rcx
movzbl %sil, %r10d
andl $0x1, %r10d
movq %rsp, %rsi
movl %r10d, (%rsi)
movzbl %al, %esi
andl $0x1, %esi
callq 0xd6d2f0
movq 0x68(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x7f97b0
movl $0x1, 0xc4(%rsp)
jmp 0xd1008b
movq 0x68(%rsp), %rdi
addq $0x20, %rdi
callq 0xd10380
movq %rax, 0x28(%rsp)
movq 0x198(%rsp), %rdi
callq 0x94b520
movl (%rax), %eax
movl %eax, 0xac(%rsp)
movq 0x198(%rsp), %rdi
callq 0x94e120
movq %rax, %rdx
movl 0xac(%rsp), %esi
leaq 0xb0(%rsp), %rdi
callq 0x94e140
movl 0x1a4(%rsp), %eax
movl %eax, 0x34(%rsp)
leaq 0xe0(%rsp), %rdi
callq 0x83b5e0
movq %rax, 0x98(%rsp)
movq %rdx, 0xa0(%rsp)
movq 0x198(%rsp), %rdi
callq 0x94e220
movq %rax, 0x88(%rsp)
movq %rdx, 0x90(%rsp)
movq 0x198(%rsp), %rdi
callq 0x94e2b0
movq %rax, 0x78(%rsp)
movq %rdx, 0x80(%rsp)
leaq 0x70(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xcf5a30
movq 0x28(%rsp), %rdi
movl 0x34(%rsp), %ecx
movl 0xb0(%rsp), %esi
movq 0xb8(%rsp), %rdx
movq 0x98(%rsp), %r8
movq 0xa0(%rsp), %r9
movq 0x70(%rsp), %rax
leaq 0x88(%rsp), %r11
leaq 0x78(%rsp), %r10
movq (%r11), %rbx
movq %rbx, (%rsp)
movq 0x8(%r11), %r11
movq %r11, 0x8(%rsp)
movq (%r10), %r11
movq %r11, 0x10(%rsp)
movq 0x8(%r10), %r10
movq %r10, 0x18(%rsp)
movq %rax, 0x20(%rsp)
callq 0xd618a0
movq 0x68(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x7f97b0
movl $0x0, 0xc4(%rsp)
leaq 0xe0(%rsp), %rdi
callq 0x83b640
leaq 0x118(%rsp), %rdi
callq 0xcec470
addq $0x1b0, %rsp # imm = 0x1B0
popq %rbx
retq
nop
| /Frontend/TextDiagnosticPrinter.cpp |
clang::VerifyDiagnosticConsumer::HandleDiagnostic(clang::DiagnosticsEngine::Level, clang::Diagnostic const&) | void VerifyDiagnosticConsumer::HandleDiagnostic(
DiagnosticsEngine::Level DiagLevel, const Diagnostic &Info) {
if (Info.hasSourceManager()) {
// If this diagnostic is for a different source manager, ignore it.
if (SrcManager && &Info.getSourceManager() != SrcManager)
return;
setSourceManager(Info.getSourceManager());
}
#ifndef NDEBUG
// Debug build tracks unparsed files for possible
// unparsed expected-* directives.
if (SrcManager) {
SourceLocation Loc = Info.getLocation();
if (Loc.isValid()) {
ParsedStatus PS = IsUnparsed;
Loc = SrcManager->getExpansionLoc(Loc);
FileID FID = SrcManager->getFileID(Loc);
auto FE = SrcManager->getFileEntryRefForID(FID);
if (FE && CurrentPreprocessor && SrcManager->isLoadedFileID(FID)) {
// If the file is a modules header file it shall not be parsed
// for expected-* directives.
HeaderSearch &HS = CurrentPreprocessor->getHeaderSearchInfo();
if (HS.findModuleForHeader(*FE))
PS = IsUnparsedNoDirectives;
}
UpdateParsedFileStatus(*SrcManager, FID, PS);
}
}
#endif
// Send the diagnostic to the buffer, we will check it once we reach the end
// of the source file (or are destructed).
Buffer->HandleDiagnostic(DiagLevel, Info);
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0xcec310
testb $0x1, %al
jne 0xd1146c
jmp 0xd114a6
movq 0x8(%rsp), %rax
cmpq $0x0, 0x50(%rax)
je 0xd1148f
movq 0x10(%rsp), %rdi
callq 0x94e120
movq 0x8(%rsp), %rcx
cmpq 0x50(%rcx), %rax
je 0xd1148f
jmp 0xd114c6
movq 0x10(%rsp), %rdi
callq 0x94e120
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xd10900
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
callq 0xd114d0
movq %rax, %rdi
movl 0x1c(%rsp), %esi
movq 0x10(%rsp), %rdx
movq (%rdi), %rax
callq *0x38(%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
| /Frontend/VerifyDiagnosticConsumer.cpp |
llvm::DenseMap<clang::FileID, clang::VerifyDiagnosticConsumer::UnparsedFileStatus, llvm::DenseMapInfo<clang::FileID, void>, llvm::detail::DenseMapPair<clang::FileID, clang::VerifyDiagnosticConsumer::UnparsedFileStatus>>::init(unsigned int) | void init(unsigned InitNumEntries) {
auto InitBuckets = BaseT::getMinBucketToReserveForEntries(InitNumEntries);
if (allocateBuckets(InitBuckets)) {
this->BaseT::initEmpty();
} else {
NumEntries = 0;
NumTombstones = 0;
}
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movl 0xc(%rsp), %esi
callq 0xd1b300
movq (%rsp), %rdi
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %esi
callq 0xd1b350
testb $0x1, %al
jne 0xd1b2d6
jmp 0xd1b2e1
movq (%rsp), %rdi
callq 0xd1b3c0
jmp 0xd1b2f3
movq (%rsp), %rax
movl $0x0, 0x8(%rax)
movl $0x0, 0xc(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
| /llvm/ADT/DenseMap.h |
llvm::StringMap<llvm::SmallVector<(anonymous namespace)::UnattachedDirective, 2u>, llvm::MallocAllocator>::~StringMap() | ~StringMap() {
// Delete all the elements in the map, but don't reset the elements
// to default values. This is a copy of clear(), but avoids unnecessary
// work not required in the destructor.
if (!empty()) {
for (unsigned I = 0, E = NumBuckets; I != E; ++I) {
StringMapEntryBase *Bucket = TheTable[I];
if (Bucket && Bucket != getTombstoneVal()) {
static_cast<MapEntryTy *>(Bucket)->Destroy(getAllocator());
}
}
}
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x7f3a10
testb $0x1, %al
jne 0xd1b769
movq 0x18(%rsp), %rax
movl $0x0, 0x2c(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x28(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x28(%rsp), %eax
je 0xd1b767
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl 0x2c(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0xd1b758
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x7f3a30
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
je 0xd1b758
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x7f3aa0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xd16df0
jmp 0xd1b75a
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0xd1b6f4
jmp 0xd1b769
movq 0x18(%rsp), %rdi
callq 0x7f3ab0
addq $0x38, %rsp
retq
nopl (%rax,%rax)
| /llvm/ADT/StringMap.h |
clang::AttributedTypeLoc clang::TypeLoc::getAs<clang::AttributedTypeLoc>() const | T getAs() const {
if (!T::isKind(*this))
return {};
T t;
TypeLoc& tl = t;
tl = *this;
return t;
} | subq $0x28, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xd290e0
testb $0x1, %al
jne 0xd28d68
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x73aa90
leaq 0x18(%rsp), %rdi
callq 0xd1e780
jmp 0xd28d93
leaq 0x18(%rsp), %rdi
callq 0xd1f340
movq (%rsp), %rcx
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rdx
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /clang/AST/TypeLoc.h |
llvm::trailing_objects_internal::TrailingObjectsImpl<8, clang::OMPMapClause, llvm::TrailingObjects<clang::OMPMapClause, clang::Expr*, clang::ValueDecl*, unsigned int, clang::OMPClauseMappableExprCommon::MappableComponent>, clang::OMPMapClause, clang::Expr*, clang::ValueDecl*, unsigned int, clang::OMPClauseMappableExprCommon::MappableComponent>::getTrailingObjectsImpl(clang::OMPMapClause*, llvm::trailing_objects_internal::TrailingObjectsBase::OverloadToken<clang::Expr*>) | static NextTy *
getTrailingObjectsImpl(BaseTy *Obj,
TrailingObjectsBase::OverloadToken<NextTy>) {
auto *Ptr = TopTrailingObj::getTrailingObjectsImpl(
Obj, TrailingObjectsBase::OverloadToken<PrevTy>()) +
TopTrailingObj::callNumTrailingObjects(
Obj, TrailingObjectsBase::OverloadToken<PrevTy>());
if (requiresRealignment())
return reinterpret_cast<NextTy *>(alignAddr(Ptr, Align::Of<NextTy>()));
else
return reinterpret_cast<NextTy *>(Ptr);
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0xd2f340
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0xd2f350
movq %rax, %rcx
movq (%rsp), %rax
imulq $0x90, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /llvm/Support/TrailingObjects.h |
clang::operator==(clang::specific_attr_iterator<clang::WeakRefAttr, llvm::SmallVector<clang::Attr*, 4u>>, clang::specific_attr_iterator<clang::WeakRefAttr, llvm::SmallVector<clang::Attr*, 4u>>) | bool operator==(specific_attr_iterator Left,
specific_attr_iterator Right) {
assert((Left.Current == nullptr) == (Right.Current == nullptr));
if (Left.Current < Right.Current)
Left.AdvanceToNext(Right.Current);
else
Right.AdvanceToNext(Left.Current);
return Left.Current == Right.Current;
} | subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0xd4c12b
movq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0xd4c150
jmp 0xd4c13a
movq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0xd4c150
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
sete %al
andb $0x1, %al
addq $0x18, %rsp
retq
nop
| /clang/AST/AttrIterator.h |
llvm::DenseMapBase<llvm::DenseMap<clang::DeclContext const*, llvm::StringRef, llvm::DenseMapInfo<clang::DeclContext const*, void>, llvm::detail::DenseMapPair<clang::DeclContext const*, llvm::StringRef>>, clang::DeclContext const*, llvm::StringRef, llvm::DenseMapInfo<clang::DeclContext const*, void>, llvm::detail::DenseMapPair<clang::DeclContext const*, llvm::StringRef>>::destroyAll() | void destroyAll() {
if (getNumBuckets() == 0) // Nothing to do.
return;
const KeyT EmptyKey = getEmptyKey(), TombstoneKey = getTombstoneKey();
for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) {
if (!KeyInfoT::isEqual(P->getFirst(), EmptyKey) &&
!KeyInfoT::isEqual(P->getFirst(), TombstoneKey))
P->getSecond().~ValueT();
P->getFirst().~KeyT();
}
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xbdf2f0
cmpl $0x0, %eax
jne 0xd51d22
jmp 0xd51dba
callq 0xbdf210
movq %rax, 0x28(%rsp)
callq 0xd51dc0
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
callq 0xbdf220
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0xbdf230
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0xd51dba
movq 0x18(%rsp), %rdi
callq 0xbdf270
movq (%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0xd51dd0
testb $0x1, %al
jne 0xd51da0
movq 0x18(%rsp), %rdi
callq 0xbdf270
movq (%rax), %rdi
movq 0x20(%rsp), %rsi
callq 0xd51dd0
testb $0x1, %al
jne 0xd51da0
movq 0x18(%rsp), %rdi
callq 0xd51df0
movq 0x18(%rsp), %rdi
callq 0xbdf270
movq 0x18(%rsp), %rax
addq $0x18, %rax
movq %rax, 0x18(%rsp)
jmp 0xd51d54
addq $0x38, %rsp
retq
nop
| /llvm/ADT/DenseMap.h |
checkRangesForMacroArgExpansion(clang::FullSourceLoc, llvm::ArrayRef<clang::CharSourceRange>) | static bool checkRangesForMacroArgExpansion(FullSourceLoc Loc,
ArrayRef<CharSourceRange> Ranges) {
assert(Loc.isMacroID() && "Must be a macro expansion!");
SmallVector<CharSourceRange, 4> SpellingRanges;
mapDiagnosticRanges(Loc, Ranges, SpellingRanges);
// Count all valid ranges.
unsigned ValidCount =
llvm::count_if(Ranges, [](const auto &R) { return R.isValid(); });
if (ValidCount > SpellingRanges.size())
return false;
// To store the source location of the argument location.
FullSourceLoc ArgumentLoc;
// Set the ArgumentLoc to the beginning location of the expansion of Loc
// so to check if the ranges expands to the same beginning location.
if (!Loc.isMacroArgExpansion(&ArgumentLoc))
return false;
for (const auto &Range : SpellingRanges)
if (!checkRangeForMacroArgExpansion(Range, Loc.getManager(), ArgumentLoc))
return false;
return true;
} | subq $0xf8, %rsp
movl %edi, 0xe0(%rsp)
movq %rsi, 0xe8(%rsp)
movq %rdx, 0xd0(%rsp)
movq %rcx, 0xd8(%rsp)
leaq 0x90(%rsp), %rdi
callq 0xd4fee0
movq 0xe0(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0xe8(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x78(%rsp)
movl 0x80(%rsp), %edi
movq 0x88(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq 0x78(%rsp), %rcx
leaq 0x90(%rsp), %r8
callq 0xd634c0
leaq 0xd0(%rsp), %rdi
callq 0xd677d0
movl %eax, 0x6c(%rsp)
movl 0x6c(%rsp), %eax
movq %rax, 0x8(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x87dfe0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jbe 0xd63f7c
movb $0x0, 0xf7(%rsp)
movl $0x1, 0x64(%rsp)
jmp 0xd64084
leaq 0x50(%rsp), %rdi
callq 0x94de70
leaq 0xe0(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x971cf0
testb $0x1, %al
jne 0xd63fb1
movb $0x0, 0xf7(%rsp)
movl $0x1, 0x64(%rsp)
jmp 0xd64084
leaq 0x90(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x94ec80
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0x94ec90
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rax
cmpq 0x38(%rsp), %rax
je 0xd64074
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x24(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x2c(%rsp)
leaq 0xe0(%rsp), %rdi
callq 0x94e370
movq %rax, %rdx
movl 0x50(%rsp), %eax
movl %eax, 0x20(%rsp)
movq 0x24(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movb 0x18(%rsp), %al
movl 0x20(%rsp), %ecx
movzbl %al, %esi
callq 0xd67810
testb $0x1, %al
jne 0xd6405f
movb $0x0, 0xf7(%rsp)
movl $0x1, 0x64(%rsp)
jmp 0xd64084
jmp 0xd64061
movq 0x40(%rsp), %rax
addq $0xc, %rax
movq %rax, 0x40(%rsp)
jmp 0xd63fdc
movb $0x1, 0xf7(%rsp)
movl $0x1, 0x64(%rsp)
leaq 0x90(%rsp), %rdi
callq 0xd50090
movb 0xf7(%rsp), %al
andb $0x1, %al
addq $0xf8, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /Frontend/DiagnosticRenderer.cpp |
void llvm::SmallVectorTemplateBase<clang::CharSourceRange, true>::uninitialized_copy<clang::CharSourceRange const, clang::CharSourceRange>(clang::CharSourceRange const*, clang::CharSourceRange const*, clang::CharSourceRange*, std::enable_if<std::is_same<std::remove_const<clang::CharSourceRange const>::type, clang::CharSourceRange>::value, void>::type*) | static void uninitialized_copy(
T1 *I, T1 *E, T2 *Dest,
std::enable_if_t<std::is_same<std::remove_const_t<T1>, T2>::value> * =
nullptr) {
// Use memcpy for PODs iterated by pointers (which includes SmallVector
// iterators): std::uninitialized_copy optimizes to memmove, but we can
// use memcpy here. Note that I and E are iterators and thus might be
// invalid for memcpy if they are equal.
if (I != E)
memcpy(reinterpret_cast<void *>(Dest), I, (E - I) * sizeof(T));
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0xd67d4e
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
subq %rcx, %rax
movl $0xc, %ecx
cqto
idivq %rcx
imulq $0xc, %rax, %rdx
callq 0x73a720
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /llvm/ADT/SmallVector.h |
llvm::SmallVectorImpl<clang::CharSourceRange>::assignRemote(llvm::SmallVectorImpl<clang::CharSourceRange>&&) | void assignRemote(SmallVectorImpl &&RHS) {
this->destroy_range(this->begin(), this->end());
if (!this->isSmall())
free(this->begin());
this->BeginX = RHS.BeginX;
this->Size = RHS.Size;
this->Capacity = RHS.Capacity;
RHS.resetToSmall();
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x94ec80
movq 0x10(%rsp), %rdi
movq %rax, 0x8(%rsp)
callq 0x94ec90
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x94ec70
movq 0x10(%rsp), %rdi
callq 0x94ed10
testb $0x1, %al
jne 0xd6c569
movq 0x10(%rsp), %rdi
callq 0x94ec80
movq %rax, %rdi
callq 0x73a760
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq 0x18(%rsp), %rcx
movl 0xc(%rcx), %ecx
movl %ecx, 0xc(%rax)
movq 0x18(%rsp), %rdi
callq 0xd6c620
addq $0x28, %rsp
retq
nop
| /llvm/ADT/SmallVector.h |
getTopFrameworkDir(clang::FileManager&, llvm::StringRef, llvm::SmallVectorImpl<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&) | static OptionalDirectoryEntryRef
getTopFrameworkDir(FileManager &FileMgr, StringRef DirName,
SmallVectorImpl<std::string> &SubmodulePath) {
assert(llvm::sys::path::extension(DirName) == ".framework" &&
"Not a framework directory");
// Note: as an egregious but useful hack we use the real path here, because
// frameworks moving between top-level frameworks to embedded frameworks tend
// to be symlinked, and we base the logical structure of modules on the
// physical layout. In particular, we need to deal with crazy includes like
//
// #include <Foo/Frameworks/Bar.framework/Headers/Wibble.h>
//
// where 'Bar' used to be embedded in 'Foo', is now a top-level framework
// which one should access with, e.g.,
//
// #include <Bar/Wibble.h>
//
// Similar issues occur when a top-level framework has moved into an
// embedded framework.
auto TopFrameworkDir = FileMgr.getOptionalDirectoryRef(DirName);
if (TopFrameworkDir)
DirName = FileMgr.getCanonicalName(*TopFrameworkDir);
do {
// Get the parent directory name.
DirName = llvm::sys::path::parent_path(DirName);
if (DirName.empty())
break;
// Determine whether this directory exists.
auto Dir = FileMgr.getOptionalDirectoryRef(DirName);
if (!Dir)
break;
// If this is a framework directory, then we're a subframework of this
// framework.
if (llvm::sys::path::extension(DirName) == ".framework") {
SubmodulePath.push_back(std::string(llvm::sys::path::stem(DirName)));
TopFrameworkDir = *Dir;
}
} while (true);
return TopFrameworkDir;
} | subq $0x118, %rsp # imm = 0x118
movq %rsi, 0x100(%rsp)
movq %rdx, 0x108(%rsp)
movq %rdi, 0xf8(%rsp)
movq %rcx, 0xf0(%rsp)
movq 0xf8(%rsp), %rdi
movq 0x100(%rsp), %rax
movq %rax, 0xe0(%rsp)
movq 0x108(%rsp), %rax
movq %rax, 0xe8(%rsp)
movq 0xe0(%rsp), %rsi
movq 0xe8(%rsp), %rdx
movl $0x1, %ecx
callq 0xbdc5f0
movq %rax, 0x110(%rsp)
leaq 0x110(%rsp), %rdi
callq 0xbdc680
testb $0x1, %al
jne 0xd856c4
jmp 0xd8572b
movq 0xf8(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x110(%rsp), %rdi
callq 0xcbde40
movq 0x10(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0xc8(%rsp)
movq 0xc8(%rsp), %rsi
callq 0x997750
movq %rax, 0xd0(%rsp)
movq %rdx, 0xd8(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x100(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x108(%rsp)
jmp 0xd8572d
movq 0x100(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0x108(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0xa8(%rsp), %rdi
movq 0xb0(%rsp), %rsi
xorl %edx, %edx
callq 0x8dc7b0
movq %rax, 0xb8(%rsp)
movq %rdx, 0xc0(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x100(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x108(%rsp)
leaq 0x100(%rsp), %rdi
callq 0x7ed530
testb $0x1, %al
jne 0xd857a7
jmp 0xd857ac
jmp 0xd8592e
movq 0xf8(%rsp), %rdi
movq 0x100(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x108(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x90(%rsp), %rsi
movq 0x98(%rsp), %rdx
movl $0x1, %ecx
callq 0xbdc5f0
movq %rax, 0xa0(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0xbdc680
testb $0x1, %al
jne 0xd8580c
jmp 0xd8592e
movq 0x100(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x108(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x70(%rsp), %rdi
movq 0x78(%rsp), %rsi
xorl %edx, %edx
callq 0x8dd9f0
movq %rax, 0x80(%rsp)
movq %rdx, 0x88(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x7174cfd(%rip), %rsi # 0x7efa550
callq 0x7eb0f0
movq 0x80(%rsp), %rdi
movq 0x88(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq 0x68(%rsp), %rcx
callq 0x7ed410
testb $0x1, %al
jne 0xd85880
jmp 0xd85920
movq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x100(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x108(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
xorl %edx, %edx
callq 0x8dd860
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
leaq 0x1f(%rsp), %rdi
callq 0x73a200
leaq 0x40(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x1f(%rsp), %rdx
callq 0x7f6ce0
movq 0x8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x865680
leaq 0x40(%rsp), %rdi
callq 0x73b5d0
leaq 0x1f(%rsp), %rdi
callq 0x73b530
leaq 0xa0(%rsp), %rdi
callq 0xcbde40
movq %rax, %rsi
leaq 0x110(%rsp), %rdi
callq 0xcc6b10
jmp 0xd85922
movb $0x1, %al
testb $0x1, %al
jne 0xd8572d
jmp 0xd8592e
movq 0x110(%rsp), %rax
addq $0x118, %rsp # imm = 0x118
retq
nop
| /Lex/HeaderSearch.cpp |
llvm::DenseMapBase<llvm::DenseMap<clang::DirectoryEntry const*, bool, llvm::DenseMapInfo<clang::DirectoryEntry const*, void>, llvm::detail::DenseMapPair<clang::DirectoryEntry const*, bool>>, clang::DirectoryEntry const*, bool, llvm::DenseMapInfo<clang::DirectoryEntry const*, void>, llvm::detail::DenseMapPair<clang::DirectoryEntry const*, bool>>::initEmpty() | void initEmpty() {
setNumEntries(0);
setNumTombstones(0);
assert((getNumBuckets() & (getNumBuckets()-1)) == 0 &&
"# initial buckets must be a power of two!");
const KeyT EmptyKey = getEmptyKey();
for (BucketT *B = getBuckets(), *E = getBucketsEnd(); B != E; ++B)
::new (&B->getFirst()) KeyT(EmptyKey);
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
xorl %esi, %esi
callq 0xd8a6f0
movq (%rsp), %rdi
xorl %esi, %esi
callq 0xd8a710
callq 0xd59170
movq (%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0xd59190
movq (%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0xd591a0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
je 0xd8a5a8
movq 0x10(%rsp), %rdi
callq 0xd591e0
movq 0x18(%rsp), %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x10(%rsp)
jmp 0xd8a57a
addq $0x28, %rsp
retq
nopl (%rax)
| /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<clang::DirectoryEntry const*, bool, llvm::DenseMapInfo<clang::DirectoryEntry const*, void>, llvm::detail::DenseMapPair<clang::DirectoryEntry const*, bool>>, clang::DirectoryEntry const*, bool, llvm::DenseMapInfo<clang::DirectoryEntry const*, void>, llvm::detail::DenseMapPair<clang::DirectoryEntry const*, bool>>::getMinBucketToReserveForEntries(unsigned int) | unsigned getMinBucketToReserveForEntries(unsigned NumEntries) {
// Ensure that "NumEntries * 4 < NumBuckets * 3"
if (NumEntries == 0)
return 0;
// +1 is required because of the strict equality.
// For example if NumEntries is 48, we need to return 401.
return NextPowerOf2(NumEntries * 4 / 3 + 1);
} | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0xd8a7fe
movl $0x0, 0x14(%rsp)
jmp 0xd8a81e
movl 0x4(%rsp), %eax
shll $0x2, %eax
movl $0x3, %ecx
xorl %edx, %edx
divl %ecx
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x7f65b0
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
| /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<clang::FileEntry const*, bool, llvm::DenseMapInfo<clang::FileEntry const*, void>, llvm::detail::DenseMapPair<clang::FileEntry const*, bool>>, clang::FileEntry const*, bool, llvm::DenseMapInfo<clang::FileEntry const*, void>, llvm::detail::DenseMapPair<clang::FileEntry const*, bool>>::getMinBucketToReserveForEntries(unsigned int) | unsigned getMinBucketToReserveForEntries(unsigned NumEntries) {
// Ensure that "NumEntries * 4 < NumBuckets * 3"
if (NumEntries == 0)
return 0;
// +1 is required because of the strict equality.
// For example if NumEntries is 48, we need to return 401.
return NextPowerOf2(NumEntries * 4 / 3 + 1);
} | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0xd8a8ae
movl $0x0, 0x14(%rsp)
jmp 0xd8a8ce
movl 0x4(%rsp), %eax
shll $0x2, %eax
movl $0x3, %ecx
xorl %edx, %edx
divl %ecx
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x7f65b0
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
| /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<unsigned int, unsigned int, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, unsigned int>>, unsigned int, unsigned int, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, unsigned int>>::makeIterator(llvm::detail::DenseMapPair<unsigned int, unsigned int>*, llvm::detail::DenseMapPair<unsigned int, unsigned int>*, llvm::DebugEpochBase&, bool) | iterator makeIterator(BucketT *P, BucketT *E,
DebugEpochBase &Epoch,
bool NoAdvance=false) {
if (shouldReverseIterate<KeyT>()) {
BucketT *B = P == getBucketsEnd() ? getBuckets() : P + 1;
return iterator(B, E, Epoch, NoAdvance);
}
return iterator(P, E, Epoch, NoAdvance);
} | subq $0x58, %rsp
movb %r8b, %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x82c200
testb $0x1, %al
jne 0xd90046
jmp 0xd900b2
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0xcf7ae0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jne 0xd90077
movq 0x10(%rsp), %rdi
callq 0xcf7ad0
movq %rax, (%rsp)
jmp 0xd90084
movq 0x38(%rsp), %rax
addq $0x8, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movb 0x27(%rsp), %al
leaq 0x48(%rsp), %rdi
andb $0x1, %al
movzbl %al, %r8d
callq 0xd900f0
jmp 0xd900d5
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movb 0x27(%rsp), %al
leaq 0x48(%rsp), %rdi
andb $0x1, %al
movzbl %al, %r8d
callq 0xd900f0
movq 0x48(%rsp), %rax
movq 0x50(%rsp), %rdx
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<clang::FileEntry const*, llvm::SmallString<64u>, llvm::DenseMapInfo<clang::FileEntry const*, void>, llvm::detail::DenseMapPair<clang::FileEntry const*, llvm::SmallString<64u>>>, clang::FileEntry const*, llvm::SmallString<64u>, llvm::DenseMapInfo<clang::FileEntry const*, void>, llvm::detail::DenseMapPair<clang::FileEntry const*, llvm::SmallString<64u>>>::moveFromOldBuckets(llvm::detail::DenseMapPair<clang::FileEntry const*, llvm::SmallString<64u>>*, llvm::detail::DenseMapPair<clang::FileEntry const*, llvm::SmallString<64u>>*) | 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();
}
} | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xd8ab70
callq 0xd58e70
movq %rax, 0x48(%rsp)
callq 0xd58e80
movq %rax, 0x40(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
cmpq 0x30(%rsp), %rax
je 0xd9105d
movq 0x38(%rsp), %rdi
callq 0xd58ee0
movq (%rax), %rdi
movq 0x48(%rsp), %rsi
callq 0x980d80
testb $0x1, %al
jne 0xd91040
movq 0x38(%rsp), %rdi
callq 0xd58ee0
movq (%rax), %rdi
movq 0x40(%rsp), %rsi
callq 0x980d80
testb $0x1, %al
jne 0xd91040
movq 0x38(%rsp), %rdi
callq 0xd58ee0
movq 0x18(%rsp), %rdi
movq %rax, %rsi
leaq 0x28(%rsp), %rdx
callq 0xd909e0
andb $0x1, %al
movb %al, 0x27(%rsp)
movq 0x38(%rsp), %rdi
callq 0xd58ee0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0xd58ee0
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movq 0x28(%rsp), %rdi
callq 0xd58ef0
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
callq 0xd58ef0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0xd91070
movq 0x18(%rsp), %rdi
callq 0xd90e00
movq 0x38(%rsp), %rdi
callq 0xd58ef0
movq %rax, %rdi
callq 0x81f2a0
movq 0x38(%rsp), %rdi
callq 0xd58ee0
movq 0x38(%rsp), %rax
addq $0x60, %rax
movq %rax, 0x38(%rsp)
jmp 0xd90f6a
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /llvm/ADT/DenseMap.h |
RemoveDuplicates(std::vector<(anonymous namespace)::DirectoryLookupInfo, std::allocator<(anonymous namespace)::DirectoryLookupInfo>>&, unsigned int, bool) | static unsigned RemoveDuplicates(std::vector<DirectoryLookupInfo> &SearchList,
unsigned First, bool Verbose) {
llvm::SmallPtrSet<const DirectoryEntry *, 8> SeenDirs;
llvm::SmallPtrSet<const DirectoryEntry *, 8> SeenFrameworkDirs;
llvm::SmallPtrSet<const HeaderMap *, 8> SeenHeaderMaps;
unsigned NonSystemRemoved = 0;
for (unsigned i = First; i != SearchList.size(); ++i) {
unsigned DirToRemove = i;
const DirectoryLookup &CurEntry = SearchList[i].Lookup;
if (CurEntry.isNormalDir()) {
// If this isn't the first time we've seen this dir, remove it.
if (SeenDirs.insert(CurEntry.getDir()).second)
continue;
} else if (CurEntry.isFramework()) {
// If this isn't the first time we've seen this framework dir, remove it.
if (SeenFrameworkDirs.insert(CurEntry.getFrameworkDir()).second)
continue;
} else {
assert(CurEntry.isHeaderMap() && "Not a headermap or normal dir?");
// If this isn't the first time we've seen this headermap, remove it.
if (SeenHeaderMaps.insert(CurEntry.getHeaderMap()).second)
continue;
}
// If we have a normal #include dir/framework/headermap that is shadowed
// later in the chain by a system include location, we actually want to
// ignore the user's request and drop the user dir... keeping the system
// dir. This is weird, but required to emulate GCC's search path correctly.
//
// Since dupes of system dirs are rare, just rescan to find the original
// that we're nuking instead of using a DenseMap.
if (CurEntry.getDirCharacteristic() != SrcMgr::C_User) {
// Find the dir that this is the same of.
unsigned FirstDir;
for (FirstDir = First;; ++FirstDir) {
assert(FirstDir != i && "Didn't find dupe?");
const DirectoryLookup &SearchEntry = SearchList[FirstDir].Lookup;
// If these are different lookup types, then they can't be the dupe.
if (SearchEntry.getLookupType() != CurEntry.getLookupType())
continue;
bool isSame;
if (CurEntry.isNormalDir())
isSame = SearchEntry.getDir() == CurEntry.getDir();
else if (CurEntry.isFramework())
isSame = SearchEntry.getFrameworkDir() == CurEntry.getFrameworkDir();
else {
assert(CurEntry.isHeaderMap() && "Not a headermap or normal dir?");
isSame = SearchEntry.getHeaderMap() == CurEntry.getHeaderMap();
}
if (isSame)
break;
}
// If the first dir in the search path is a non-system dir, zap it
// instead of the system one.
if (SearchList[FirstDir].Lookup.getDirCharacteristic() == SrcMgr::C_User)
DirToRemove = FirstDir;
}
if (Verbose) {
llvm::errs() << "ignoring duplicate directory \""
<< CurEntry.getName() << "\"\n";
if (DirToRemove != i)
llvm::errs() << " as it is a non-system directory that duplicates "
<< "a system directory\n";
}
if (DirToRemove != i)
++NonSystemRemoved;
// This is reached if the current entry is a duplicate. Remove the
// DirToRemove (usually the current dir).
SearchList.erase(SearchList.begin()+DirToRemove);
--i;
}
return NonSystemRemoved;
} | subq $0x218, %rsp # imm = 0x218
movb %dl, %al
movq %rdi, 0x210(%rsp)
movl %esi, 0x20c(%rsp)
andb $0x1, %al
movb %al, 0x20b(%rsp)
leaq 0x1a8(%rsp), %rdi
callq 0xd96b10
leaq 0x148(%rsp), %rdi
callq 0xd96b10
leaq 0xe8(%rsp), %rdi
callq 0xd96b30
movl $0x0, 0xe4(%rsp)
movl 0x20c(%rsp), %eax
movl %eax, 0xe0(%rsp)
movl 0xe0(%rsp), %eax
movq %rax, 0x38(%rsp)
movq 0x210(%rsp), %rdi
callq 0xd94ff0
movq %rax, %rcx
movq 0x38(%rsp), %rax
cmpq %rcx, %rax
je 0xd965f1
movl 0xe0(%rsp), %eax
movl %eax, 0xdc(%rsp)
movq 0x210(%rsp), %rdi
movl 0xe0(%rsp), %eax
movl %eax, %esi
callq 0xd96850
addq $0x8, %rax
movq %rax, 0xd0(%rsp)
movq 0xd0(%rsp), %rdi
callq 0xd697c0
testb $0x1, %al
jne 0xd9627e
jmp 0xd962b7
movq 0xd0(%rsp), %rdi
callq 0xd7f4c0
movq %rax, %rdx
leaq 0xb8(%rsp), %rdi
leaq 0x1a8(%rsp), %rsi
callq 0xd96b50
testb $0x1, 0xc8(%rsp)
je 0xd962b2
jmp 0xd965db
jmp 0xd96338
movq 0xd0(%rsp), %rdi
callq 0xd7dd80
testb $0x1, %al
jne 0xd962ca
jmp 0xd96300
movq 0xd0(%rsp), %rdi
callq 0xd96be0
movq %rax, %rdx
leaq 0xa0(%rsp), %rdi
leaq 0x148(%rsp), %rsi
callq 0xd96b50
testb $0x1, 0xb0(%rsp)
je 0xd962fe
jmp 0xd965db
jmp 0xd96336
movq 0xd0(%rsp), %rdi
callq 0xd7e6a0
movq %rax, %rdx
leaq 0x88(%rsp), %rdi
leaq 0xe8(%rsp), %rsi
callq 0xd96c20
testb $0x1, 0x98(%rsp)
je 0xd96334
jmp 0xd965db
jmp 0xd96336
jmp 0xd96338
movq 0xd0(%rsp), %rdi
callq 0xd7ddf0
cmpl $0x0, %eax
je 0xd964b9
movl 0x20c(%rsp), %eax
movl %eax, 0x84(%rsp)
movq 0x210(%rsp), %rdi
movl 0x84(%rsp), %eax
movl %eax, %esi
callq 0xd96850
addq $0x8, %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rdi
callq 0xd699e0
movl %eax, 0x34(%rsp)
movq 0xd0(%rsp), %rdi
callq 0xd699e0
movl %eax, %ecx
movl 0x34(%rsp), %eax
cmpl %ecx, %eax
je 0xd963a5
jmp 0xd9646c
movq 0xd0(%rsp), %rdi
callq 0xd697c0
testb $0x1, %al
jne 0xd963b8
jmp 0xd963ea
movq 0x78(%rsp), %rdi
callq 0xd7f4c0
movq %rax, 0x28(%rsp)
movq 0xd0(%rsp), %rdi
callq 0xd7f4c0
movq %rax, %rcx
movq 0x28(%rsp), %rax
cmpq %rcx, %rax
sete %al
andb $0x1, %al
movb %al, 0x77(%rsp)
jmp 0xd96461
movq 0xd0(%rsp), %rdi
callq 0xd7dd80
testb $0x1, %al
jne 0xd963fd
jmp 0xd9642f
movq 0x78(%rsp), %rdi
callq 0xd96be0
movq %rax, 0x20(%rsp)
movq 0xd0(%rsp), %rdi
callq 0xd96be0
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
sete %al
andb $0x1, %al
movb %al, 0x77(%rsp)
jmp 0xd9645f
movq 0x78(%rsp), %rdi
callq 0xd7e6a0
movq %rax, 0x18(%rsp)
movq 0xd0(%rsp), %rdi
callq 0xd7e6a0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
sete %al
andb $0x1, %al
movb %al, 0x77(%rsp)
jmp 0xd96461
testb $0x1, 0x77(%rsp)
je 0xd9646a
jmp 0xd96482
jmp 0xd9646c
movl 0x84(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x84(%rsp)
jmp 0xd9635c
movq 0x210(%rsp), %rdi
movl 0x84(%rsp), %eax
movl %eax, %esi
callq 0xd96850
movq %rax, %rdi
addq $0x8, %rdi
callq 0xd7ddf0
cmpl $0x0, %eax
jne 0xd964b7
movl 0x84(%rsp), %eax
movl %eax, 0xdc(%rsp)
jmp 0xd964b9
testb $0x1, 0x20b(%rsp)
je 0xd9654f
callq 0x8d7480
movq %rax, %rdi
leaq 0x716bdb5(%rip), %rsi # 0x7f0228b
callq 0x7e6c00
movq %rax, 0x10(%rsp)
movq 0xd0(%rsp), %rdi
callq 0xd7e7d0
movq 0x10(%rsp), %rdi
movq %rax, 0x60(%rsp)
movq %rdx, 0x68(%rsp)
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rdx
callq 0x7ebb60
movq %rax, %rdi
leaq 0x73409e2(%rip), %rsi # 0x80d6ef7
callq 0x7e6c00
movl 0xdc(%rsp), %eax
cmpl 0xe0(%rsp), %eax
je 0xd9654d
callq 0x8d7480
movq %rax, %rdi
leaq 0x716bd71(%rip), %rsi # 0x7f022aa
callq 0x7e6c00
movq %rax, %rdi
leaq 0x716bd95(%rip), %rsi # 0x7f022dd
callq 0x7e6c00
jmp 0xd9654f
movl 0xdc(%rsp), %eax
cmpl 0xe0(%rsp), %eax
je 0xd96570
movl 0xe4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xe4(%rsp)
movq 0x210(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x210(%rsp), %rdi
callq 0xd94eb0
movq %rax, 0x48(%rsp)
movl 0xdc(%rsp), %eax
movl %eax, %esi
leaq 0x48(%rsp), %rdi
callq 0xd96d20
movq %rax, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xd96d60
movq 0x8(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0xd96cb0
movq %rax, 0x40(%rsp)
movl 0xe0(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xe0(%rsp)
movl 0xe0(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xe0(%rsp)
jmp 0xd96211
movl 0xe4(%rsp), %eax
movl %eax, 0x4(%rsp)
leaq 0xe8(%rsp), %rdi
callq 0xd96da0
leaq 0x148(%rsp), %rdi
callq 0xd96db0
leaq 0x1a8(%rsp), %rdi
callq 0xd96db0
movl 0x4(%rsp), %eax
addq $0x218, %rsp # imm = 0x218
retq
nop
| /Lex/InitHeaderSearch.cpp |
clang::Lexer::Create_PragmaLexer(clang::SourceLocation, clang::SourceLocation, clang::SourceLocation, unsigned int, clang::Preprocessor&) | Lexer *Lexer::Create_PragmaLexer(SourceLocation SpellingLoc,
SourceLocation ExpansionLocStart,
SourceLocation ExpansionLocEnd,
unsigned TokLen, Preprocessor &PP) {
SourceManager &SM = PP.getSourceManager();
// Create the lexer as if we were going to lex the file normally.
FileID SpellingFID = SM.getFileID(SpellingLoc);
llvm::MemoryBufferRef InputFile = SM.getBufferOrFake(SpellingFID);
Lexer *L = new Lexer(SpellingFID, InputFile, PP);
// Now that the lexer is created, change the start/end locations so that we
// just lex the subsection of the file that we want. This is lexing from a
// scratch buffer.
const char *StrData = SM.getCharacterData(SpellingLoc);
L->BufferPtr = StrData;
L->BufferEnd = StrData+TokLen;
assert(L->BufferEnd[0] == 0 && "Buffer is not nul terminated!");
// Set the SourceLocation with the remapping information. This ensures that
// GetMappedTokenLoc will remap the tokens as they are lexed.
L->FileLoc = SM.createExpansionLoc(SM.getLocForStartOfFile(SpellingFID),
ExpansionLocStart,
ExpansionLocEnd, TokLen);
// Ensure that the lexer thinks it is inside a directive, so that end \n will
// return an EOD token.
L->ParsingPreprocessorDirective = true;
// This lexer really is for _Pragma.
L->Is_PragmaLexer = true;
return L;
} | subq $0xa8, %rsp
movl %edi, 0xa4(%rsp)
movl %esi, 0xa0(%rsp)
movl %edx, 0x9c(%rsp)
movl %ecx, 0x98(%rsp)
movq %r8, 0x90(%rsp)
movq 0x90(%rsp), %rdi
callq 0xbcea10
movq %rax, 0x88(%rsp)
movq 0x88(%rsp), %rdi
movl 0xa4(%rsp), %eax
movl %eax, 0x80(%rsp)
movl 0x80(%rsp), %esi
callq 0x94f740
movl %eax, 0x84(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x84(%rsp), %eax
movl %eax, 0x5c(%rsp)
leaq 0x58(%rsp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x73aa90
leaq 0x58(%rsp), %rdi
callq 0x9485e0
movq 0x10(%rsp), %rsi
movl 0x5c(%rsp), %edx
movl 0x58(%rsp), %ecx
leaq 0x60(%rsp), %rdi
callq 0x950c50
movl $0xd0, %edi
callq 0x73b270
movq %rax, %rdi
movq %rdi, 0x18(%rsp)
movl 0x84(%rsp), %eax
movl %eax, 0x4c(%rsp)
movq 0x90(%rsp), %rcx
movl 0x4c(%rsp), %esi
leaq 0x60(%rsp), %rdx
movl $0x1, %r8d
callq 0xd98b00
movq 0x18(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x88(%rsp), %rdi
movl 0xa4(%rsp), %eax
movl %eax, 0x3c(%rsp)
movl 0x3c(%rsp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x97a110
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rcx
movq 0x50(%rsp), %rax
movq %rcx, 0x98(%rax)
movq 0x40(%rsp), %rcx
movl 0x98(%rsp), %eax
addq %rax, %rcx
movq 0x50(%rsp), %rax
movq %rcx, 0x78(%rax)
movq 0x88(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x88(%rsp), %rdi
movl 0x84(%rsp), %eax
movl %eax, 0x30(%rsp)
movl 0x30(%rsp), %esi
callq 0x950cf0
movq 0x20(%rsp), %rdi
movl %eax, 0x34(%rsp)
movl 0xa0(%rsp), %eax
movl %eax, 0x2c(%rsp)
movl 0x9c(%rsp), %eax
movl %eax, 0x28(%rsp)
movl 0x98(%rsp), %r8d
movl 0x34(%rsp), %esi
movl 0x2c(%rsp), %edx
movl 0x28(%rsp), %ecx
movl $0x1, %r9d
xorl %eax, %eax
movl $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x9756e0
movl %eax, 0x38(%rsp)
movq 0x50(%rsp), %rax
movl 0x38(%rsp), %ecx
movl %ecx, 0x80(%rax)
movq 0x50(%rsp), %rax
movb $0x1, 0x18(%rax)
movq 0x50(%rsp), %rax
movb $0x1, 0x91(%rax)
movq 0x50(%rsp), %rax
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /Lex/Lexer.cpp |
isAllowedIDChar(unsigned int, clang::LangOptions const&, bool&) | static bool isAllowedIDChar(uint32_t C, const LangOptions &LangOpts,
bool &IsExtension) {
if (LangOpts.AsmPreprocessor) {
return false;
} else if (LangOpts.DollarIdents && '$' == C) {
return true;
} else if (LangOpts.CPlusPlus || LangOpts.C23) {
// A non-leading codepoint must have the XID_Continue property.
// XIDContinueRanges doesn't contains characters also in XIDStartRanges,
// so we need to check both tables.
// '_' doesn't have the XID_Continue property but is allowed in C and C++.
static const llvm::sys::UnicodeCharSet XIDStartChars(XIDStartRanges);
static const llvm::sys::UnicodeCharSet XIDContinueChars(XIDContinueRanges);
if (C == '_' || XIDStartChars.contains(C) || XIDContinueChars.contains(C))
return true;
return isMathematicalExtensionID(C, LangOpts, /*IsStart=*/false,
IsExtension);
} else if (LangOpts.C11) {
static const llvm::sys::UnicodeCharSet C11AllowedIDChars(
C11AllowedIDCharRanges);
return C11AllowedIDChars.contains(C);
} else {
static const llvm::sys::UnicodeCharSet C99AllowedIDChars(
C99AllowedIDCharRanges);
return C99AllowedIDChars.contains(C);
}
} | subq $0x18, %rsp
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
shrq $0x20, %rax
andq $0x1, %rax
cmpl $0x0, %eax
je 0xd9d690
movb $0x0, 0x17(%rsp)
jmp 0xd9d77a
movq 0x8(%rsp), %rax
movq (%rax), %rax
shrq $0x1f, %rax
andq $0x1, %rax
cmpl $0x0, %eax
je 0xd9d6ba
movl $0x24, %eax
cmpl 0x10(%rsp), %eax
jne 0xd9d6ba
movb $0x1, 0x17(%rsp)
jmp 0xd9d77a
movq 0x8(%rsp), %rax
movq (%rax), %rax
shrq $0xa, %rax
andq $0x1, %rax
cmpl $0x0, %eax
jne 0xd9d6e4
movq 0x8(%rsp), %rax
movq (%rax), %rax
shrq $0x3, %rax
andq $0x1, %rax
cmpl $0x0, %eax
je 0xd9d738
cmpl $0x5f, 0x10(%rsp)
je 0xd9d715
movl 0x10(%rsp), %esi
leaq 0xaf61562(%rip), %rdi # 0xbcfec58
callq 0x928e90
testb $0x1, %al
jne 0xd9d715
movl 0x10(%rsp), %esi
leaq 0xaf6155e(%rip), %rdi # 0xbcfec68
callq 0x928e90
testb $0x1, %al
jne 0xd9d715
jmp 0xd9d71c
movb $0x1, 0x17(%rsp)
jmp 0xd9d77a
movl 0x10(%rsp), %edi
movq 0x8(%rsp), %rsi
movq (%rsp), %rcx
xorl %edx, %edx
callq 0xda8720
andb $0x1, %al
movb %al, 0x17(%rsp)
jmp 0xd9d77a
movq 0x8(%rsp), %rax
movq (%rax), %rax
shrq %rax
andq $0x1, %rax
cmpl $0x0, %eax
je 0xd9d764
movl 0x10(%rsp), %esi
leaq 0xaf61521(%rip), %rdi # 0xbcfec78
callq 0x928e90
andb $0x1, %al
movb %al, 0x17(%rsp)
jmp 0xd9d77a
movl 0x10(%rsp), %esi
leaq 0xaf61519(%rip), %rdi # 0xbcfec88
callq 0x928e90
andb $0x1, %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
| /Lex/Lexer.cpp |
clang::Lexer::Lex(clang::Token&) | bool Lexer::Lex(Token &Result) {
assert(!isDependencyDirectivesLexer());
// Start a new token.
Result.startToken();
// Set up misc whitespace flags for LexTokenInternal.
if (IsAtStartOfLine) {
Result.setFlag(Token::StartOfLine);
IsAtStartOfLine = false;
}
if (HasLeadingSpace) {
Result.setFlag(Token::LeadingSpace);
HasLeadingSpace = false;
}
if (HasLeadingEmptyMacro) {
Result.setFlag(Token::LeadingEmptyMacro);
HasLeadingEmptyMacro = false;
}
bool atPhysicalStartOfLine = IsAtPhysicalStartOfLine;
IsAtPhysicalStartOfLine = false;
bool isRawLex = isLexingRawMode();
(void) isRawLex;
bool returnedToken = LexTokenInternal(Result, atPhysicalStartOfLine);
// (After the LexTokenInternal call, the lexer might be destroyed.)
assert((returnedToken || !isRawLex) && "Raw lex must succeed");
return returnedToken;
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0xcf44d0
movq 0x8(%rsp), %rax
testb $0x1, 0xa0(%rax)
je 0xda2b9b
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0xd9cb90
movq 0x8(%rsp), %rax
movb $0x0, 0xa0(%rax)
movq 0x8(%rsp), %rax
testb $0x1, 0xa2(%rax)
je 0xda2bc4
movq 0x18(%rsp), %rdi
movl $0x2, %esi
callq 0xd9cb90
movq 0x8(%rsp), %rax
movb $0x0, 0xa2(%rax)
movq 0x8(%rsp), %rax
testb $0x1, 0xa3(%rax)
je 0xda2bed
movq 0x18(%rsp), %rdi
movl $0x10, %esi
callq 0xd9cb90
movq 0x8(%rsp), %rax
movb $0x0, 0xa3(%rax)
movq 0x8(%rsp), %rdi
movb 0xa1(%rdi), %al
andb $0x1, %al
movb %al, 0x17(%rsp)
movb $0x0, 0xa1(%rdi)
callq 0xd9cbb0
movq 0x8(%rsp), %rdi
andb $0x1, %al
movb %al, 0x16(%rsp)
movq 0x18(%rsp), %rsi
movb 0x17(%rsp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0xda4e70
andb $0x1, %al
movb %al, 0x15(%rsp)
movb 0x15(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
| /Lex/Lexer.cpp |
FindConflictEnd(char const*, char const*, clang::ConflictMarkerKind) | static const char *FindConflictEnd(const char *CurPtr, const char *BufferEnd,
ConflictMarkerKind CMK) {
const char *Terminator = CMK == CMK_Perforce ? "<<<<\n" : ">>>>>>>";
size_t TermLen = CMK == CMK_Perforce ? 5 : 7;
auto RestOfBuffer = StringRef(CurPtr, BufferEnd - CurPtr).substr(TermLen);
size_t Pos = RestOfBuffer.find(Terminator);
while (Pos != StringRef::npos) {
// Must occur at start of line.
if (Pos == 0 ||
(RestOfBuffer[Pos - 1] != '\r' && RestOfBuffer[Pos - 1] != '\n')) {
RestOfBuffer = RestOfBuffer.substr(Pos+TermLen);
Pos = RestOfBuffer.find(Terminator);
continue;
}
return RestOfBuffer.data()+Pos;
}
return nullptr;
} | subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movl %edx, 0x6c(%rsp)
movl 0x6c(%rsp), %edx
leaq 0x715f544(%rip), %rax # 0x7f02b34
leaq 0x715f537(%rip), %rcx # 0x7f02b2e
cmpl $0x2, %edx
cmoveq %rcx, %rax
movq %rax, 0x60(%rsp)
movl 0x6c(%rsp), %edx
movl $0x7, %eax
movl $0x5, %ecx
cmpl $0x2, %edx
cmovel %ecx, %eax
cltq
movq %rax, 0x58(%rsp)
movq 0x78(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq 0x78(%rsp), %rax
subq %rax, %rdx
leaq 0x38(%rsp), %rdi
callq 0x7f47a0
movq 0x58(%rsp), %rsi
leaq 0x38(%rsp), %rdi
movq $-0x1, %rdx
callq 0x7f7180
movq %rax, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x7eb0f0
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x48(%rsp), %rdi
xorl %eax, %eax
movl %eax, %ecx
callq 0x8876d0
movq %rax, 0x30(%rsp)
cmpq $-0x1, 0x30(%rsp)
je 0xda3754
cmpq $0x0, 0x30(%rsp)
je 0xda36d4
movq 0x30(%rsp), %rsi
subq $0x1, %rsi
leaq 0x48(%rsp), %rdi
callq 0x833050
movsbl %al, %eax
cmpl $0xd, %eax
je 0xda373b
movq 0x30(%rsp), %rsi
subq $0x1, %rsi
leaq 0x48(%rsp), %rdi
callq 0x833050
movsbl %al, %eax
cmpl $0xa, %eax
je 0xda373b
movq 0x30(%rsp), %rsi
addq 0x58(%rsp), %rsi
leaq 0x48(%rsp), %rdi
movq $-0x1, %rdx
callq 0x7f7180
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x60(%rsp), %rsi
movq %rsp, %rdi
callq 0x7eb0f0
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x48(%rsp), %rdi
xorl %eax, %eax
movl %eax, %ecx
callq 0x8876d0
movq %rax, 0x30(%rsp)
jmp 0xda3686
leaq 0x48(%rsp), %rdi
callq 0x7ed2e0
addq 0x30(%rsp), %rax
movq %rax, 0x80(%rsp)
jmp 0xda3760
movq $0x0, 0x80(%rsp)
movq 0x80(%rsp), %rax
addq $0x88, %rsp
retq
| /Lex/Lexer.cpp |
llvm::detail::TrailingZerosCounter<unsigned int, 4ul>::count(unsigned int) | static unsigned count(T Val) {
if (Val == 0)
return 32;
#if __has_builtin(__builtin_ctz) || defined(__GNUC__)
return __builtin_ctz(Val);
#elif defined(_MSC_VER)
unsigned long Index;
_BitScanForward(&Index, Val);
return Index;
#endif
} | movl %edi, -0x8(%rsp)
cmpl $0x0, -0x8(%rsp)
jne 0xda96a5
movl $0x20, -0x4(%rsp)
jmp 0xda96b1
movl -0x8(%rsp), %eax
tzcntl %eax, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
| /llvm/ADT/bit.h |
clang::StringLiteralParser::getOffsetOfStringByte(clang::Token const&, unsigned int) const | unsigned StringLiteralParser::getOffsetOfStringByte(const Token &Tok,
unsigned ByteNo) const {
// Get the spelling of the token.
SmallString<32> SpellingBuffer;
SpellingBuffer.resize(Tok.getLength());
bool StringInvalid = false;
const char *SpellingPtr = &SpellingBuffer[0];
unsigned TokLen = Lexer::getSpelling(Tok, SpellingPtr, SM, Features,
&StringInvalid);
if (StringInvalid)
return 0;
const char *SpellingStart = SpellingPtr;
const char *SpellingEnd = SpellingPtr+TokLen;
// Handle UTF-8 strings just like narrow strings.
if (SpellingPtr[0] == 'u' && SpellingPtr[1] == '8')
SpellingPtr += 2;
assert(SpellingPtr[0] != 'L' && SpellingPtr[0] != 'u' &&
SpellingPtr[0] != 'U' && "Doesn't handle wide or utf strings yet");
// For raw string literals, this is easy.
if (SpellingPtr[0] == 'R') {
assert(SpellingPtr[1] == '"' && "Should be a raw string literal!");
// Skip 'R"'.
SpellingPtr += 2;
while (*SpellingPtr != '(') {
++SpellingPtr;
assert(SpellingPtr < SpellingEnd && "Missing ( for raw string literal");
}
// Skip '('.
++SpellingPtr;
return SpellingPtr - SpellingStart + ByteNo;
}
// Skip over the leading quote
assert(SpellingPtr[0] == '"' && "Should be a string literal!");
++SpellingPtr;
// Skip over bytes until we find the offset we're looking for.
while (ByteNo) {
assert(SpellingPtr < SpellingEnd && "Didn't find byte offset!");
// Step over non-escapes simply.
if (*SpellingPtr != '\\') {
++SpellingPtr;
--ByteNo;
continue;
}
// Otherwise, this is an escape character. Advance over it.
bool HadError = false;
if (SpellingPtr[1] == 'u' || SpellingPtr[1] == 'U' ||
SpellingPtr[1] == 'N') {
const char *EscapePtr = SpellingPtr;
unsigned Len = MeasureUCNEscape(SpellingStart, SpellingPtr, SpellingEnd,
1, Features, HadError);
if (Len > ByteNo) {
// ByteNo is somewhere within the escape sequence.
SpellingPtr = EscapePtr;
break;
}
ByteNo -= Len;
} else {
ProcessCharEscape(SpellingStart, SpellingPtr, SpellingEnd, HadError,
FullSourceLoc(Tok.getLocation(), SM), CharByteWidth * 8,
Diags, Features, StringLiteralEvalMethod::Evaluated);
--ByteNo;
}
assert(!HadError && "This method isn't valid on erroneous strings");
}
return SpellingPtr-SpellingStart;
} | pushq %rbx
subq $0xf0, %rsp
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movl %edx, 0xd4(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x84b210
movq 0xd8(%rsp), %rdi
callq 0xcf5250
movl %eax, %eax
movl %eax, %esi
leaq 0x98(%rsp), %rdi
callq 0x87a880
movb $0x0, 0x97(%rsp)
leaq 0x98(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8dc530
movq %rax, %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x88(%rsp)
movq 0xd8(%rsp), %rdi
movq (%rax), %rdx
movq 0x8(%rax), %rcx
leaq 0x88(%rsp), %rsi
leaq 0x97(%rsp), %r8
callq 0xd99d10
movl %eax, 0x84(%rsp)
testb $0x1, 0x97(%rsp)
je 0xdb21f0
movl $0x0, 0xec(%rsp)
movl $0x1, 0x80(%rsp)
jmp 0xdb24a4
movq 0x88(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x88(%rsp), %rax
movl 0x84(%rsp), %ecx
addq %rcx, %rax
movq %rax, 0x70(%rsp)
movq 0x88(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x75, %eax
jne 0xdb2249
movq 0x88(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x38, %eax
jne 0xdb2249
movq 0x88(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x88(%rsp)
movq 0x88(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x52, %eax
jne 0xdb22d8
movq 0x88(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x88(%rsp)
movq 0x88(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x28, %eax
je 0xdb2293
movq 0x88(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x88(%rsp)
jmp 0xdb226d
movq 0x88(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x88(%rsp)
movq 0x88(%rsp), %rax
movq 0x78(%rsp), %rcx
subq %rcx, %rax
movl 0xd4(%rsp), %ecx
addq %rcx, %rax
movl %eax, 0xec(%rsp)
movl $0x1, 0x80(%rsp)
jmp 0xdb24a4
movq 0x88(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x88(%rsp)
cmpl $0x0, 0xd4(%rsp)
je 0xdb2482
movq 0x88(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
je 0xdb2331
movq 0x88(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x88(%rsp)
movl 0xd4(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xd4(%rsp)
jmp 0xdb22ec
movb $0x0, 0x6f(%rsp)
movq 0x88(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x75, %eax
je 0xdb2369
movq 0x88(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x55, %eax
je 0xdb2369
movq 0x88(%rsp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x4e, %eax
jne 0xdb23dc
movq 0x38(%rsp), %rax
movq 0x88(%rsp), %rcx
movq %rcx, 0x60(%rsp)
movq 0x78(%rsp), %rdi
movq 0x70(%rsp), %rdx
movq 0x8(%rax), %r8
leaq 0x88(%rsp), %rsi
movl $0x1, %ecx
leaq 0x6f(%rsp), %r9
callq 0xdb24d0
movl %eax, 0x5c(%rsp)
movl 0x5c(%rsp), %eax
cmpl 0xd4(%rsp), %eax
jbe 0xdb23c3
movq 0x60(%rsp), %rax
movq %rax, 0x88(%rsp)
jmp 0xdb2482
movl 0x5c(%rsp), %ecx
movl 0xd4(%rsp), %eax
subl %ecx, %eax
movl %eax, 0xd4(%rsp)
jmp 0xdb247d
movq 0x78(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0xd8(%rsp), %rdi
callq 0xcc5e50
movl %eax, %ecx
movq 0x38(%rsp), %rax
movl %ecx, 0x44(%rsp)
movq (%rax), %rdx
movl 0x44(%rsp), %esi
leaq 0x48(%rsp), %rdi
callq 0x94e140
movq 0x38(%rsp), %rax
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rdx
movl 0x28(%rax), %r11d
shll $0x3, %r11d
movq 0x18(%rax), %r10
movq 0x8(%rax), %rax
movl 0x48(%rsp), %r8d
movq 0x50(%rsp), %r9
leaq 0x88(%rsp), %rsi
leaq 0x6f(%rsp), %rcx
xorl %ebx, %ebx
movl %r11d, (%rsp)
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
callq 0xdae4a0
movl 0xd4(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xd4(%rsp)
jmp 0xdb22ec
movq 0x88(%rsp), %rax
movq 0x78(%rsp), %rcx
subq %rcx, %rax
movl %eax, 0xec(%rsp)
movl $0x1, 0x80(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x84b220
movl 0xec(%rsp), %eax
addq $0xf0, %rsp
popq %rbx
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| /Lex/LiteralSupport.cpp |
MeasureUCNEscape(char const*, char const*&, char const*, unsigned int, clang::LangOptions const&, bool&) | static int MeasureUCNEscape(const char *ThisTokBegin, const char *&ThisTokBuf,
const char *ThisTokEnd, unsigned CharByteWidth,
const LangOptions &Features, bool &HadError) {
// UTF-32: 4 bytes per escape.
if (CharByteWidth == 4)
return 4;
uint32_t UcnVal = 0;
unsigned short UcnLen = 0;
FullSourceLoc Loc;
if (!ProcessUCNEscape(ThisTokBegin, ThisTokBuf, ThisTokEnd, UcnVal,
UcnLen, Loc, nullptr, Features, true)) {
HadError = true;
return 0;
}
// UTF-16: 2 bytes for BMP, 4 bytes otherwise.
if (CharByteWidth == 2)
return UcnVal <= 0xFFFF ? 2 : 4;
// UTF-8.
if (UcnVal < 0x80)
return 1;
if (UcnVal < 0x800)
return 2;
if (UcnVal < 0x10000)
return 3;
return 4;
} | subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq %rdx, 0x68(%rsp)
movl %ecx, 0x64(%rsp)
movq %r8, 0x58(%rsp)
movq %r9, 0x50(%rsp)
cmpl $0x4, 0x64(%rsp)
jne 0xdb250b
movl $0x4, 0x84(%rsp)
jmp 0xdb2610
movl $0x0, 0x4c(%rsp)
movw $0x0, 0x4a(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x94de70
movq 0x78(%rsp), %rdi
movq 0x70(%rsp), %rsi
movq 0x68(%rsp), %rdx
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x58(%rsp), %rax
leaq 0x4c(%rsp), %rcx
leaq 0x4a(%rsp), %r8
leaq 0x28(%rsp), %r10
xorl %r9d, %r9d
movq (%r10), %r11
movq %r11, (%rsp)
movq 0x8(%r10), %r10
movq %r10, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movl $0x1, 0x18(%rsp)
callq 0xdadc20
testb $0x1, %al
jne 0xdb2599
movq 0x50(%rsp), %rax
movb $0x1, (%rax)
movl $0x0, 0x84(%rsp)
jmp 0xdb2610
cmpl $0x2, 0x64(%rsp)
jne 0xdb25c0
movl 0x4c(%rsp), %edx
movl $0x4, %eax
movl $0x2, %ecx
cmpl $0xffff, %edx # imm = 0xFFFF
cmovbel %ecx, %eax
movl %eax, 0x84(%rsp)
jmp 0xdb2610
cmpl $0x80, 0x4c(%rsp)
jae 0xdb25d7
movl $0x1, 0x84(%rsp)
jmp 0xdb2610
cmpl $0x800, 0x4c(%rsp) # imm = 0x800
jae 0xdb25ee
movl $0x2, 0x84(%rsp)
jmp 0xdb2610
cmpl $0x10000, 0x4c(%rsp) # imm = 0x10000
jae 0xdb2605
movl $0x3, 0x84(%rsp)
jmp 0xdb2610
movl $0x4, 0x84(%rsp)
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
nop
| /Lex/LiteralSupport.cpp |
clang::MacroInfo::getDefinitionLengthSlow(clang::SourceManager const&) const | unsigned MacroInfo::getDefinitionLengthSlow(const SourceManager &SM) const {
assert(!IsDefinitionLengthCached);
IsDefinitionLengthCached = true;
ArrayRef<Token> ReplacementTokens = tokens();
if (ReplacementTokens.empty())
return (DefinitionLength = 0);
const Token &firstToken = ReplacementTokens.front();
const Token &lastToken = ReplacementTokens.back();
SourceLocation macroStart = firstToken.getLocation();
SourceLocation macroEnd = lastToken.getLocation();
assert(macroStart.isValid() && macroEnd.isValid());
assert((macroStart.isFileID() || firstToken.is(tok::comment)) &&
"Macro defined in macro?");
assert((macroEnd.isFileID() || lastToken.is(tok::comment)) &&
"Macro defined in macro?");
std::pair<FileID, unsigned>
startInfo = SM.getDecomposedExpansionLoc(macroStart);
std::pair<FileID, unsigned>
endInfo = SM.getDecomposedExpansionLoc(macroEnd);
assert(startInfo.first == endInfo.first &&
"Macro definition spanning multiple FileIDs ?");
assert(startInfo.second <= endInfo.second);
DefinitionLength = endInfo.second - startInfo.second;
DefinitionLength += lastToken.getLength();
return DefinitionLength;
} | subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movw 0x24(%rdi), %ax
andw $-0x2, %ax
orw $0x1, %ax
movw %ax, 0x24(%rdi)
callq 0xcf43f0
movq %rax, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xdb13d0
testb $0x1, %al
jne 0xdb40e7
jmp 0xdb4100
movq 0x8(%rsp), %rax
movl $0x0, 0x20(%rax)
movl $0x0, 0x64(%rsp)
jmp 0xdb41a1
leaq 0x40(%rsp), %rdi
callq 0xdb1dc0
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xdb1dd0
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0xcc5e50
movl %eax, 0x2c(%rsp)
movq 0x30(%rsp), %rdi
callq 0xcc5e50
movl %eax, 0x28(%rsp)
movq 0x50(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %esi
callq 0x971a70
movq %rax, 0x20(%rsp)
movq 0x50(%rsp), %rdi
movl 0x28(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %esi
callq 0x971a70
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x14(%rsp)
movl 0x18(%rsp), %ecx
subl 0x24(%rsp), %ecx
movl %ecx, 0x20(%rax)
movq 0x30(%rsp), %rdi
callq 0xcf5250
movl %eax, %ecx
movq 0x8(%rsp), %rax
addl 0x20(%rax), %ecx
movl %ecx, 0x20(%rax)
movl 0x20(%rax), %eax
movl %eax, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopw (%rax,%rax)
| /Lex/MacroInfo.cpp |
clang::ModuleMap::resolveLinkAsDependencies(clang::Module*) | void ModuleMap::resolveLinkAsDependencies(Module *Mod) {
auto PendingLinkAs = PendingLinkAsModule.find(Mod->Name);
if (PendingLinkAs != PendingLinkAsModule.end()) {
for (auto &Name : PendingLinkAs->second) {
auto *M = findModule(Name.getKey());
if (M)
M->UseExportAsModuleLinkName = true;
}
}
} | subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x428, %rax # imm = 0x428
movq %rax, 0x8(%rsp)
movq 0x78(%rsp), %rsi
leaq 0x60(%rsp), %rdi
callq 0x7eaca0
movq 0x8(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rdx
callq 0xdb5a30
movq 0x10(%rsp), %rdi
movq %rax, 0x70(%rsp)
addq $0x428, %rdi # imm = 0x428
callq 0xdb5ae0
movq %rax, 0x58(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0xdb5ab0
testb $0x1, %al
jne 0xdb5972
jmp 0xdb5a27
leaq 0x70(%rsp), %rdi
callq 0xdb5b20
movq %rax, 0x48(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xdb5b50
addq $0x8, %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x9f9ae0
movq %rax, 0x40(%rsp)
movq 0x50(%rsp), %rdi
callq 0x9f9b20
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x9f9b60
testb $0x1, %al
jne 0xdb59c7
jmp 0xdb5a25
leaq 0x40(%rsp), %rdi
callq 0x9f9b90
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x804160
movq 0x10(%rsp), %rdi
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0xdb5b60
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0xdb5a17
movq 0x28(%rsp), %rax
movb $0x1, 0x908(%rax)
jmp 0xdb5a19
leaq 0x40(%rsp), %rdi
callq 0x9f9c10
jmp 0xdb59b2
jmp 0xdb5a27
addq $0x88, %rsp
retq
nop
| /Lex/ModuleMap.cpp |
updateModuleTimestamp(clang::serialization::ModuleFile&) | static void updateModuleTimestamp(ModuleFile &MF) {
// Overwrite the timestamp file contents so that file's mtime changes.
std::string TimestampFilename = MF.getTimestampFilename();
std::error_code EC;
llvm::raw_fd_ostream OS(TimestampFilename, EC,
llvm::sys::fs::OF_TextWithCRLF);
if (EC)
return;
OS << "Timestamp file\n";
OS.close();
OS.clear_error(); // Avoid triggering a fatal error.
} | subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq 0xb0(%rsp), %rsi
leaq 0x90(%rsp), %rdi
callq 0xed6510
leaq 0x80(%rsp), %rdi
callq 0x7f50e0
leaq 0x10(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x7eaca0
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x20(%rsp), %rdi
leaq 0x80(%rsp), %rcx
movl $0x3, %r8d
callq 0x8d68a0
leaq 0x80(%rsp), %rdi
callq 0x7f5160
testb $0x1, %al
jne 0xe90fd8
jmp 0xe90fe2
movl $0x1, 0xc(%rsp)
jmp 0xe9100f
leaq 0x20(%rsp), %rdi
leaq 0x707a708(%rip), %rsi # 0x7f0b6f6
callq 0x7e6c00
leaq 0x20(%rsp), %rdi
callq 0x8d6f80
leaq 0x20(%rsp), %rdi
callq 0xd02910
movl $0x0, 0xc(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x8d6c90
leaq 0x90(%rsp), %rdi
callq 0x73b5d0
addq $0xb8, %rsp
retq
nop
| /Serialization/ASTReader.cpp |
non-virtual thunk to clang::ASTReader::ReadPreprocessedEntity(unsigned int) | PreprocessedEntity *ASTReader::ReadPreprocessedEntity(unsigned Index) {
PreprocessedEntityID PPID = Index+1;
std::pair<ModuleFile *, unsigned> PPInfo = getModulePreprocessedEntity(Index);
ModuleFile &M = *PPInfo.first;
unsigned LocalIndex = PPInfo.second;
const PPEntityOffset &PPOffs = M.PreprocessedEntityOffsets[LocalIndex];
if (!PP.getPreprocessingRecord()) {
Error("no preprocessing record");
return nullptr;
}
SavedStreamPosition SavedPosition(M.PreprocessorDetailCursor);
if (llvm::Error Err = M.PreprocessorDetailCursor.JumpToBit(
M.MacroOffsetsBase + PPOffs.getOffset())) {
Error(std::move(Err));
return nullptr;
}
Expected<llvm::BitstreamEntry> MaybeEntry =
M.PreprocessorDetailCursor.advance(BitstreamCursor::AF_DontPopBlockAtEnd);
if (!MaybeEntry) {
Error(MaybeEntry.takeError());
return nullptr;
}
llvm::BitstreamEntry Entry = MaybeEntry.get();
if (Entry.Kind != llvm::BitstreamEntry::Record)
return nullptr;
// Read the record.
SourceRange Range(ReadSourceLocation(M, PPOffs.getBegin()),
ReadSourceLocation(M, PPOffs.getEnd()));
PreprocessingRecord &PPRec = *PP.getPreprocessingRecord();
StringRef Blob;
RecordData Record;
Expected<unsigned> MaybeRecType =
M.PreprocessorDetailCursor.readRecord(Entry.ID, Record, &Blob);
if (!MaybeRecType) {
Error(MaybeRecType.takeError());
return nullptr;
}
switch ((PreprocessorDetailRecordTypes)MaybeRecType.get()) {
case PPD_MACRO_EXPANSION: {
bool isBuiltin = Record[0];
IdentifierInfo *Name = nullptr;
MacroDefinitionRecord *Def = nullptr;
if (isBuiltin)
Name = getLocalIdentifier(M, Record[1]);
else {
PreprocessedEntityID GlobalID =
getGlobalPreprocessedEntityID(M, Record[1]);
Def = cast<MacroDefinitionRecord>(
PPRec.getLoadedPreprocessedEntity(GlobalID - 1));
}
MacroExpansion *ME;
if (isBuiltin)
ME = new (PPRec) MacroExpansion(Name, Range);
else
ME = new (PPRec) MacroExpansion(Def, Range);
return ME;
}
case PPD_MACRO_DEFINITION: {
// Decode the identifier info and then check again; if the macro is
// still defined and associated with the identifier,
IdentifierInfo *II = getLocalIdentifier(M, Record[0]);
MacroDefinitionRecord *MD = new (PPRec) MacroDefinitionRecord(II, Range);
if (DeserializationListener)
DeserializationListener->MacroDefinitionRead(PPID, MD);
return MD;
}
case PPD_INCLUSION_DIRECTIVE: {
const char *FullFileNameStart = Blob.data() + Record[0];
StringRef FullFileName(FullFileNameStart, Blob.size() - Record[0]);
OptionalFileEntryRef File;
if (!FullFileName.empty())
File = PP.getFileManager().getOptionalFileRef(FullFileName);
// FIXME: Stable encoding
InclusionDirective::InclusionKind Kind
= static_cast<InclusionDirective::InclusionKind>(Record[2]);
InclusionDirective *ID
= new (PPRec) InclusionDirective(PPRec, Kind,
StringRef(Blob.data(), Record[0]),
Record[1], Record[3],
File,
Range);
return ID;
}
}
llvm_unreachable("Invalid PreprocessorDetailRecordTypes");
} | movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq -0x8(%rsp), %rdi
addq $-0x8, %rdi
movl -0xc(%rsp), %esi
jmp 0xe9d780
nopl (%rax,%rax)
| /Serialization/ASTReader.cpp |
clang::TypeLocReader::VisitObjCTypeParamTypeLoc(clang::ObjCTypeParamTypeLoc) | void TypeLocReader::VisitObjCTypeParamTypeLoc(ObjCTypeParamTypeLoc TL) {
if (TL.getNumProtocols()) {
TL.setProtocolLAngleLoc(readSourceLocation());
TL.setProtocolRAngleLoc(readSourceLocation());
}
for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
TL.setProtocolLoc(i, readSourceLocation());
} | subq $0x48, %rsp
movq %rsi, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xd23b10
cmpl $0x0, %eax
je 0xea3314
movq 0x10(%rsp), %rdi
callq 0xea0650
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %esi
leaq 0x38(%rsp), %rdi
callq 0xea3370
movq 0x10(%rsp), %rdi
callq 0xea0650
movl %eax, 0x28(%rsp)
movl 0x28(%rsp), %esi
leaq 0x38(%rsp), %rdi
callq 0xea33a0
movl $0x0, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xd23b10
movl %eax, 0x20(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x20(%rsp), %eax
je 0xea3369
movq 0x10(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0xea0650
movl 0xc(%rsp), %esi
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %edx
leaq 0x38(%rsp), %rdi
callq 0xea33d0
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0xea332a
addq $0x48, %rsp
retq
nop
| /Serialization/ASTReader.cpp |
clang::TypeLocReader::VisitObjCObjectTypeLoc(clang::ObjCObjectTypeLoc) | void TypeLocReader::VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
TL.setHasBaseTypeAsWritten(Reader.readBool());
TL.setTypeArgsLAngleLoc(readSourceLocation());
TL.setTypeArgsRAngleLoc(readSourceLocation());
for (unsigned i = 0, e = TL.getNumTypeArgs(); i != e; ++i)
TL.setTypeArgTInfo(i, GetTypeSourceInfo());
TL.setProtocolLAngleLoc(readSourceLocation());
TL.setProtocolRAngleLoc(readSourceLocation());
for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i)
TL.setProtocolLoc(i, readSourceLocation());
} | subq $0x58, %rsp
movq %rsi, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq (%rax), %rdi
callq 0xea0d40
movzbl %al, %esi
andl $0x1, %esi
leaq 0x48(%rsp), %rdi
callq 0xea3550
movq 0x10(%rsp), %rdi
callq 0xea0650
movl %eax, 0x3c(%rsp)
movl 0x3c(%rsp), %esi
leaq 0x48(%rsp), %rdi
callq 0xea3590
movq 0x10(%rsp), %rdi
callq 0xea0650
movl %eax, 0x38(%rsp)
movl 0x38(%rsp), %esi
leaq 0x48(%rsp), %rdi
callq 0xea35c0
movl $0x0, 0x34(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xd23570
movl %eax, 0x30(%rsp)
movl 0x34(%rsp), %eax
cmpl 0x30(%rsp), %eax
je 0xea34bd
movq 0x10(%rsp), %rdi
movl 0x34(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0xea0c30
movl 0xc(%rsp), %esi
movq %rax, %rdx
leaq 0x48(%rsp), %rdi
callq 0xea35f0
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0xea3483
movq 0x10(%rsp), %rdi
callq 0xea0650
movl %eax, 0x2c(%rsp)
movl 0x2c(%rsp), %esi
leaq 0x48(%rsp), %rdi
callq 0xea3630
movq 0x10(%rsp), %rdi
callq 0xea0650
movl %eax, 0x28(%rsp)
movl 0x28(%rsp), %esi
leaq 0x48(%rsp), %rdi
callq 0xea3660
movl $0x0, 0x24(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xd235e0
movl %eax, 0x20(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x20(%rsp), %eax
je 0xea354a
movq 0x10(%rsp), %rdi
movl 0x24(%rsp), %eax
movl %eax, 0x8(%rsp)
callq 0xea0650
movl 0x8(%rsp), %esi
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %edx
leaq 0x48(%rsp), %rdi
callq 0xea3690
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0xea350b
addq $0x58, %rsp
retq
nop
| /Serialization/ASTReader.cpp |
clang::ASTReader::PrintStats() | void ASTReader::PrintStats() {
std::fprintf(stderr, "*** AST File Statistics:\n");
unsigned NumTypesLoaded =
TypesLoaded.size() - llvm::count(TypesLoaded.materialized(), QualType());
unsigned NumDeclsLoaded =
DeclsLoaded.size() -
llvm::count(DeclsLoaded.materialized(), (Decl *)nullptr);
unsigned NumIdentifiersLoaded =
IdentifiersLoaded.size() -
llvm::count(IdentifiersLoaded, (IdentifierInfo *)nullptr);
unsigned NumMacrosLoaded =
MacrosLoaded.size() - llvm::count(MacrosLoaded, (MacroInfo *)nullptr);
unsigned NumSelectorsLoaded =
SelectorsLoaded.size() - llvm::count(SelectorsLoaded, Selector());
if (unsigned TotalNumSLocEntries = getTotalNumSLocs())
std::fprintf(stderr, " %u/%u source location entries read (%f%%)\n",
NumSLocEntriesRead, TotalNumSLocEntries,
((float)NumSLocEntriesRead/TotalNumSLocEntries * 100));
if (!TypesLoaded.empty())
std::fprintf(stderr, " %u/%u types read (%f%%)\n",
NumTypesLoaded, (unsigned)TypesLoaded.size(),
((float)NumTypesLoaded/TypesLoaded.size() * 100));
if (!DeclsLoaded.empty())
std::fprintf(stderr, " %u/%u declarations read (%f%%)\n",
NumDeclsLoaded, (unsigned)DeclsLoaded.size(),
((float)NumDeclsLoaded/DeclsLoaded.size() * 100));
if (!IdentifiersLoaded.empty())
std::fprintf(stderr, " %u/%u identifiers read (%f%%)\n",
NumIdentifiersLoaded, (unsigned)IdentifiersLoaded.size(),
((float)NumIdentifiersLoaded/IdentifiersLoaded.size() * 100));
if (!MacrosLoaded.empty())
std::fprintf(stderr, " %u/%u macros read (%f%%)\n",
NumMacrosLoaded, (unsigned)MacrosLoaded.size(),
((float)NumMacrosLoaded/MacrosLoaded.size() * 100));
if (!SelectorsLoaded.empty())
std::fprintf(stderr, " %u/%u selectors read (%f%%)\n",
NumSelectorsLoaded, (unsigned)SelectorsLoaded.size(),
((float)NumSelectorsLoaded/SelectorsLoaded.size() * 100));
if (TotalNumStatements)
std::fprintf(stderr, " %u/%u statements read (%f%%)\n",
NumStatementsRead, TotalNumStatements,
((float)NumStatementsRead/TotalNumStatements * 100));
if (TotalNumMacros)
std::fprintf(stderr, " %u/%u macros read (%f%%)\n",
NumMacrosRead, TotalNumMacros,
((float)NumMacrosRead/TotalNumMacros * 100));
if (TotalLexicalDeclContexts)
std::fprintf(stderr, " %u/%u lexical declcontexts read (%f%%)\n",
NumLexicalDeclContextsRead, TotalLexicalDeclContexts,
((float)NumLexicalDeclContextsRead/TotalLexicalDeclContexts
* 100));
if (TotalVisibleDeclContexts)
std::fprintf(stderr, " %u/%u visible declcontexts read (%f%%)\n",
NumVisibleDeclContextsRead, TotalVisibleDeclContexts,
((float)NumVisibleDeclContextsRead/TotalVisibleDeclContexts
* 100));
if (TotalNumMethodPoolEntries)
std::fprintf(stderr, " %u/%u method pool entries read (%f%%)\n",
NumMethodPoolEntriesRead, TotalNumMethodPoolEntries,
((float)NumMethodPoolEntriesRead/TotalNumMethodPoolEntries
* 100));
if (NumMethodPoolLookups)
std::fprintf(stderr, " %u/%u method pool lookups succeeded (%f%%)\n",
NumMethodPoolHits, NumMethodPoolLookups,
((float)NumMethodPoolHits/NumMethodPoolLookups * 100.0));
if (NumMethodPoolTableLookups)
std::fprintf(stderr, " %u/%u method pool table lookups succeeded (%f%%)\n",
NumMethodPoolTableHits, NumMethodPoolTableLookups,
((float)NumMethodPoolTableHits/NumMethodPoolTableLookups
* 100.0));
if (NumIdentifierLookupHits)
std::fprintf(stderr,
" %u / %u identifier table lookups succeeded (%f%%)\n",
NumIdentifierLookupHits, NumIdentifierLookups,
(double)NumIdentifierLookupHits*100.0/NumIdentifierLookups);
if (GlobalIndex) {
std::fprintf(stderr, "\n");
GlobalIndex->printStats();
}
std::fprintf(stderr, "\n");
dump();
std::fprintf(stderr, "\n");
} | subq $0x1a8, %rsp # imm = 0x1A8
movq %rdi, 0x1a0(%rsp)
movq 0x1a0(%rsp), %rax
movq %rax, 0xf8(%rsp)
movq 0xb1b4972(%rip), %rax # 0xc05def8
movq (%rax), %rdi
leaq 0x7061c5d(%rip), %rsi # 0x7f0b1ed
movb $0x0, %al
callq 0x73a2c0
movq 0xf8(%rsp), %rdi
addq $0xa78, %rdi # imm = 0xA78
callq 0xe8b2f0
movq 0xf8(%rsp), %rsi
movq %rax, 0xd0(%rsp)
addq $0xa78, %rsi # imm = 0xA78
leaq 0x178(%rsp), %rdi
callq 0xeaa0f0
leaq 0x170(%rsp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x73aa90
leaq 0x170(%rsp), %rdi
callq 0xd1e2c0
leaq 0x178(%rsp), %rdi
leaq 0x170(%rsp), %rsi
callq 0xeaa090
movq 0xf8(%rsp), %rdi
movq %rax, %rcx
movq 0xd0(%rsp), %rax
subq %rcx, %rax
movl %eax, 0x19c(%rsp)
addq $0xa98, %rdi # imm = 0xA98
callq 0xe8b430
movq 0xf8(%rsp), %rsi
movq %rax, 0xd8(%rsp)
addq $0xa98, %rsi # imm = 0xA98
leaq 0x148(%rsp), %rdi
callq 0xeaa1c0
movq $0x0, 0x140(%rsp)
leaq 0x148(%rsp), %rdi
leaq 0x140(%rsp), %rsi
callq 0xeaa160
movq 0xf8(%rsp), %rdi
movq %rax, %rcx
movq 0xd8(%rsp), %rax
subq %rcx, %rax
movl %eax, 0x16c(%rsp)
addq $0xfc8, %rdi # imm = 0xFC8
callq 0xe8b970
movq 0xf8(%rsp), %rdi
movq %rax, 0xe0(%rsp)
addq $0xfc8, %rdi # imm = 0xFC8
movq $0x0, 0x130(%rsp)
leaq 0x130(%rsp), %rsi
callq 0xeaa230
movq 0xf8(%rsp), %rdi
movq %rax, %rcx
movq 0xe0(%rsp), %rax
subq %rcx, %rax
movl %eax, 0x13c(%rsp)
addq $0xfe0, %rdi # imm = 0xFE0
callq 0xe35f70
movq 0xf8(%rsp), %rdi
movq %rax, 0xe8(%rsp)
addq $0xfe0, %rdi # imm = 0xFE0
movq $0x0, 0x120(%rsp)
leaq 0x120(%rsp), %rsi
callq 0xeaa280
movq 0xf8(%rsp), %rdi
movq %rax, %rcx
movq 0xe8(%rsp), %rax
subq %rcx, %rax
movl %eax, 0x12c(%rsp)
addq $0x1158, %rdi # imm = 0x1158
callq 0x87dfe0
movq %rax, %rcx
movq 0xf8(%rsp), %rax
movq %rcx, 0x100(%rsp)
addq $0x1158, %rax # imm = 0x1158
movq %rax, 0xf0(%rsp)
leaq 0x110(%rsp), %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x73aa90
leaq 0x110(%rsp), %rdi
callq 0xeaa310
movq 0xf0(%rsp), %rdi
leaq 0x110(%rsp), %rsi
callq 0xeaa2d0
movq 0xf8(%rsp), %rdi
movq %rax, %rcx
movq 0x100(%rsp), %rax
subq %rcx, %rax
movl %eax, 0x11c(%rsp)
callq 0xe70900
movl %eax, 0x10c(%rsp)
cmpl $0x0, 0x10c(%rsp)
je 0xea9829
movq 0xf8(%rsp), %rax
movq 0xb1b4711(%rip), %rcx # 0xc05def8
movq (%rcx), %rdi
movl 0x2300(%rax), %eax
movl %eax, %esi
movl %esi, %edx
movl 0x10c(%rsp), %eax
movl %eax, %ecx
cvtsi2ss %rsi, %xmm0
cvtsi2ss %rax, %xmm1
divss %xmm1, %xmm0
movss 0x70585a9(%rip), %xmm1 # 0x7f01dbc
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x70619e5(%rip), %rsi # 0x7f0b207
movb $0x1, %al
callq 0x73a2c0
movq 0xf8(%rsp), %rdi
addq $0xa78, %rdi # imm = 0xA78
callq 0xeaa320
testb $0x1, %al
jne 0xea9939
movq 0xf8(%rsp), %rdi
movq 0xb1b46a4(%rip), %rax # 0xc05def8
movq (%rax), %rax
movq %rax, 0xa8(%rsp)
movl 0x19c(%rsp), %eax
movl %eax, 0xb4(%rsp)
addq $0xa78, %rdi # imm = 0xA78
movq %rdi, 0xb8(%rsp)
callq 0xe8b2f0
movq 0xb8(%rsp), %rdi
movl %eax, 0xc0(%rsp)
movl 0x19c(%rsp), %eax
cvtsi2ss %rax, %xmm0
movss %xmm0, 0xc4(%rsp)
callq 0xe8b2f0
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, 0xc8(%rsp)
testq %rax, %rax
movss %xmm0, 0xcc(%rsp)
js 0xea98ef
movss 0xc8(%rsp), %xmm0
movss %xmm0, 0xcc(%rsp)
movl 0xc0(%rsp), %ecx
movl 0xb4(%rsp), %edx
movq 0xa8(%rsp), %rdi
movss 0xc4(%rsp), %xmm0
movss 0xcc(%rsp), %xmm1
divss %xmm1, %xmm0
movss 0x7058499(%rip), %xmm1 # 0x7f01dbc
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x7061902(%rip), %rsi # 0x7f0b234
movb $0x1, %al
callq 0x73a2c0
movq 0xf8(%rsp), %rdi
addq $0xa98, %rdi # imm = 0xA98
callq 0xeaa340
testb $0x1, %al
jne 0xea9a49
movq 0xf8(%rsp), %rdi
movq 0xb1b4594(%rip), %rax # 0xc05def8
movq (%rax), %rax
movq %rax, 0x80(%rsp)
movl 0x16c(%rsp), %eax
movl %eax, 0x8c(%rsp)
addq $0xa98, %rdi # imm = 0xA98
movq %rdi, 0x90(%rsp)
callq 0xe8b430
movq 0x90(%rsp), %rdi
movl %eax, 0x98(%rsp)
movl 0x16c(%rsp), %eax
cvtsi2ss %rax, %xmm0
movss %xmm0, 0x9c(%rsp)
callq 0xe8b430
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, 0xa0(%rsp)
testq %rax, %rax
movss %xmm0, 0xa4(%rsp)
js 0xea99ff
movss 0xa0(%rsp), %xmm0
movss %xmm0, 0xa4(%rsp)
movl 0x98(%rsp), %ecx
movl 0x8c(%rsp), %edx
movq 0x80(%rsp), %rdi
movss 0x9c(%rsp), %xmm0
movss 0xa4(%rsp), %xmm1
divss %xmm1, %xmm0
movss 0x7058389(%rip), %xmm1 # 0x7f01dbc
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x706180d(%rip), %rsi # 0x7f0b24f
movb $0x1, %al
callq 0x73a2c0
movq 0xf8(%rsp), %rdi
addq $0xfc8, %rdi # imm = 0xFC8
callq 0xeaa360
testb $0x1, %al
jne 0xea9b2c
movq 0xf8(%rsp), %rdi
movq 0xb1b4484(%rip), %rax # 0xc05def8
movq (%rax), %rax
movq %rax, 0x58(%rsp)
movl 0x13c(%rsp), %eax
movl %eax, 0x64(%rsp)
addq $0xfc8, %rdi # imm = 0xFC8
movq %rdi, 0x68(%rsp)
callq 0xe8b970
movq 0x68(%rsp), %rdi
movl %eax, 0x70(%rsp)
movl 0x13c(%rsp), %eax
cvtsi2ss %rax, %xmm0
movss %xmm0, 0x74(%rsp)
callq 0xe8b970
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, 0x78(%rsp)
testq %rax, %rax
movss %xmm0, 0x7c(%rsp)
js 0xea9af1
movss 0x78(%rsp), %xmm0
movss %xmm0, 0x7c(%rsp)
movl 0x70(%rsp), %ecx
movl 0x64(%rsp), %edx
movq 0x58(%rsp), %rdi
movss 0x74(%rsp), %xmm0
movss 0x7c(%rsp), %xmm1
divss %xmm1, %xmm0
movss 0x70582a6(%rip), %xmm1 # 0x7f01dbc
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x706174c(%rip), %rsi # 0x7f0b271
movb $0x1, %al
callq 0x73a2c0
movq 0xf8(%rsp), %rdi
addq $0xfe0, %rdi # imm = 0xFE0
callq 0xe28ff0
testb $0x1, %al
jne 0xea9c0f
movq 0xf8(%rsp), %rdi
movq 0xb1b43a1(%rip), %rax # 0xc05def8
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movl 0x12c(%rsp), %eax
movl %eax, 0x3c(%rsp)
addq $0xfe0, %rdi # imm = 0xFE0
movq %rdi, 0x40(%rsp)
callq 0xe35f70
movq 0x40(%rsp), %rdi
movl %eax, 0x48(%rsp)
movl 0x12c(%rsp), %eax
cvtsi2ss %rax, %xmm0
movss %xmm0, 0x4c(%rsp)
callq 0xe35f70
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, 0x50(%rsp)
testq %rax, %rax
movss %xmm0, 0x54(%rsp)
js 0xea9bd4
movss 0x50(%rsp), %xmm0
movss %xmm0, 0x54(%rsp)
movl 0x48(%rsp), %ecx
movl 0x3c(%rsp), %edx
movq 0x30(%rsp), %rdi
movss 0x4c(%rsp), %xmm0
movss 0x54(%rsp), %xmm1
divss %xmm1, %xmm0
movss 0x70581c3(%rip), %xmm1 # 0x7f01dbc
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x706168a(%rip), %rsi # 0x7f0b292
movb $0x1, %al
callq 0x73a2c0
movq 0xf8(%rsp), %rdi
addq $0x1158, %rdi # imm = 0x1158
callq 0x87e020
testb $0x1, %al
jne 0xea9cf2
movq 0xf8(%rsp), %rdi
movq 0xb1b42be(%rip), %rax # 0xc05def8
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movl 0x11c(%rsp), %eax
movl %eax, 0x14(%rsp)
addq $0x1158, %rdi # imm = 0x1158
movq %rdi, 0x18(%rsp)
callq 0x87dfe0
movq 0x18(%rsp), %rdi
movl %eax, 0x20(%rsp)
movl 0x11c(%rsp), %eax
cvtsi2ss %rax, %xmm0
movss %xmm0, 0x24(%rsp)
callq 0x87dfe0
movq %rax, %rdx
shrq %rdx
movl %eax, %ecx
andl $0x1, %ecx
orq %rdx, %rcx
cvtsi2ss %rcx, %xmm0
addss %xmm0, %xmm0
cvtsi2ss %rax, %xmm1
movss %xmm1, 0x28(%rsp)
testq %rax, %rax
movss %xmm0, 0x2c(%rsp)
js 0xea9cb7
movss 0x28(%rsp), %xmm0
movss %xmm0, 0x2c(%rsp)
movl 0x20(%rsp), %ecx
movl 0x14(%rsp), %edx
movq 0x8(%rsp), %rdi
movss 0x24(%rsp), %xmm0
movss 0x2c(%rsp), %xmm1
divss %xmm1, %xmm0
movss 0x70580e0(%rip), %xmm1 # 0x7f01dbc
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x70615c3(%rip), %rsi # 0x7f0b2ae
movb $0x1, %al
callq 0x73a2c0
movq 0xf8(%rsp), %rax
cmpl $0x0, 0x230c(%rax)
je 0xea9d53
movq 0xf8(%rsp), %rax
movq 0xb1b41e6(%rip), %rcx # 0xc05def8
movq (%rcx), %rdi
movl 0x2308(%rax), %ecx
movl 0x230c(%rax), %eax
movl %ecx, %esi
movl %esi, %edx
movl %eax, %ecx
cvtsi2ss %rsi, %xmm0
cvtsi2ss %rax, %xmm1
divss %xmm1, %xmm0
movss 0x705807f(%rip), %xmm1 # 0x7f01dbc
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x7061581(%rip), %rsi # 0x7f0b2cd
movb $0x1, %al
callq 0x73a2c0
movq 0xf8(%rsp), %rax
cmpl $0x0, 0x2314(%rax)
je 0xea9db4
movq 0xf8(%rsp), %rax
movq 0xb1b4185(%rip), %rcx # 0xc05def8
movq (%rcx), %rdi
movl 0x2310(%rax), %ecx
movl 0x2314(%rax), %eax
movl %ecx, %esi
movl %esi, %edx
movl %eax, %ecx
cvtsi2ss %rsi, %xmm0
cvtsi2ss %rax, %xmm1
divss %xmm1, %xmm0
movss 0x705801e(%rip), %xmm1 # 0x7f01dbc
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x70614e5(%rip), %rsi # 0x7f0b292
movb $0x1, %al
callq 0x73a2c0
movq 0xf8(%rsp), %rax
cmpl $0x0, 0x2340(%rax)
je 0xea9e15
movq 0xf8(%rsp), %rax
movq 0xb1b4124(%rip), %rcx # 0xc05def8
movq (%rcx), %rdi
movl 0x233c(%rax), %ecx
movl 0x2340(%rax), %eax
movl %ecx, %esi
movl %esi, %edx
movl %eax, %ecx
cvtsi2ss %rsi, %xmm0
cvtsi2ss %rax, %xmm1
divss %xmm1, %xmm0
movss 0x7057fbd(%rip), %xmm1 # 0x7f01dbc
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x70614df(%rip), %rsi # 0x7f0b2ed
movb $0x1, %al
callq 0x73a2c0
movq 0xf8(%rsp), %rax
cmpl $0x0, 0x2348(%rax)
je 0xea9e76
movq 0xf8(%rsp), %rax
movq 0xb1b40c3(%rip), %rcx # 0xc05def8
movq (%rcx), %rdi
movl 0x2344(%rax), %ecx
movl 0x2348(%rax), %eax
movl %ecx, %esi
movl %esi, %edx
movl %eax, %ecx
cvtsi2ss %rsi, %xmm0
cvtsi2ss %rax, %xmm1
divss %xmm1, %xmm0
movss 0x7057f5c(%rip), %xmm1 # 0x7f01dbc
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x70614a8(%rip), %rsi # 0x7f0b317
movb $0x1, %al
callq 0x73a2c0
movq 0xf8(%rsp), %rax
cmpl $0x0, 0x2338(%rax)
je 0xea9ed7
movq 0xf8(%rsp), %rax
movq 0xb1b4062(%rip), %rcx # 0xc05def8
movq (%rcx), %rdi
movl 0x2324(%rax), %ecx
movl 0x2338(%rax), %eax
movl %ecx, %esi
movl %esi, %edx
movl %eax, %ecx
cvtsi2ss %rsi, %xmm0
cvtsi2ss %rax, %xmm1
divss %xmm1, %xmm0
movss 0x7057efb(%rip), %xmm1 # 0x7f01dbc
mulss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0x7061471(%rip), %rsi # 0x7f0b341
movb $0x1, %al
callq 0x73a2c0
movq 0xf8(%rsp), %rax
cmpl $0x0, 0x2328(%rax)
je 0xea9f38
movq 0xf8(%rsp), %rcx
movq 0xb1b4001(%rip), %rax # 0xc05def8
movq (%rax), %rdi
movl 0x2328(%rcx), %eax
movl 0x232c(%rcx), %ecx
movl %ecx, %esi
movl %esi, %edx
movl %eax, %ecx
cvtsi2ss %rsi, %xmm0
cvtsi2ss %rax, %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x6f6e26a(%rip), %xmm1 # 0x7e18190
mulsd %xmm1, %xmm0
leaq 0x7061439(%rip), %rsi # 0x7f0b36a
movb $0x1, %al
callq 0x73a2c0
movq 0xf8(%rsp), %rax
cmpl $0x0, 0x2330(%rax)
je 0xea9f99
movq 0xf8(%rsp), %rcx
movq 0xb1b3fa0(%rip), %rax # 0xc05def8
movq (%rax), %rdi
movl 0x2330(%rcx), %eax
movl 0x2334(%rcx), %ecx
movl %ecx, %esi
movl %esi, %edx
movl %eax, %ecx
cvtsi2ss %rsi, %xmm0
cvtsi2ss %rax, %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
movsd 0x6f6e209(%rip), %xmm1 # 0x7e18190
mulsd %xmm1, %xmm0
leaq 0x7061406(%rip), %rsi # 0x7f0b398
movb $0x1, %al
callq 0x73a2c0
movq 0xf8(%rsp), %rax
cmpl $0x0, 0x231c(%rax)
je 0xea9ff6
movq 0xf8(%rsp), %rcx
movq 0xb1b3f3f(%rip), %rax # 0xc05def8
movq (%rax), %rdi
movl 0x2318(%rcx), %eax
movl 0x231c(%rcx), %ecx
movl %ecx, %esi
movl %esi, %edx
movl %eax, %ecx
cvtsi2sd %rsi, %xmm0
movsd 0x6f6e1b5(%rip), %xmm1 # 0x7e18190
mulsd %xmm1, %xmm0
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
leaq 0x70613dd(%rip), %rsi # 0x7f0b3cc
movb $0x1, %al
callq 0x73a2c0
movq 0xf8(%rsp), %rdi
addq $0x200, %rdi # imm = 0x200
callq 0xe8dcd0
testb $0x1, %al
jne 0xeaa010
jmp 0xeaa044
movq 0xb1b3ee1(%rip), %rax # 0xc05def8
movq (%rax), %rdi
leaq 0x70573eb(%rip), %rsi # 0x7f0140c
movb $0x0, %al
callq 0x73a2c0
movq 0xf8(%rsp), %rdi
addq $0x200, %rdi # imm = 0x200
callq 0xe756f0
movq %rax, %rdi
callq 0x10b7100
movq 0xb1b3ead(%rip), %rax # 0xc05def8
movq (%rax), %rdi
leaq 0x70573b7(%rip), %rsi # 0x7f0140c
movb $0x0, %al
callq 0x73a2c0
movq 0xf8(%rsp), %rdi
callq 0xeaa3b0
movq 0xb1b3e88(%rip), %rax # 0xc05def8
movq (%rax), %rdi
leaq 0x7057392(%rip), %rsi # 0x7f0140c
movb $0x0, %al
callq 0x73a2c0
addq $0x1a8, %rsp # imm = 0x1A8
retq
nopl (%rax)
| /Serialization/ASTReader.cpp |
llvm::DenseMapIterator<clang::DeclContext const*, clang::serialization::reader::DeclContextLookupTable, llvm::DenseMapInfo<clang::DeclContext const*, void>, llvm::detail::DenseMapPair<clang::DeclContext const*, clang::serialization::reader::DeclContextLookupTable>, false>::RetreatPastEmptyBuckets() | void RetreatPastEmptyBuckets() {
assert(Ptr >= End);
const KeyT Empty = KeyInfoT::getEmptyKey();
const KeyT Tombstone = KeyInfoT::getTombstoneKey();
while (Ptr != End && (KeyInfoT::isEqual(Ptr[-1].getFirst(), Empty) ||
KeyInfoT::isEqual(Ptr[-1].getFirst(), Tombstone)))
--Ptr;
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0xbdf2c0
movq %rax, 0x18(%rsp)
callq 0xd51e00
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdx
movq (%rdx), %rcx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, 0x7(%rsp)
je 0xf16090
movq 0x8(%rsp), %rax
movq (%rax), %rdi
addq $-0x18, %rdi
callq 0xf16170
movq (%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0xd51dd0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x6(%rsp)
jne 0xf16088
movq 0x8(%rsp), %rax
movq (%rax), %rdi
addq $-0x18, %rdi
callq 0xf16170
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0xd51dd0
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0xf1609a
jmp 0xf160ae
movq 0x8(%rsp), %rax
movq (%rax), %rcx
addq $-0x18, %rcx
movq %rcx, (%rax)
jmp 0xf16027
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /llvm/ADT/DenseMap.h |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.