name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
clang::interp::Record::Record(clang::RecordDecl const*, llvm::SmallVector<clang::interp::Record::Base, 8u>&&, llvm::SmallVector<clang::interp::Record::Field, 8u>&&, llvm::SmallVector<clang::interp::Record::Base, 2u>&&, unsigned int, unsigned int)
|
Record::Record(const RecordDecl *Decl, BaseList &&SrcBases,
FieldList &&SrcFields, VirtualBaseList &&SrcVirtualBases,
unsigned VirtualSize, unsigned BaseSize)
: Decl(Decl), Bases(std::move(SrcBases)), Fields(std::move(SrcFields)),
BaseSize(BaseSize), VirtualSize(VirtualSize), IsUnion(Decl->isUnion()) {
for (Base &V : SrcVirtualBases)
VirtualBases.push_back({ V.Decl, V.Offset + BaseSize, V.Desc, V.R });
for (Base &B : Bases)
BaseMap[B.Decl] = &B;
for (Field &F : Fields)
FieldMap[F.Decl] = &F;
for (Base &V : VirtualBases)
VirtualBaseMap[V.Decl] = &V;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r9d, (%rsp)
movq %r8, 0x8(%rsp)
movq %rcx, %r14
movq %rsi, %rbp
movq %rdi, %rbx
movq %rsi, (%rdi)
addq $0x8, %rdi
movq %rdx, %rsi
callq 0xf19906
leaq 0x118(%rbx), %rdi
movq %r14, %rsi
callq 0xf19926
leaq 0x1e8(%rbx), %r13
leaq 0x1f8(%rbx), %rax
movq %rax, 0x1e8(%rbx)
movabsq $0x200000000, %rax # imm = 0x200000000
movq %rax, 0x1f0(%rbx)
leaq 0x238(%rbx), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0xf19ca4
leaq 0x250(%rbx), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0xf19d46
leaq 0x268(%rbx), %rdi
movq %rdi, 0x10(%rsp)
xorl %esi, %esi
callq 0xf19de8
movl 0x70(%rsp), %eax
movl %eax, 0x280(%rbx)
movl (%rsp), %eax
movl %eax, 0x284(%rbx)
movzwl 0x48(%rbp), %eax
andl $0xe000, %eax # imm = 0xE000
cmpw $0x4000, %ax # imm = 0x4000
movq %rbx, (%rsp)
sete 0x288(%rbx)
movq 0x8(%rsp), %rax
movq (%rax), %rbx
movl 0x8(%rax), %r14d
shlq $0x5, %r14
leaq 0x18(%rsp), %rbp
testq %r14, %r14
je 0xf19863
movq (%rbx), %rax
movq %rax, 0x18(%rsp)
movl 0x8(%rbx), %eax
addl 0x70(%rsp), %eax
movl %eax, 0x20(%rsp)
movups 0x10(%rbx), %xmm0
movups %xmm0, 0x28(%rsp)
movq %r13, %rdi
movq %rbp, %rsi
callq 0xf18986
addq $0x20, %rbx
addq $-0x20, %r14
jmp 0xf1982d
movq (%rsp), %r14
movq 0x8(%r14), %r13
movl 0x10(%r14), %ebx
shlq $0x5, %rbx
testq %rbx, %rbx
je 0xf19891
movq %r12, %rdi
movq %r13, %rsi
callq 0xf19e8a
movq %r13, 0x8(%rax)
addq $0x20, %r13
addq $-0x20, %rbx
jmp 0xf19873
movq 0x118(%r14), %r12
movl 0x120(%r14), %eax
imulq $0x18, %rax, %rbx
testq %rbx, %rbx
je 0xf198c1
movq %r15, %rdi
movq %r12, %rsi
callq 0xf1a0ba
movq %r12, 0x8(%rax)
addq $0x18, %r12
addq $-0x18, %rbx
jmp 0xf198a3
movq 0x1e8(%r14), %r15
movl 0x1f0(%r14), %ebx
shlq $0x5, %rbx
movq 0x10(%rsp), %r14
testq %rbx, %rbx
je 0xf198f6
movq %r14, %rdi
movq %r15, %rsi
callq 0xf1a2ea
movq %r15, 0x8(%rax)
addq $0x20, %r15
addq $-0x20, %rbx
jmp 0xf198d8
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/AST/Interp/Record.cpp
|
bool llvm::DenseMapBase<llvm::DenseMap<clang::RecordDecl const*, clang::interp::Record::Base const*, llvm::DenseMapInfo<clang::RecordDecl const*, void>, llvm::detail::DenseMapPair<clang::RecordDecl const*, clang::interp::Record::Base const*>>, clang::RecordDecl const*, clang::interp::Record::Base const*, llvm::DenseMapInfo<clang::RecordDecl const*, void>, llvm::detail::DenseMapPair<clang::RecordDecl const*, clang::interp::Record::Base const*>>::LookupBucketFor<clang::RecordDecl const*>(clang::RecordDecl const* const&, llvm::detail::DenseMapPair<clang::RecordDecl const*, clang::interp::Record::Base const*> const*&) const
|
unsigned getNumBuckets() const {
return NumBuckets;
}
|
movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0xf19f64
pushq %rbx
movq (%rdi), %rdi
movq (%rsi), %rsi
movl %esi, %eax
shrl $0x4, %eax
movl %esi, %r8d
shrl $0x9, %r8d
xorl %eax, %r8d
decl %ecx
movl $0x1, %r10d
xorl %r9d, %r9d
andl %ecx, %r8d
movq %r8, %rax
shlq $0x4, %rax
leaq (%rdi,%rax), %r11
movq (%rdi,%rax), %rbx
movb $0x1, %al
cmpq %rbx, %rsi
je 0xf19f74
cmpq $-0x1000, %rbx # imm = 0xF000
je 0xf19f6b
xorq $-0x2000, %rbx # imm = 0xE000
orq %r9, %rbx
cmoveq %r11, %r9
addl %r10d, %r8d
incl %r10d
jmp 0xf19f2c
xorl %r11d, %r11d
xorl %eax, %eax
jmp 0xf19f75
testq %r9, %r9
cmovneq %r9, %r11
xorl %eax, %eax
popq %rbx
movq %r11, (%rdx)
retq
nop
|
/llvm/ADT/DenseMap.h
|
llvm::DenseMapBase<llvm::DenseMap<clang::BlockDecl const*, unsigned int, llvm::DenseMapInfo<clang::BlockDecl const*, void>, llvm::detail::DenseMapPair<clang::BlockDecl const*, unsigned int>>, clang::BlockDecl const*, unsigned int, llvm::DenseMapInfo<clang::BlockDecl const*, void>, llvm::detail::DenseMapPair<clang::BlockDecl const*, unsigned int>>::clear()
|
unsigned getNumEntries() const {
return NumEntries;
}
|
movl 0x8(%rdi), %ecx
testl %ecx, %ecx
jne 0xf1cb43
cmpl $0x0, 0xc(%rdi)
je 0xf1cb7d
shll $0x2, %ecx
movl 0x10(%rdi), %eax
cmpl %eax, %ecx
setae %cl
cmpl $0x41, %eax
setb %dl
orb %cl, %dl
je 0xf1cb7e
movq (%rdi), %rcx
shlq $0x4, %rax
xorl %edx, %edx
cmpq %rdx, %rax
je 0xf1cb78
movq $-0x1000, (%rcx,%rdx) # imm = 0xF000
addq $0x10, %rdx
jmp 0xf1cb65
andq $0x0, 0x8(%rdi)
retq
|
/llvm/ADT/DenseMap.h
|
bool llvm::DenseMapBase<llvm::DenseMap<std::pair<clang::DeclContext const*, clang::IdentifierInfo*>, unsigned int, llvm::DenseMapInfo<std::pair<clang::DeclContext const*, clang::IdentifierInfo*>, void>, llvm::detail::DenseMapPair<std::pair<clang::DeclContext const*, clang::IdentifierInfo*>, unsigned int>>, std::pair<clang::DeclContext const*, clang::IdentifierInfo*>, unsigned int, llvm::DenseMapInfo<std::pair<clang::DeclContext const*, clang::IdentifierInfo*>, void>, llvm::detail::DenseMapPair<std::pair<clang::DeclContext const*, clang::IdentifierInfo*>, unsigned int>>::LookupBucketFor<std::pair<clang::DeclContext const*, clang::IdentifierInfo*>>(std::pair<clang::DeclContext const*, clang::IdentifierInfo*> const&, llvm::detail::DenseMapPair<std::pair<clang::DeclContext const*, clang::IdentifierInfo*>, unsigned int> const*&) const
|
bool LookupBucketFor(const LookupKeyT &Val,
const BucketT *&FoundBucket) const {
const BucketT *BucketsPtr = getBuckets();
const unsigned NumBuckets = getNumBuckets();
if (NumBuckets == 0) {
FoundBucket = nullptr;
return false;
}
// FoundTombstone - Keep track of whether we find a tombstone while probing.
const BucketT *FoundTombstone = nullptr;
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
assert(!KeyInfoT::isEqual(Val, EmptyKey) &&
!KeyInfoT::isEqual(Val, TombstoneKey) &&
"Empty/Tombstone value shouldn't be inserted into map!");
unsigned BucketNo = getHashValue(Val) & (NumBuckets-1);
unsigned ProbeAmt = 1;
while (true) {
const BucketT *ThisBucket = BucketsPtr + BucketNo;
// Found Val's bucket? If so, return it.
if (LLVM_LIKELY(KeyInfoT::isEqual(Val, ThisBucket->getFirst()))) {
FoundBucket = ThisBucket;
return true;
}
// If we found an empty bucket, the key doesn't exist in the set.
// Insert it and return the default value.
if (LLVM_LIKELY(KeyInfoT::isEqual(ThisBucket->getFirst(), EmptyKey))) {
// If we've already seen a tombstone while probing, fill it in instead
// of the empty bucket we eventually probed to.
FoundBucket = FoundTombstone ? FoundTombstone : ThisBucket;
return false;
}
// If this is a tombstone, remember it. If Val ends up not in the map, we
// prefer to return it than something that would require more probing.
if (KeyInfoT::isEqual(ThisBucket->getFirst(), TombstoneKey) &&
!FoundTombstone)
FoundTombstone = ThisBucket; // Remember the first tombstone found.
// Otherwise, it's a hash collision or a tombstone, continue quadratic
// probing.
BucketNo += ProbeAmt++;
BucketNo &= (NumBuckets-1);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl 0x10(%rdi), %ebp
testl %ebp, %ebp
je 0xf29624
movq %rsi, %r14
movq (%rdi), %r15
movq %rsi, %rdi
callq 0xf29642
decl %ebp
movq (%r14), %rsi
movq 0x8(%r14), %rdi
pushq $0x1
popq %r8
xorl %edx, %edx
movq $-0x2000, %r10 # imm = 0xE000
andl %ebp, %eax
imulq $0x18, %rax, %rcx
leaq (%r15,%rcx), %r9
movq (%r15,%rcx), %r14
movq 0x8(%r15,%rcx), %r11
cmpq %r14, %rsi
jne 0xf295fa
movb $0x1, %cl
cmpq %r11, %rdi
je 0xf29629
cmpq $-0x1000, %r14 # imm = 0xF000
jne 0xf2960c
cmpq $-0x1000, %r11 # imm = 0xF000
je 0xf29639
xorq %r10, %r14
xorq %r10, %r11
orq %r14, %r11
orq %rdx, %r11
cmoveq %r9, %rdx
addl %r8d, %eax
incl %r8d
jmp 0xf295db
xorl %r9d, %r9d
xorl %ecx, %ecx
movq %r9, (%rbx)
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
testq %rdx, %rdx
cmovneq %rdx, %r9
jmp 0xf29627
|
/llvm/ADT/DenseMap.h
|
clang::JSONNodeDumper::writeBareSourceLocation(clang::SourceLocation, bool)
|
void JSONNodeDumper::writeBareSourceLocation(SourceLocation Loc,
bool IsSpelling) {
PresumedLoc Presumed = SM.getPresumedLoc(Loc);
unsigned ActualLine = IsSpelling ? SM.getSpellingLineNumber(Loc)
: SM.getExpansionLineNumber(Loc);
StringRef ActualFile = SM.getBufferName(Loc);
if (Presumed.isValid()) {
JOS.attribute("offset", SM.getDecomposedLoc(Loc).second);
if (LastLocFilename != ActualFile) {
JOS.attribute("file", ActualFile);
JOS.attribute("line", ActualLine);
} else if (LastLocLine != ActualLine)
JOS.attribute("line", ActualLine);
StringRef PresumedFile = Presumed.getFilename();
if (PresumedFile != ActualFile && LastLocPresumedFilename != PresumedFile)
JOS.attribute("presumedFile", PresumedFile);
unsigned PresumedLine = Presumed.getLine();
if (ActualLine != PresumedLine && LastLocPresumedLine != PresumedLine)
JOS.attribute("presumedLine", PresumedLine);
JOS.attribute("col", Presumed.getColumn());
JOS.attribute("tokLen",
Lexer::MeasureTokenLength(Loc, SM, Ctx.getLangOpts()));
LastLocFilename = ActualFile;
LastLocPresumedFilename = PresumedFile;
LastLocPresumedLine = PresumedLine;
LastLocLine = ActualLine;
// Orthogonal to the file, line, and column de-duplication is whether the
// given location was a result of an include. If so, print where the
// include location came from.
writeIncludeStack(SM.getPresumedLoc(Presumed.getIncludeLoc()),
/*JustFirst*/ true);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
movq 0x4c8(%rdi), %rsi
leaq 0x40(%rsp), %rdi
pushq $0x1
popq %rcx
movl %ebp, %edx
callq 0x107fb50
movq 0x4c8(%rbx), %rdi
movl %ebp, %esi
xorl %edx, %edx
testl %r14d, %r14d
je 0xf2c1b2
callq 0x10800ba
jmp 0xf2c1b7
callq 0x10800ec
movl %eax, %r14d
movq 0x4c8(%rbx), %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x10801b6
cmpq $0x0, 0x40(%rsp)
je 0xf2c489
movq %rax, %r15
movl %r14d, 0x1c(%rsp)
leaq 0x418(%rbx), %r13
movq 0x4c8(%rbx), %rdi
movl %ebp, %esi
movq %rdx, %r12
callq 0x4ed426
shrq $0x20, %rax
leaq 0x58(%rsp), %r14
movw $0x3, (%r14)
movq %rax, 0x8(%r14)
leaq 0x519160(%rip), %rsi # 0x1445370
pushq $0x6
popq %rdx
movq %r13, %rdi
movq %r14, %rcx
callq 0x4bf8d8
movq %r14, %rdi
callq 0x117a148
movq 0x4f8(%rbx), %rdi
movq 0x500(%rbx), %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x476ce5
testb %al, %al
movq %r12, 0x20(%rsp)
je 0xf2c29e
leaq 0x58(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x54260e
leaq 0x2a3282(%rip), %rsi # 0x11cf4e4
pushq $0x4
popq %rdx
movq %r13, %rdi
movq %r14, %rcx
callq 0x4bf8d8
movq %r14, %rdi
callq 0x117a148
movw $0x3, (%r14)
movl 0x1c(%rsp), %r12d
movl %r12d, %eax
movq %rax, 0x8(%r14)
leaq 0x288450(%rip), %rsi # 0x11b46e1
leaq 0x58(%rsp), %r14
movq %r13, %rdi
pushq $0x4
popq %rdx
jmp 0xf2c2cb
movl 0x1c(%rsp), %r12d
cmpl %r12d, 0x518(%rbx)
je 0xf2c2db
leaq 0x58(%rsp), %r14
movw $0x3, (%r14)
movl %r12d, %eax
movq %rax, 0x8(%r14)
leaq 0x28841c(%rip), %rsi # 0x11b46e1
pushq $0x4
popq %rdx
movq %r13, %rdi
movq %r14, %rcx
callq 0x4bf8d8
movq %r14, %rdi
callq 0x117a148
movq 0x40(%rsp), %rsi
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x4502cc
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %r15, 0x38(%rsp)
movq %r15, %rdx
movq 0x20(%rsp), %rcx
callq 0x476ce5
testb %al, %al
je 0xf2c35f
movq 0x508(%rbx), %rdi
movq 0x510(%rbx), %rsi
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rcx
callq 0x476ce5
testb %al, %al
je 0xf2c35f
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
leaq 0x58(%rsp), %r14
movq %r14, %rdi
callq 0x54260e
leaq 0x353082(%rip), %rsi # 0x127f3cb
pushq $0xc
popq %rdx
movq %r13, %rdi
movq %r14, %rcx
callq 0x4bf8d8
movq %r14, %rdi
callq 0x117a148
movl 0x4c(%rsp), %r15d
cmpl %r15d, %r12d
je 0xf2c39e
cmpl %r15d, 0x51c(%rbx)
je 0xf2c39e
leaq 0x58(%rsp), %r14
movw $0x3, (%r14)
movq %r15, 0x8(%r14)
leaq 0x353050(%rip), %rsi # 0x127f3d8
pushq $0xc
popq %rdx
movq %r13, %rdi
movq %r14, %rcx
callq 0x4bf8d8
movq %r14, %rdi
callq 0x117a148
movl 0x50(%rsp), %eax
movw $0x3, %r12w
leaq 0x58(%rsp), %r14
movw %r12w, (%r14)
movq %rax, 0x8(%r14)
leaq 0x344e61(%rip), %rsi # 0x127121c
pushq $0x3
popq %rdx
movq %r13, %rdi
movq %r14, %rcx
callq 0x4bf8d8
movq %r14, %rdi
callq 0x117a148
movq 0x4c8(%rbx), %rsi
movq 0x4d0(%rbx), %rax
movq 0x830(%rax), %rdx
movl %ebp, %edi
callq 0xfff7f2
movw %r12w, (%r14)
movl %eax, %eax
movq %rax, 0x8(%r14)
leaq 0x352fe7(%rip), %rsi # 0x127f3e5
pushq $0x6
popq %rdx
leaq 0x58(%rsp), %r14
movq %r13, %rdi
movq %r14, %rcx
callq 0x4bf8d8
movq %r14, %rdi
callq 0x117a148
movq 0x38(%rsp), %rax
movq %rax, 0x4f8(%rbx)
movq 0x20(%rsp), %rax
movq %rax, 0x500(%rbx)
movups 0x28(%rsp), %xmm0
movups %xmm0, 0x508(%rbx)
movl %r15d, 0x51c(%rbx)
movl 0x1c(%rsp), %eax
movl %eax, 0x518(%rbx)
movq 0x4c8(%rbx), %rsi
movl 0x54(%rsp), %edx
leaq 0x80(%rsp), %r14
pushq $0x1
popq %rbp
movq %r14, %rdi
movl %ebp, %ecx
callq 0x107fb50
movq 0x10(%r14), %rax
movq %rax, 0x10(%rsp)
movups (%r14), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
movl %ebp, %esi
callq 0xf2c09a
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/AST/JSONNodeDumper.cpp
|
clang::JSONNodeDumper::createCXXRecordDefinitionData(clang::CXXRecordDecl const*)
|
llvm::json::Object
JSONNodeDumper::createCXXRecordDefinitionData(const CXXRecordDecl *RD) {
llvm::json::Object Ret;
// This data is common to all C++ classes.
FIELD1(isGenericLambda);
FIELD1(isLambda);
FIELD1(isEmpty);
FIELD1(isAggregate);
FIELD1(isStandardLayout);
FIELD1(isTriviallyCopyable);
FIELD1(isPOD);
FIELD1(isTrivial);
FIELD1(isPolymorphic);
FIELD1(isAbstract);
FIELD1(isLiteral);
FIELD1(canPassInRegisters);
FIELD1(hasUserDeclaredConstructor);
FIELD1(hasConstexprNonCopyMoveConstructor);
FIELD1(hasMutableFields);
FIELD1(hasVariantMembers);
FIELD2("canConstDefaultInit", allowConstDefaultInit);
Ret["defaultCtor"] = createDefaultConstructorDefinitionData(RD);
Ret["copyCtor"] = createCopyConstructorDefinitionData(RD);
Ret["moveCtor"] = createMoveConstructorDefinitionData(RD);
Ret["copyAssign"] = createCopyAssignmentDefinitionData(RD);
Ret["moveAssign"] = createMoveAssignmentDefinitionData(RD);
Ret["dtor"] = createDestructorDefinitionData(RD);
return Ret;
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdx, %r14
movq %rdi, %rbx
callq 0xf2e200
movq %r14, %rdi
callq 0xe22826
testb %al, %al
je 0xf2c9fc
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x352a71(%rip), %rsi # 0x127f43a
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq 0x80(%r14), %rax
testq %rax, %rax
je 0xf2ca58
testb $0x10, 0xa(%rax)
je 0xf2ca58
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x352a25(%rip), %rsi # 0x127f44a
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x8b7324
testb %al, %al
je 0xf2caae
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x3529d8(%rip), %rsi # 0x127f453
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x7cceca
testb %al, %al
je 0xf2cb04
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x35298a(%rip), %rsi # 0x127f45b
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x7cb17e
testb %al, %al
je 0xf2cb5a
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x352940(%rip), %rsi # 0x127f467
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0xe20a56
testb %al, %al
je 0xf2cbb0
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x3528fb(%rip), %rsi # 0x127f478
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x859f74
testb %al, %al
je 0xf2cc06
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x3528b9(%rip), %rsi # 0x127f48c
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0xf2e208
testb %al, %al
je 0xf2cc5c
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x352869(%rip), %rsi # 0x127f492
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x7ad816
testb %al, %al
je 0xf2ccb2
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x35281d(%rip), %rsi # 0x127f49c
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x835106
testb %al, %al
je 0xf2cd08
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x3527d5(%rip), %rsi # 0x127f4aa
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0xe22308
testb %al, %al
je 0xf2cd5e
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x35278a(%rip), %rsi # 0x127f4b5
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
testb $0x18, 0x4c(%r14)
jne 0xf2cdaf
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x352743(%rip), %rsi # 0x127f4bf
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x8ad64a
testb %al, %al
je 0xf2ce05
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x352700(%rip), %rsi # 0x127f4d2
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0xc856c4
testb %al, %al
je 0xf2ce5b
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x3526c5(%rip), %rsi # 0x127f4ed
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x961db4
testb %al, %al
je 0xf2ceb1
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x352692(%rip), %rsi # 0x127f510
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x8cf7d0
testb %al, %al
je 0xf2cf07
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x35264d(%rip), %rsi # 0x127f521
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x8e402e
testb %al, %al
je 0xf2cf5d
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x352609(%rip), %rsi # 0x127f533
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
leaq 0x20(%rsp), %rdi
callq 0xf2e200
movq %r14, %rdi
callq 0x86deb2
testb %al, %al
je 0xf2cfbf
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x35fd9d(%rip), %rsi # 0x128cd27
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x859f3a
testb %al, %al
je 0xf2d017
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x35f123(%rip), %rsi # 0x128c105
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x9ca9c2
testb %al, %al
je 0xf2d06f
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x352d76(%rip), %rsi # 0x127fdb0
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0xa21f4e
testb %al, %al
je 0xf2d0c7
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x352d29(%rip), %rsi # 0x127fdbb
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x8d298a
testb %al, %al
je 0xf2d11f
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x352af4(%rip), %rsi # 0x127fbde
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x86dece
testb %al, %al
je 0xf2d177
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x352c86(%rip), %rsi # 0x127fdc8
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x8d2850
testb %al, %al
je 0xf2d1cf
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x352c3c(%rip), %rsi # 0x127fdd6
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
leaq 0x38(%rsp), %r12
leaq 0x20(%rsp), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x54f770
leaq 0x35235c(%rip), %rsi # 0x127f547
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0xf2c5d0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r12, %rsi
callq 0x54268a
movq %r13, %rdi
callq 0x54fc08
movq %r12, %rdi
callq 0x117a148
movq %r15, %rdi
callq 0x54fc22
leaq 0x20(%rsp), %rdi
callq 0xf2e200
movq %r14, %rdi
callq 0x961a46
testb %al, %al
je 0xf2d288
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x35fb30(%rip), %rsi # 0x128cd83
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x86e7ea
testb %al, %al
je 0xf2d2e0
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x35ee5a(%rip), %rsi # 0x128c105
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x863d86
testb %al, %al
je 0xf2d338
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x352aad(%rip), %rsi # 0x127fdb0
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x8d51dc
testb %al, %al
je 0xf2d390
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x352a90(%rip), %rsi # 0x127fdeb
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0xe206c0
testb %al, %al
je 0xf2d3e8
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x352a45(%rip), %rsi # 0x127fdf8
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x8aff62
testb %al, %al
je 0xf2d440
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x3529fb(%rip), %rsi # 0x127fe06
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x8b3602
testb %al, %al
je 0xf2d498
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x352965(%rip), %rsi # 0x127fdc8
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x8b3612
testb %al, %al
je 0xf2d4f0
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x352961(%rip), %rsi # 0x127fe1c
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x8b3612
testb %al, %al
jne 0xf2d554
movq %r14, %rdi
callq 0x8d2184
testb %al, %al
je 0xf2d554
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x352915(%rip), %rsi # 0x127fe34
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
leaq 0x38(%rsp), %r12
leaq 0x20(%rsp), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x54f770
leaq 0x351fe3(%rip), %rsi # 0x127f553
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0xf2c5d0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r12, %rsi
callq 0x54268a
movq %r13, %rdi
callq 0x54fc08
movq %r12, %rdi
callq 0x117a148
movq %r15, %rdi
callq 0x54fc22
leaq 0x20(%rsp), %rdi
callq 0xf2e200
movq %r14, %rdi
callq 0x8d6c00
testb %al, %al
je 0xf2d60d
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x35f74f(%rip), %rsi # 0x128cd27
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0xe20882
testb %al, %al
je 0xf2d665
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x35f753(%rip), %rsi # 0x128cd83
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x8be9d6
testb %al, %al
je 0xf2d6bd
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x35ea7d(%rip), %rsi # 0x128c105
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x90c392
testb %al, %al
je 0xf2d715
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x3526d0(%rip), %rsi # 0x127fdb0
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x8b1fd8
testb %al, %al
je 0xf2d76d
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x3526b3(%rip), %rsi # 0x127fdeb
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x8b39dc
testb %al, %al
je 0xf2d7c5
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x352638(%rip), %rsi # 0x127fdc8
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x8b39be
testb %al, %al
je 0xf2d81d
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x352634(%rip), %rsi # 0x127fe1c
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x8b39be
testb %al, %al
jne 0xf2d881
movq %r14, %rdi
callq 0x8d21a4
testb %al, %al
je 0xf2d881
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x3525e8(%rip), %rsi # 0x127fe34
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
leaq 0x38(%rsp), %r12
leaq 0x20(%rsp), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x54f770
leaq 0x351cbf(%rip), %rsi # 0x127f55c
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0xf2c5d0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r12, %rsi
callq 0x54268a
movq %r13, %rdi
callq 0x54fc08
movq %r12, %rdi
callq 0x117a148
movq %r15, %rdi
callq 0x54fc22
leaq 0x20(%rsp), %rdi
callq 0xf2e200
movq %r14, %rdi
callq 0xe208b0
testb %al, %al
je 0xf2d93a
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x35f47e(%rip), %rsi # 0x128cd83
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x86e7f8
testb %al, %al
je 0xf2d992
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x35e7a8(%rip), %rsi # 0x128c105
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x863da6
testb %al, %al
je 0xf2d9ea
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x3523fb(%rip), %rsi # 0x127fdb0
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0xe206ee
testb %al, %al
je 0xf2da42
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x3523eb(%rip), %rsi # 0x127fdf8
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x8aff98
testb %al, %al
je 0xf2da9a
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x3523a1(%rip), %rsi # 0x127fe06
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x8d51ec
testb %al, %al
je 0xf2daf2
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x35232e(%rip), %rsi # 0x127fdeb
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x8b3d3e
testb %al, %al
je 0xf2db4a
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x3522b3(%rip), %rsi # 0x127fdc8
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x8b3d4e
testb %al, %al
je 0xf2dba2
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x3522af(%rip), %rsi # 0x127fe1c
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
leaq 0x38(%rsp), %r12
leaq 0x20(%rsp), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x54f770
leaq 0x3519a7(%rip), %rsi # 0x127f565
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0xf2c5d0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r12, %rsi
callq 0x54268a
movq %r13, %rdi
callq 0x54fc08
movq %r12, %rdi
callq 0x117a148
movq %r15, %rdi
callq 0x54fc22
leaq 0x20(%rsp), %rdi
callq 0xf2e200
movq %r14, %rdi
callq 0x8d6636
testb %al, %al
je 0xf2dc5b
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x35f101(%rip), %rsi # 0x128cd27
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0xe208d2
testb %al, %al
je 0xf2dcb3
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x35f105(%rip), %rsi # 0x128cd83
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x8bdb82
testb %al, %al
je 0xf2dd0b
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x35e42f(%rip), %rsi # 0x128c105
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x8d6652
testb %al, %al
je 0xf2dd63
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x352082(%rip), %rsi # 0x127fdb0
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x8b1fe8
testb %al, %al
je 0xf2ddbb
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x352065(%rip), %rsi # 0x127fdeb
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x8b403a
testb %al, %al
je 0xf2de13
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x351fea(%rip), %rsi # 0x127fdc8
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x8b39ce
testb %al, %al
je 0xf2de6b
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x351fe6(%rip), %rsi # 0x127fe1c
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
leaq 0x38(%rsp), %r12
leaq 0x20(%rsp), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x54f770
leaq 0x3516e9(%rip), %rsi # 0x127f570
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0xf2c5d0
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r12, %rsi
callq 0x54268a
movq %r13, %rdi
callq 0x54fc08
movq %r12, %rdi
callq 0x117a148
movq %r15, %rdi
callq 0x54fc22
leaq 0x20(%rsp), %rdi
callq 0xf2e200
movq %r14, %rdi
callq 0xe20900
testb %al, %al
je 0xf2df24
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x35ee94(%rip), %rsi # 0x128cd83
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x7c9774
testb %al, %al
je 0xf2df7c
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x35eecd(%rip), %rsi # 0x128ce14
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x85adc2
testb %al, %al
je 0xf2dfd4
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x35e166(%rip), %rsi # 0x128c105
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x863dc6
testb %al, %al
je 0xf2e02c
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x351db9(%rip), %rsi # 0x127fdb0
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x86e9b8
testb %al, %al
je 0xf2e084
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x351d9c(%rip), %rsi # 0x127fdeb
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x8b433c
testb %al, %al
je 0xf2e0dc
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x351d21(%rip), %rsi # 0x127fdc8
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x8b434c
testb %al, %al
je 0xf2e134
leaq 0x38(%rsp), %r15
movw $0x1, (%r15)
movb $0x1, 0x8(%r15)
leaq 0x351d1d(%rip), %rsi # 0x127fe1c
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x8b434c
testb %al, %al
jne 0xf2e198
movq %r14, %rdi
callq 0x8d2194
testb %al, %al
je 0xf2e198
leaq 0x38(%rsp), %r14
movw $0x1, (%r14)
movb $0x1, 0x8(%r14)
leaq 0x351cd1(%rip), %rsi # 0x127fe34
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xf2c5d0
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r14, %rsi
callq 0x54268a
movq %r15, %rdi
callq 0x54fc08
movq %r14, %rdi
callq 0x117a148
leaq 0x38(%rsp), %r15
leaq 0x20(%rsp), %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x54f770
leaq 0x28b8ad(%rip), %rsi # 0x11b9a61
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0xf2c5d0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1179d16
movq %rax, %rdi
movq %r15, %rsi
callq 0x54268a
movq %r12, %rdi
callq 0x54fc08
movq %r15, %rdi
callq 0x117a148
movq %r14, %rdi
callq 0x54fc22
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/AST/JSONNodeDumper.cpp
|
clang::JSONNodeDumper::VisitObjCBoxedExpr(clang::ObjCBoxedExpr const*)
|
void JSONNodeDumper::Visit(const comments::Comment *C,
const comments::FullComment *FC) {
if (!C)
return;
JOS.attribute("id", createPointerRepresentation(C));
JOS.attribute("kind", C->getCommentKindName());
JOS.attributeObject("loc",
[C, this] { writeSourceLocation(C->getLocation()); });
JOS.attributeObject("range",
[C, this] { writeSourceRange(C->getSourceRange()); });
InnerCommentVisitor::visit(C, FC);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq 0x18(%rsi), %r12
testq %r12, %r12
je 0xf31beb
movq %rdi, %r15
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x68(%rsp), %r14
movq %rsp, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x45b7c2
movq 0x28(%r12), %rax
leaq 0x20(%rsp), %rdi
movq %rax, (%rdi)
movq %r14, %rsi
callq 0x106e02a
addq $0x418, %r15 # imm = 0x418
leaq 0x48(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x4363d0
leaq 0x20(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x4bf8fa
leaq 0x28530a(%rip), %rsi # 0x11b6ec7
pushq $0x8
popq %rdx
movq %r15, %rdi
movq %r13, %rcx
callq 0x4bf8d8
movq %r13, %rdi
callq 0x117a148
movq %r12, %rdi
callq 0x436d30
movq %r14, %rdi
callq 0x4801c6
movq %rbx, %rdi
callq 0x436d30
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/AST/JSONNodeDumper.cpp
|
void llvm::SmallVectorImpl<clang::FieldDecl*>::append<clang::FieldDecl**, void>(clang::FieldDecl**, clang::FieldDecl**)
|
void append(ItTy in_start, ItTy in_end) {
this->assertSafeToAddRange(in_start, in_end);
size_type NumInputs = std::distance(in_start, in_end);
this->reserve(this->size() + NumInputs);
this->uninitialized_copy(in_start, in_end, this->end());
this->set_size(this->size() + NumInputs);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, %r12
subq %rsi, %r12
sarq $0x3, %r12
movl 0x8(%rdi), %esi
addq %r12, %rsi
callq 0x86e6bc
subq %r15, %r14
je 0xf5b2f4
movl 0x8(%rbx), %edi
shlq $0x3, %rdi
addq (%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x436800
addl %r12d, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/llvm/ADT/SmallVector.h
|
clang::OMPMetaDirective* clang::OMPExecutableDirective::createEmptyDirective<clang::OMPMetaDirective>(clang::ASTContext const&, unsigned int, bool, unsigned int)
|
static T *createEmptyDirective(const ASTContext &C, unsigned NumClauses,
bool HasAssociatedStmt = false,
unsigned NumChildren = 0) {
void *Mem =
C.Allocate(sizeof(T) + OMPChildren::size(NumClauses, HasAssociatedStmt,
NumChildren),
alignof(T));
auto *Data =
OMPChildren::CreateEmpty(reinterpret_cast<T *>(Mem) + 1, NumClauses,
HasAssociatedStmt, NumChildren);
auto *Inst = new (Mem) T;
Inst->Data = Data;
return Inst;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movl %esi, %eax
movl %edx, %ecx
addl %ebx, %ecx
addq %rax, %rcx
leaq 0x38(,%rcx,8), %rsi
addq $0x850, %rdi # imm = 0x850
pushq $0x3
popq %rdx
callq 0x467060
movq %rax, %r15
leaq 0x28(%rax), %r12
movl %r14d, 0x28(%rax)
movl %ebx, 0x2c(%rax)
movb %bpl, 0x30(%rax)
movq %rax, %rdi
callq 0xf82ca6
movq %r12, 0x18(%r15)
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
|
/clang/AST/StmtOpenMP.h
|
llvm::SmallVectorTemplateBase<clang::CompoundStmt*, true>::growAndAssign(unsigned long, clang::CompoundStmt*)
|
void growAndAssign(size_t NumElts, T Elt) {
// Elt has been copied in case it's an internal reference, side-stepping
// reference invalidation problems without losing the realloc optimization.
this->set_size(0);
this->grow(NumElts);
std::uninitialized_fill_n(this->begin(), NumElts, Elt);
this->set_size(NumElts);
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %rdx, (%r15)
andl $0x0, 0x8(%rdi)
callq 0xf82bd6
movq (%r14), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xf82bed
movl %ebx, 0x8(%r14)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/llvm/ADT/SmallVector.h
|
llvm::raw_ostream& clang::printOpenACCDirectiveKind<llvm::raw_ostream>(llvm::raw_ostream&, clang::OpenACCDirectiveKind)
|
inline StreamTy &printOpenACCDirectiveKind(StreamTy &Out,
OpenACCDirectiveKind K) {
switch (K) {
case OpenACCDirectiveKind::Parallel:
return Out << "parallel";
case OpenACCDirectiveKind::Serial:
return Out << "serial";
case OpenACCDirectiveKind::Kernels:
return Out << "kernels";
case OpenACCDirectiveKind::Data:
return Out << "data";
case OpenACCDirectiveKind::EnterData:
return Out << "enter data";
case OpenACCDirectiveKind::ExitData:
return Out << "exit data";
case OpenACCDirectiveKind::HostData:
return Out << "host_data";
case OpenACCDirectiveKind::Loop:
return Out << "loop";
case OpenACCDirectiveKind::Cache:
return Out << "cache";
case OpenACCDirectiveKind::ParallelLoop:
return Out << "parallel loop";
case OpenACCDirectiveKind::SerialLoop:
return Out << "serial loop";
case OpenACCDirectiveKind::KernelsLoop:
return Out << "kernels loop";
case OpenACCDirectiveKind::Atomic:
return Out << "atomic";
case OpenACCDirectiveKind::Declare:
return Out << "declare";
case OpenACCDirectiveKind::Init:
return Out << "init";
case OpenACCDirectiveKind::Shutdown:
return Out << "shutdown";
case OpenACCDirectiveKind::Set:
return Out << "set";
case OpenACCDirectiveKind::Update:
return Out << "update";
case OpenACCDirectiveKind::Wait:
return Out << "wait";
case OpenACCDirectiveKind::Routine:
return Out << "routine";
case OpenACCDirectiveKind::Invalid:
return Out << "<invalid>";
}
llvm_unreachable("Uncovered directive kind");
}
|
movslq %esi, %rax
leaq 0x2ff035(%rip), %rcx # 0x12883a4
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
jmp 0x45143e
nop
|
/clang/Basic/OpenACCKinds.h
|
(anonymous namespace)::StmtProfiler::VisitCXXConstructExpr(clang::CXXConstructExpr const*)
|
void StmtProfiler::VisitCXXConstructExpr(const CXXConstructExpr *S) {
VisitExpr(S);
VisitDecl(S->getConstructor());
ID.AddBoolean(S->isElidable());
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xf8b398
movq 0x10(%rbx), %rsi
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq 0x8(%r14), %rdi
movl (%rbx), %esi
shrl $0x12, %esi
andl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd90c86
|
/AST/StmtProfile.cpp
|
clang::SubstTemplateTemplateParmPackStorage::Profile(llvm::FoldingSetNodeID&, clang::ASTContext&)
|
void SubstTemplateTemplateParmPackStorage::Profile(llvm::FoldingSetNodeID &ID,
ASTContext &Context) {
Profile(ID, Context, getArgumentPack(), getAssociatedDecl(), getIndex(),
getFinal());
}
|
subq $0x18, %rsp
movq 0x10(%rdi), %rcx
movl (%rdi), %r8d
movl %r8d, %r9d
shrl $0x11, %r9d
movq %rsp, %rax
movl $0x9, (%rax)
movq %rcx, 0x8(%rax)
movl %r9d, 0x4(%rax)
movq 0x18(%rdi), %r9
movq %r9, %rcx
andq $-0x8, %rcx
shrl $0x2, %r8d
andl $0x7fff, %r8d # imm = 0x7FFF
andl $0x4, %r9d
shrl $0x2, %r9d
movq %rsi, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0xf8de54
addq $0x18, %rsp
retq
|
/AST/TemplateName.cpp
|
clang::TextNodeDumper::visitBlockCommandComment(clang::comments::BlockCommandComment const*, clang::comments::FullComment const*)
|
void TextNodeDumper::visitBlockCommandComment(
const comments::BlockCommandComment *C, const comments::FullComment *) {
OS << " Name=\"" << getCommandName(C->getCommandID()) << "\"";
for (unsigned i = 0, e = C->getNumArgs(); i != e; ++i)
OS << " Arg[" << i << "]=\"" << C->getArgText(i) << "\"";
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x448(%rdi), %rdi
leaq 0x2f9315(%rip), %rsi # 0x128b946
callq 0x45143e
movq %rax, %r15
movl 0xc(%rbx), %esi
shrl $0x8, %esi
andl $0xfffff, %esi # imm = 0xFFFFF
movq %r14, %rdi
callq 0xf9209a
movq %r15, %rdi
movq %rax, %rsi
callq 0x45143e
leaq 0x4aa890(%rip), %rsi # 0x143ceef
movq %rax, %rdi
callq 0x45143e
movl 0x18(%rbx), %r15d
pushq $0x10
popq %r13
xorl %r12d, %r12d
leaq 0x2f9327(%rip), %rbp # 0x128b9a0
cmpq %r12, %r15
je 0xf926d4
movq 0x448(%r14), %rdi
leaq 0x2f930e(%rip), %rsi # 0x128b99a
callq 0x45143e
movq %rax, %rdi
movq %r12, %rsi
callq 0x47f0a0
movq %rax, %rdi
movq %rbp, %rsi
callq 0x45143e
movq 0x10(%rbx), %rcx
movq -0x8(%rcx,%r13), %rsi
movq (%rcx,%r13), %rdx
movq %rax, %rdi
callq 0x453a5c
movq %rax, %rdi
leaq 0x4aa829(%rip), %rsi # 0x143ceef
callq 0x45143e
incq %r12
addq $0x18, %r13
jmp 0xf92679
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/AST/TextNodeDumper.cpp
|
clang::TextNodeDumper::VisitFieldDecl(clang::FieldDecl const*)
|
void TextNodeDumper::VisitFieldDecl(const FieldDecl *D) {
dumpName(D);
dumpType(D->getType());
if (D->isMutable())
OS << " mutable";
if (D->isModulePrivate())
OS << " __module_private__";
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0xf91ac0
movq 0x30(%r14), %rsi
movq %rbx, %rdi
callq 0xf8f244
testb $0x2, 0x44(%r14)
je 0xf965f7
movq 0x448(%rbx), %rdi
leaq 0x2f09ea(%rip), %rsi # 0x1286fdc
callq 0x45143e
movl 0x8(%r14), %eax
andl $0x7, %eax
cmpl $0x4, %eax
jne 0xf9661d
movq 0x448(%rbx), %rdi
leaq 0x2f5ad0(%rip), %rsi # 0x128c0e1
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x45143e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/AST/TextNodeDumper.cpp
|
clang::TextNodeDumper::VisitOMPRequiresDecl(clang::OMPRequiresDecl const*)
|
void TextNodeDumper::VisitOMPRequiresDecl(const OMPRequiresDecl *D) {
for (const auto *C : D->clauselists()) {
AddChild([=] {
if (!C) {
ColorScope Color(OS, ShowColors, NullColor);
OS << "<<<NULL>>> OMPClause";
return;
}
{
ColorScope Color(OS, ShowColors, AttrColor);
StringRef ClauseName(
llvm::omp::getOpenMPClauseName(C->getClauseKind()));
OS << "OMP" << ClauseName.substr(/*Start=*/0, /*N=*/1).upper()
<< ClauseName.drop_front() << "Clause";
}
dumpPointer(C);
dumpSourceRange(SourceRange(C->getBeginLoc(), C->getEndLoc()));
});
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
movq 0x28(%rsi), %rax
leaq 0x10(%rax), %r12
movl (%rax), %ecx
leaq 0x10(%rax,%rcx,8), %r14
leaq 0x50(%rsp), %r13
leaq 0x10(%rdi), %r15
pushq $0x1
popq %rbp
movq %r14, 0x30(%rsp)
cmpq %r14, %r12
je 0xf96edf
movq (%r12), %rax
leaq 0x2eb983(%rip), %rcx # 0x12826c7
movq %rcx, 0x38(%rsp)
andq $0x0, 0x40(%rsp)
movq %rax, 0x20(%rsp)
movq %rbx, 0x28(%rsp)
cmpb $0x1, 0x420(%rbx)
jne 0xf96d9f
movb $0x0, 0x420(%rbx)
leaq 0x20(%rsp), %rdi
callq 0xf9e6c6
movl 0x18(%rbx), %eax
testq %rax, %rax
je 0xf96e07
movq (%r15), %rcx
shlq $0x5, %rax
leaq (%rcx,%rax), %rdi
addq $-0x20, %rdi
movl %ebp, %esi
callq 0xdc997a
movq %r15, %rdi
callq 0xdc9996
jmp 0xf96d73
movq %rbx, 0x48(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%r13)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%r13)
leaq 0x60(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x4525b6
cmpb $0x1, 0x421(%rbx)
jne 0xf96e34
movq %rsp, %r13
movq %r13, %rdi
leaq 0x48(%rsp), %rsi
callq 0xf9e838
movq %r15, %rdi
movq %r13, %rsi
callq 0xdc99bc
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0xf96ec0
movq %r13, %rdi
movq %r13, %rsi
pushq $0x3
popq %rdx
callq *%rax
jmp 0xf96ec0
andq $0x0, 0x430(%rbx)
movq 0x428(%rbx), %rax
movb $0x0, (%rax)
movq (%rbx), %rdi
leaq 0x215b15(%rip), %rsi # 0x11ac938
callq 0x45143e
movb $0x1, 0x420(%rbx)
jmp 0xf96ed6
movq 0x10(%rbx), %rax
movl 0x18(%rbx), %ecx
shlq $0x5, %rcx
leaq (%rax,%rcx), %rdi
addq $-0x20, %rdi
xorl %esi, %esi
callq 0xdc997a
movq 0x10(%rbx), %r13
movl 0x18(%rbx), %r14d
shlq $0x5, %r14
movq %rsp, %rdi
leaq 0x48(%rsp), %rsi
callq 0xf9e838
movaps (%rsp), %xmm0
movaps %xmm0, 0x80(%rsp)
movups -0x20(%r13,%r14), %xmm1
movaps %xmm1, (%rsp)
movups %xmm0, -0x20(%r13,%r14)
movq 0x10(%rsp), %rcx
movq -0x10(%r13,%r14), %rax
movq %rax, 0x10(%rsp)
movq %rcx, -0x10(%r13,%r14)
movq 0x18(%rsp), %rcx
movq -0x8(%r13,%r14), %rdx
movq %rdx, 0x18(%rsp)
movq %rcx, -0x8(%r13,%r14)
testq %rax, %rax
je 0xf96ebb
movq %rsp, %rdi
movq %rdi, %rsi
pushq $0x3
popq %rdx
callq *%rax
movq 0x30(%rsp), %r14
leaq 0x50(%rsp), %r13
movb $0x0, 0x421(%rbx)
leaq 0x60(%rsp), %rdi
callq 0x436d30
addq $0x8, %r12
jmp 0xf96d30
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/AST/TextNodeDumper.cpp
|
clang::ObjCObjectType::isSpecialized() const
|
bool ObjCObjectType::isSpecialized() const {
// If we have type arguments written here, the type is specialized.
if (ObjCObjectTypeBits.NumTypeArgs > 0)
return true;
// Otherwise, check whether the base type is specialized.
if (const auto objcObject = getBaseType()->getAs<ObjCObjectType>()) {
// Terminate when we reach an interface type.
if (isa<ObjCInterfaceType>(objcObject))
return false;
return objcObject->isSpecialized();
}
// Not specialized.
return false;
}
|
movzwl 0x12(%rdi), %eax
movb $0x1, %cl
testw $0x3f8, %ax # imm = 0x3F8
jne 0xfa3b32
pushq %rbx
movq 0x18(%rdi), %rax
andq $-0x10, %rax
movq (%rax), %rdi
callq 0x4eda7e
movq %rax, %rbx
testq %rax, %rax
je 0xfa3b1f
cmpb $0x22, 0x10(%rbx)
jne 0xfa3b21
xorl %eax, %eax
jmp 0xfa3b29
jmp 0xfa3b29
movq %rbx, %rdi
callq 0xfa3af0
testq %rbx, %rbx
setne %cl
andb %al, %cl
popq %rbx
movl %ecx, %eax
retq
nop
|
/AST/Type.cpp
|
clang::ObjCObjectTypeImpl::Profile(llvm::FoldingSetNodeID&, clang::QualType, llvm::ArrayRef<clang::QualType>, llvm::ArrayRef<clang::ObjCProtocolDecl*>, bool)
|
void ObjCObjectTypeImpl::Profile(llvm::FoldingSetNodeID &ID,
QualType BaseType,
ArrayRef<QualType> typeArgs,
ArrayRef<ObjCProtocolDecl *> protocols,
bool isKindOf) {
ID.AddPointer(BaseType.getAsOpaquePtr());
ID.AddInteger(typeArgs.size());
for (auto typeArg : typeArgs)
ID.AddPointer(typeArg.getAsOpaquePtr());
ID.AddInteger(protocols.size());
for (auto *proto : protocols)
ID.AddPointer(proto);
ID.AddBoolean(isKindOf);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r12
movq %rdx, %r13
movq %rdi, %r15
movb 0x40(%rsp), %al
movb %al, 0x7(%rsp)
callq 0x49582e
movq %r15, %rdi
movq %r12, %rsi
callq 0x49582e
shlq $0x3, %r12
xorl %ebp, %ebp
cmpq %rbp, %r12
je 0xfaa3fc
movq (%r13,%rbp), %rsi
movq %r15, %rdi
callq 0x49582e
addq $0x8, %rbp
jmp 0xfaa3e4
movq %r15, %rdi
movq %rbx, %rsi
callq 0x49582e
shlq $0x3, %rbx
xorl %r12d, %r12d
cmpq %r12, %rbx
je 0xfaa425
movq (%r14,%r12), %rsi
movq %r15, %rdi
callq 0x49582e
addq $0x8, %r12
jmp 0xfaa40e
movzbl 0x7(%rsp), %esi
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd90c86
|
/AST/Type.cpp
|
clang::LinkageComputer::computeTypeLinkageInfo(clang::Type const*)
|
LinkageInfo LinkageComputer::computeTypeLinkageInfo(const Type *T) {
switch (T->getTypeClass()) {
#define TYPE(Class,Base)
#define NON_CANONICAL_TYPE(Class,Base) case Type::Class:
#include "clang/AST/TypeNodes.inc"
llvm_unreachable("didn't expect a non-canonical type here");
#define TYPE(Class,Base)
#define DEPENDENT_TYPE(Class,Base) case Type::Class:
#define NON_CANONICAL_UNLESS_DEPENDENT_TYPE(Class,Base) case Type::Class:
#include "clang/AST/TypeNodes.inc"
// Treat instantiation-dependent types as external.
assert(T->isInstantiationDependentType());
return LinkageInfo::external();
case Type::BitInt:
case Type::Builtin:
return LinkageInfo::external();
case Type::Auto:
case Type::DeducedTemplateSpecialization:
return LinkageInfo::external();
case Type::Record:
case Type::Enum:
return getDeclLinkageAndVisibility(cast<TagType>(T)->getDecl());
case Type::Complex:
return computeTypeLinkageInfo(cast<ComplexType>(T)->getElementType());
case Type::Pointer:
return computeTypeLinkageInfo(cast<PointerType>(T)->getPointeeType());
case Type::BlockPointer:
return computeTypeLinkageInfo(cast<BlockPointerType>(T)->getPointeeType());
case Type::LValueReference:
case Type::RValueReference:
return computeTypeLinkageInfo(cast<ReferenceType>(T)->getPointeeType());
case Type::MemberPointer: {
const auto *MPT = cast<MemberPointerType>(T);
LinkageInfo LV = computeTypeLinkageInfo(MPT->getClass());
LV.merge(computeTypeLinkageInfo(MPT->getPointeeType()));
return LV;
}
case Type::ConstantArray:
case Type::IncompleteArray:
case Type::VariableArray:
case Type::ArrayParameter:
return computeTypeLinkageInfo(cast<ArrayType>(T)->getElementType());
case Type::Vector:
case Type::ExtVector:
return computeTypeLinkageInfo(cast<VectorType>(T)->getElementType());
case Type::ConstantMatrix:
return computeTypeLinkageInfo(
cast<ConstantMatrixType>(T)->getElementType());
case Type::FunctionNoProto:
return computeTypeLinkageInfo(cast<FunctionType>(T)->getReturnType());
case Type::FunctionProto: {
const auto *FPT = cast<FunctionProtoType>(T);
LinkageInfo LV = computeTypeLinkageInfo(FPT->getReturnType());
for (const auto &ai : FPT->param_types())
LV.merge(computeTypeLinkageInfo(ai));
return LV;
}
case Type::ObjCInterface:
return getDeclLinkageAndVisibility(cast<ObjCInterfaceType>(T)->getDecl());
case Type::ObjCObject:
return computeTypeLinkageInfo(cast<ObjCObjectType>(T)->getBaseType());
case Type::ObjCObjectPointer:
return computeTypeLinkageInfo(
cast<ObjCObjectPointerType>(T)->getPointeeType());
case Type::Atomic:
return computeTypeLinkageInfo(cast<AtomicType>(T)->getValueType());
case Type::Pipe:
return computeTypeLinkageInfo(cast<PipeType>(T)->getElementType());
}
llvm_unreachable("unhandled type class");
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movzbl 0x10(%rsi), %eax
addl $-0x2, %eax
leaq 0x2e4a21(%rip), %rcx # 0x128f11c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x16, 0xf(%rsp)
jmp 0xfaa71b
movq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0xfaa7dc
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %r14, %rdi
callq 0x4c5cee
movq %rbx, %rdi
movq %rax, %rsi
jmp 0xfaa712
movq %r14, %rdi
callq 0xfa5a44
jmp 0xfaa755
movq 0x18(%r14), %rsi
jmp 0xfaa70f
movq %r14, %rdi
callq 0xfa3bc8
movq %rbx, %rdi
movq %rax, %rsi
callq 0xe0f4dc
jmp 0xfaa717
movq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0xfaa6da
leaq 0xf(%rsp), %r15
movb %al, (%r15)
movq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0xfaa7dc
movzbl %al, %esi
movq %r15, %rdi
callq 0xd8fa06
jmp 0xfaa71b
movq 0x18(%r14), %rsi
movq %rbx, %rdi
callq 0xfaa7dc
leaq 0xf(%rsp), %r15
movb %al, (%r15)
movq 0x10(%r14), %r12
shrq $0x23, %r12
andl $0x7fff8, %r12d # imm = 0x7FFF8
xorl %r13d, %r13d
cmpq %r13, %r12
je 0xfaa71b
movq 0x30(%r14,%r13), %rsi
movq %rbx, %rdi
callq 0xfaa7dc
movzbl %al, %esi
movq %r15, %rdi
callq 0xd8fa06
addq $0x8, %r13
jmp 0xfaa7b5
|
/AST/Type.cpp
|
clang::AutoType::Profile(llvm::FoldingSetNodeID&, clang::ASTContext const&, clang::QualType, clang::AutoTypeKeyword, bool, clang::ConceptDecl*, llvm::ArrayRef<clang::TemplateArgument>)
|
void AutoType::Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context,
QualType Deduced, AutoTypeKeyword Keyword,
bool IsDependent, ConceptDecl *CD,
ArrayRef<TemplateArgument> Arguments) {
ID.AddPointer(Deduced.getAsOpaquePtr());
ID.AddInteger((unsigned)Keyword);
ID.AddBoolean(IsDependent);
ID.AddPointer(CD);
for (const TemplateArgument &Arg : Arguments)
Arg.Profile(ID, Context);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r9, %r15
movl %r8d, %ebp
movl %ecx, %r12d
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, %rsi
callq 0x49582e
movq %r14, %rdi
movl %r12d, %esi
callq 0x4957e2
movq %r14, %rdi
movl %ebp, %esi
callq 0xd90c86
movq %r14, %rdi
movq %r15, %rsi
callq 0x49582e
movq 0x30(%rsp), %r15
imulq $0x18, 0x38(%rsp), %r12
testq %r12, %r12
je 0xfaaf33
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xf8cce6
addq $0x18, %r15
addq $-0x18, %r12
jmp 0xfaaf16
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/AST/Type.cpp
|
llvm::MutableArrayRef<clang::QualType> llvm::ArrayRef<clang::QualType>::copy<clang::ASTContext>(clang::ASTContext&)
|
MutableArrayRef<T> copy(Allocator &A) {
T *Buff = A.template Allocate<T>(Length);
std::uninitialized_copy(begin(), end(), Buff);
return MutableArrayRef<T>(Buff, Length);
}
|
pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
movq %rax, %rdi
callq 0xfab558
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
cmpq %rsi, %rdx
je 0xfab551
movq (%rcx,%rsi), %rdi
movq %rdi, (%rax,%rsi)
addq $0x8, %rsi
jmp 0xfab53e
movq 0x8(%rbx), %rdx
popq %rbx
retq
nop
|
/llvm/ADT/ArrayRef.h
|
(anonymous namespace)::TypePrinter::print(clang::Type const*, clang::Qualifiers, llvm::raw_ostream&, llvm::StringRef)
|
void TypePrinter::print(const Type *T, Qualifiers Quals, raw_ostream &OS,
StringRef PlaceHolder) {
if (!T) {
OS << "NULL TYPE";
return;
}
SaveAndRestore PHVal(HasEmptyPlaceHolder, PlaceHolder.empty());
printBefore(T, Quals, OS);
OS << PlaceHolder;
printAfter(T, Quals, OS);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
testq %rsi, %rsi
je 0xfaee07
movq %r9, %r12
movq %r8, %r13
movq %rsi, %r15
movq %rdi, %r14
testq %r9, %r9
movb 0x14(%rdi), %bpl
sete 0x14(%rdi)
movq %rbx, %rcx
callq 0xfaf1f2
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x453a5c
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xfb0b28
movb %bpl, 0x14(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2e29dc(%rip), %rsi # 0x12917ea
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x45143e
|
/AST/TypePrinter.cpp
|
llvm::DenseMapIterator<clang::BaseSubobject, clang::VTableLayout::AddressPointLocation, llvm::DenseMapInfo<clang::BaseSubobject, void>, llvm::detail::DenseMapPair<clang::BaseSubobject, clang::VTableLayout::AddressPointLocation>, true>::operator++()
|
inline DenseMapIterator& operator++() { // Preincrement
assert(isHandleInSync() && "invalid iterator access!");
assert(Ptr != End && "incrementing end() iterator");
if (shouldReverseIterate<KeyT>()) {
--Ptr;
RetreatPastEmptyBuckets();
return *this;
}
++Ptr;
AdvancePastEmptyBuckets();
return *this;
}
|
pushq %rbx
movq %rdi, %rbx
addq $0x18, (%rdi)
callq 0xfb6862
movq %rbx, %rax
popq %rbx
retq
|
/llvm/ADT/DenseMap.h
|
(anonymous namespace)::ItaniumVTableBuilder::LayoutPrimaryAndSecondaryVTables(clang::BaseSubobject, bool, bool, clang::CharUnits)
|
void ItaniumVTableBuilder::LayoutPrimaryAndSecondaryVTables(
BaseSubobject Base, bool BaseIsMorallyVirtual,
bool BaseIsVirtualInLayoutClass, CharUnits OffsetInLayoutClass) {
assert(Base.getBase()->isDynamicClass() && "class does not have a vtable!");
unsigned VTableIndex = Components.size();
VTableIndices.push_back(VTableIndex);
// Add vcall and vbase offsets for this vtable.
VCallAndVBaseOffsetBuilder Builder(
VTables, MostDerivedClass, LayoutClass, &Overriders, Base,
BaseIsVirtualInLayoutClass, OffsetInLayoutClass);
Components.append(Builder.components_begin(), Builder.components_end());
// Check if we need to add these vcall offsets.
if (BaseIsVirtualInLayoutClass && !Builder.getVCallOffsets().empty()) {
VCallOffsetMap &VCallOffsets = VCallOffsetsForVBases[Base.getBase()];
if (VCallOffsets.empty())
VCallOffsets = Builder.getVCallOffsets();
}
// If we're laying out the most derived class we want to keep track of the
// virtual base class offset offsets.
if (Base.getBase() == MostDerivedClass)
VBaseOffsetOffsets = Builder.getVBaseOffsetOffsets();
// Add the offset to top.
CharUnits OffsetToTop = MostDerivedClassOffset - OffsetInLayoutClass;
Components.push_back(VTableComponent::MakeOffsetToTop(OffsetToTop));
// Next, add the RTTI.
if (!Context.getLangOpts().OmitVTableRTTI)
Components.push_back(VTableComponent::MakeRTTI(MostDerivedClass));
uint64_t AddressPoint = Components.size();
// Now go through all virtual member functions and add them.
PrimaryBasesSetVectorTy PrimaryBases;
AddMethods(Base, OffsetInLayoutClass,
Base.getBase(), OffsetInLayoutClass,
PrimaryBases);
const CXXRecordDecl *RD = Base.getBase();
if (RD == MostDerivedClass) {
assert(MethodVTableIndices.empty());
for (const auto &I : MethodInfoMap) {
const CXXMethodDecl *MD = I.first;
const MethodInfo &MI = I.second;
if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(MD)) {
MethodVTableIndices[GlobalDecl(DD, Dtor_Complete)]
= MI.VTableIndex - AddressPoint;
MethodVTableIndices[GlobalDecl(DD, Dtor_Deleting)]
= MI.VTableIndex + 1 - AddressPoint;
} else {
MethodVTableIndices[MD] = MI.VTableIndex - AddressPoint;
}
}
}
// Compute 'this' pointer adjustments.
ComputeThisAdjustments();
// Add all address points.
while (true) {
AddressPoints.insert(
std::make_pair(BaseSubobject(RD, OffsetInLayoutClass),
VTableLayout::AddressPointLocation{
unsigned(VTableIndices.size() - 1),
unsigned(AddressPoint - VTableIndex)}));
const ASTRecordLayout &Layout = Context.getASTRecordLayout(RD);
const CXXRecordDecl *PrimaryBase = Layout.getPrimaryBase();
if (!PrimaryBase)
break;
if (Layout.isPrimaryBaseVirtual()) {
// Check if this virtual primary base is a primary base in the layout
// class. If it's not, we don't want to add it.
const ASTRecordLayout &LayoutClassLayout =
Context.getASTRecordLayout(LayoutClass);
if (LayoutClassLayout.getVBaseClassOffset(PrimaryBase) !=
OffsetInLayoutClass) {
// We don't want to add this class (or any of its primary bases).
break;
}
}
RD = PrimaryBase;
}
// Layout secondary vtables.
LayoutSecondaryVTables(Base, BaseIsMorallyVirtual, OffsetInLayoutClass);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x528, %rsp # imm = 0x528
movq %r9, %rbp
movl %r8d, %ebx
movl %ecx, 0x64(%rsp)
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
leaq 0xa0(%rdi), %r13
movl 0xa8(%rdi), %esi
addq $0x368, %rdi # imm = 0x368
movq %rsi, 0x88(%rsp)
callq 0x54bb0e
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq 0x20(%r12), %rcx
leaq 0x30(%r12), %rax
movq %r14, 0x20(%rsp)
movq %r14, 0xf0(%rsp)
movq %r15, 0xf8(%rsp)
movups 0xf0(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rbp, 0x38(%rsp)
movq %rbp, 0x10(%rsp)
movq %rax, %rbp
leaq 0x188(%rsp), %r14
movq %r14, %rdi
movq %rax, %r8
movl %ebx, %r9d
callq 0xfb2dc6
movq 0x20(%r14), %rax
movl 0x28(%r14), %ecx
leaq (%rax,%rcx,8), %rcx
leaq 0x108(%rsp), %rsi
movq %rcx, (%rsi)
leaq 0x100(%rsp), %rdx
movq %rax, (%rdx)
movq %r13, 0x40(%rsp)
movq %r13, %rdi
callq 0xfb82a8
testl %ebx, %ebx
je 0xfb7b06
cmpl $0x0, 0x400(%rsp)
je 0xfb7b06
leaq 0x70(%r12), %r14
leaq 0xa0(%rsp), %rsi
movq 0x20(%rsp), %r13
movq %r13, (%rsi)
leaq 0x120(%rsp), %rbx
movq %r14, %rdi
movq %rbx, %rdx
callq 0xfb8cde
movq (%rbx), %rbx
testb %al, %al
je 0xfb7ab4
cmpl $0x0, 0x10(%rbx)
jne 0xfb7b06
jmp 0xfb7af2
leaq 0xa0(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0xfb8d54
movq %rax, %rbx
movq %r13, (%rax)
leaq 0x18(%rax), %r14
movl $0x100, %edx # imm = 0x100
movq %r14, %rdi
xorl %esi, %esi
callq 0x436260
movq %r14, 0x8(%rbx)
movabsq $0x1000000000, %rax # imm = 0x1000000000
movq %rax, 0x10(%rbx)
leaq 0x3f8(%rsp), %rsi
addq $0x8, %rbx
movq %rbx, %rdi
callq 0xfb9006
movq 0x20(%rsp), %rax
cmpq %rax, 0x8(%r12)
jne 0xfb7b27
leaq 0x508(%rsp), %rsi
leaq 0x88(%r12), %rdi
callq 0xf5c520
movq 0x10(%r12), %rax
subq 0x38(%rsp), %rax
leaq 0x2(,%rax,8), %rsi
movq 0x40(%rsp), %rdi
callq 0xfb6c90
movq 0x28(%r12), %rax
movq 0x830(%rax), %rax
testb $0x20, 0xa8(%rax)
jne 0xfb7b6b
movq 0x8(%r12), %rsi
orq $0x3, %rsi
movq 0x40(%rsp), %rdi
callq 0xfb6c90
movl 0xa8(%r12), %eax
movq %rax, 0x48(%rsp)
leaq 0x120(%rsp), %rbx
movq %rbx, %rdi
callq 0xfb90de
movq %rbx, (%rsp)
movq %r12, %rdi
movq 0x20(%rsp), %rbx
movq %rbx, %rsi
movq %r15, 0x90(%rsp)
movq %r15, %rdx
movq 0x38(%rsp), %rcx
movq %rbx, %r8
movq %rcx, %r9
callq 0xfb8306
cmpq %rbx, 0x8(%r12)
jne 0xfb7ce9
movq %rbp, 0x80(%rsp)
leaq 0x2c8(%r12), %rdi
callq 0xfb8a4c
movq %rax, %rbx
leaq 0xa0(%rsp), %rax
movq %rbx, (%rax)
movq %rdx, 0x8(%rax)
movl 0x2d8(%r12), %ebp
shlq $0x5, %rbp
addq 0x2c8(%r12), %rbp
leaq 0x2e0(%r12), %rax
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rax
negq %rax
movq %rax, 0x28(%rsp)
movq %r12, 0x98(%rsp)
movq 0x30(%rsp), %r15
cmpq %rbp, %rbx
je 0xfb7ce1
movq (%rbx), %r14
movq 0x18(%rbx), %r13
subq 0x48(%rsp), %r13
testq %r14, %r14
je 0xfb7ca4
movl 0x1c(%r14), %eax
andl $0x7f, %eax
cmpl $0x21, %eax
jne 0xfb7ca4
andq $-0x8, %r14
leaq 0x1(%r14), %rax
movq %rax, 0x68(%rsp)
andl $0x0, 0x70(%rsp)
movq %r15, %rdi
movq %rbp, %r12
leaq 0x68(%rsp), %rbp
movq %rbp, %rsi
callq 0xfbb4e0
movq %r13, 0x10(%rax)
movq 0x18(%rbx), %rax
movq 0x28(%rsp), %rcx
leaq (%rax,%rcx), %rbx
incq %rbx
movq %r14, 0x68(%rsp)
andl $0x0, 0x70(%rsp)
movq %r15, %rdi
movq %rbp, %rsi
movq %r12, %rbp
movq 0x98(%rsp), %r12
callq 0xfbb4e0
movq %rbx, 0x10(%rax)
jmp 0xfb7cc7
leaq 0x68(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xe4c3be
movq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq 0xfbb4e0
movq %r13, 0x10(%rax)
leaq 0xa0(%rsp), %rdi
callq 0xfb8a70
movq 0xa0(%rsp), %rbx
jmp 0xfb7c1f
movq 0x80(%rsp), %rbp
leaq 0x2c8(%r12), %rdi
movq %rdi, 0x28(%rsp)
callq 0xfb8a4c
movq %rax, %rbx
leaq 0x110(%rsp), %r15
movq %rax, (%r15)
movq %rdx, 0x8(%r15)
movl 0x2d8(%r12), %r14d
shlq $0x5, %r14
addq 0x2c8(%r12), %r14
leaq 0x2f8(%r12), %rax
movq %rax, 0x30(%rsp)
leaq 0xa0(%rsp), %r13
cmpq %r14, %rbx
je 0xfb7e45
movq (%rbx), %rdx
movq %rdx, 0x58(%rsp)
movq 0x18(%rbx), %rax
movq %rax, 0x50(%rsp)
movq 0x40(%rsp), %rcx
movq (%rcx), %rcx
movl (%rcx,%rax,8), %eax
notl %eax
testb $0x7, %al
je 0xfb7e30
movq 0x8(%rbx), %rcx
leaq 0x68(%rsp), %rdi
movq %rbp, %rsi
callq 0xfb6cf8
movq 0x10(%rbx), %rcx
cmpq 0x78(%rsp), %rcx
jne 0xfb7dad
movq %r13, %rdi
movq 0x30(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0xfbb780
movq 0xc0(%rsp), %rax
orq 0xb8(%rsp), %rax
je 0xfb7e30
movq 0x10(%rbx), %rcx
movq 0x58(%rsp), %rdx
movq 0x78(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x68(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r13, %rdi
movq %r12, %rsi
callq 0xfb94fc
movq %r13, %rdi
callq 0xfbb7e2
testb %al, %al
jne 0xfb7e30
movq %r12, 0xd8(%rsp)
leaq 0x58(%rsp), %rax
movq %rax, 0xe0(%rsp)
movq %r13, 0xe8(%rsp)
movq 0x50(%rsp), %rsi
leaq 0xd8(%rsp), %rdi
callq 0xfbb7f4
movq 0x58(%rsp), %rax
movl 0x1c(%rax), %eax
andl $0x7f, %eax
cmpl $0x21, %eax
jne 0xfb7e30
movq 0x50(%rsp), %rsi
incq %rsi
leaq 0xd8(%rsp), %rdi
callq 0xfbb7f4
movq %r15, %rdi
callq 0xfb8a70
movq 0x110(%rsp), %rbx
jmp 0xfb7d36
movl 0x2d0(%r12), %eax
movl 0x2d4(%r12), %ecx
orl %eax, %ecx
je 0xfb7efe
leal (,%rax,4), %ecx
movl 0x2d8(%r12), %esi
cmpl %esi, %ecx
setae %cl
cmpl $0x41, %esi
setb %dl
orb %cl, %dl
jne 0xfb7e8b
testl %eax, %eax
je 0xfb7eb7
decl %eax
je 0xfb7ebb
bsrl %eax, %eax
xorl $0x1f, %eax
jmp 0xfb7ebe
movq 0x28(%rsp), %rax
movq (%rax), %rax
shlq $0x5, %rsi
xorl %ecx, %ecx
cmpq %rcx, %rsi
je 0xfb7eac
movq $-0x1000, (%rax,%rcx) # imm = 0xF000
addq $0x20, %rcx
jmp 0xfb7e99
andq $0x0, 0x2d0(%r12)
jmp 0xfb7efe
xorl %ebx, %ebx
jmp 0xfb7ed0
pushq $0x20
popq %rax
movb $0x21, %cl
subb %al, %cl
pushq $0x1
popq %rax
shll %cl, %eax
cmpl $0x41, %eax
pushq $0x40
popq %rbx
cmovgel %eax, %ebx
cmpl %esi, %ebx
jne 0xfb7ee0
movq 0x28(%rsp), %rdi
callq 0xfb78d8
jmp 0xfb7efe
movq 0x28(%rsp), %r14
movq (%r14), %rdi
shlq $0x5, %rsi
pushq $0x8
popq %rdx
callq 0x464066
movq %r14, %rdi
movl %ebx, %esi
callq 0xfb7866
movq 0x8(%r12), %rax
cmpq 0x20(%r12), %rax
je 0xfb7ffe
leaq 0x2b0(%r12), %rbx
movq 0x48(%rsp), %rbp
subl 0x88(%rsp), %ebp
shlq $0x20, %rbp
leaq 0x68(%rsp), %r14
leaq 0xa0(%rsp), %r15
movq 0x20(%rsp), %r13
movl 0x370(%r12), %eax
decl %eax
movq %r13, 0xa0(%rsp)
movq 0x38(%rsp), %rcx
movq %rcx, 0xa8(%rsp)
orq %rbp, %rax
movq %rax, 0xb0(%rsp)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xfb8a82
movq 0x28(%r12), %rdi
movq %r13, %rsi
callq 0xf5c776
movq 0x48(%rax), %rax
movq 0x30(%rax), %rax
movq %rax, %r13
andq $-0x8, %r13
je 0xfb7fb3
testb $0x4, %al
je 0xfb7f38
movq 0x20(%r12), %rsi
movq 0x28(%r12), %rdi
callq 0xf5c776
movq %rax, %rdi
movq %r13, %rsi
callq 0xdb2756
cmpq 0x38(%rsp), %rax
je 0xfb7f38
movzbl 0x64(%rsp), %ecx
movq %r12, %rdi
movq 0x20(%rsp), %rsi
movq 0x90(%rsp), %rdx
movq 0x38(%rsp), %r8
callq 0xfb8a94
leaq 0x120(%rsp), %rdi
callq 0xfb8b92
leaq 0x188(%rsp), %rdi
callq 0xfb2edc
addq $0x528, %rsp # imm = 0x528
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x30(%rsp), %rdi
callq 0xfbb88a
movq %rax, %r14
leaq 0xa0(%rsp), %rbx
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
movl 0x308(%r12), %r13d
shlq $0x6, %r13
addq 0x2f8(%r12), %r13
cmpq %r13, %r14
je 0xfb7f0e
movq (%r14), %rax
movq 0x40(%rsp), %rcx
movq (%rcx), %rcx
movq (%rcx,%rax,8), %r15
movl %r15d, %eax
andl $0x6, %eax
cmpl $0x4, %eax
jne 0xfb8076
andq $-0x8, %r15
movq %r15, %rdi
callq 0x4d2f20
cmpq 0x8(%r12), %rax
jne 0xfb8076
addq $0x8, %r14
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xfb9798
movq %rbx, %rdi
callq 0xfbb8ac
movq 0xa0(%rsp), %r14
jmp 0xfb802e
|
/AST/VTableBuilder.cpp
|
llvm::DenseMapBase<llvm::DenseMap<clang::BaseSubobject, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<clang::BaseSubobject, void>, llvm::detail::DenseSetPair<clang::BaseSubobject>>, clang::BaseSubobject, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<clang::BaseSubobject, void>, llvm::detail::DenseSetPair<clang::BaseSubobject>>::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);
}
|
testl %esi, %esi
je 0xfbdbd4
pushq %rax
shll $0x2, %esi
pushq $0x3
popq %rcx
movl %esi, %eax
xorl %edx, %edx
divl %ecx
leal 0x1(%rax), %edi
callq 0x45e847
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
nop
|
/llvm/ADT/DenseMap.h
|
std::pair<llvm::DenseMapIterator<clang::CXXRecordDecl const*, unsigned int, llvm::DenseMapInfo<clang::CXXRecordDecl const*, void>, llvm::detail::DenseMapPair<clang::CXXRecordDecl const*, unsigned int>, false>, bool> llvm::DenseMapBase<llvm::DenseMap<clang::CXXRecordDecl const*, unsigned int, llvm::DenseMapInfo<clang::CXXRecordDecl const*, void>, llvm::detail::DenseMapPair<clang::CXXRecordDecl const*, unsigned int>>, clang::CXXRecordDecl const*, unsigned int, llvm::DenseMapInfo<clang::CXXRecordDecl const*, void>, llvm::detail::DenseMapPair<clang::CXXRecordDecl const*, unsigned int>>::try_emplace<unsigned int const&>(clang::CXXRecordDecl const* const&, unsigned int const&)
|
std::pair<iterator, bool> try_emplace(const KeyT &Key, Ts &&... Args) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return std::make_pair(makeIterator(TheBucket,
shouldReverseIterate<KeyT>()
? getBuckets()
: getBucketsEnd(),
*this, true),
false); // Already in map.
// Otherwise, insert the new element.
TheBucket = InsertIntoBucket(TheBucket, Key, std::forward<Ts>(Args)...);
return std::make_pair(makeIterator(TheBucket,
shouldReverseIterate<KeyT>()
? getBuckets()
: getBucketsEnd(),
*this, true),
true);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r13
movq %rsi, %rdi
movq %rdx, %rsi
movq %r13, %rdx
callq 0x70ac00
movl %eax, %ecx
movq (%r13), %rax
testb %cl, %cl
je 0xfc32f0
xorl %ecx, %ecx
jmp 0xfc3303
movq %r14, %rdi
movq %rax, %rsi
movq %r12, %rdx
movq %r15, %rcx
callq 0xfc332a
movb $0x1, %cl
movl 0x10(%r14), %edx
shlq $0x4, %rdx
addq (%r14), %rdx
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
movb %cl, 0x10(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/llvm/ADT/DenseMap.h
|
clang::comments::Parser::isTokBlockCommand()
|
bool is(tok::TokenKind K) const LLVM_READONLY { return Kind == K; }
|
movl 0x34(%rdi), %eax
andl $-0x2, %eax
cmpl $0x4, %eax
jne 0xfc7237
pushq %rax
movq 0x28(%rdi), %rax
movl 0x38(%rdi), %esi
movq %rax, %rdi
callq 0xe08ad8
movb 0x13(%rax), %al
andb $0x2, %al
shrb %al
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
|
/clang/AST/CommentLexer.h
|
llvm::SmallVectorImpl<clang::interp::Scope::Local>::operator=(llvm::SmallVectorImpl<clang::interp::Scope::Local>&&)
|
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;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0xfd5f36
movq %rsi, %r14
movq (%rsi), %rsi
leaq 0x10(%r14), %rax
cmpq %rax, %rsi
je 0xfd5eb8
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfd5f46
jmp 0xfd5f36
movl 0x8(%r14), %r15d
movl 0x8(%rbx), %r12d
cmpl %r15d, %r12d
jae 0xfd5edc
cmpl %r15d, 0xc(%rbx)
jae 0xfd5ef2
andl $0x0, 0x8(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xfd5f84
jmp 0xfd5f08
testl %r15d, %r15d
je 0xfd5f2d
movq (%rbx), %rdi
movq %r15, %rdx
shlq $0x4, %rdx
callq 0x436140
jmp 0xfd5f2d
testq %r12, %r12
je 0xfd5f08
movq %r12, %rdx
shlq $0x4, %rdx
movq (%rbx), %rdi
callq 0x436140
jmp 0xfd5f0b
xorl %r12d, %r12d
movl 0x8(%r14), %edx
subq %r12, %rdx
je 0xfd5f2d
shlq $0x4, %r12
movq (%r14), %rsi
addq %r12, %rsi
addq (%rbx), %r12
shlq $0x4, %rdx
movq %r12, %rdi
callq 0x436800
movl %r15d, 0x8(%rbx)
andl $0x0, 0x8(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/llvm/ADT/SmallVector.h
|
llvm::DenseMap<clang::ParmVarDecl const*, clang::interp::ParamOffset, llvm::DenseMapInfo<clang::ParmVarDecl const*, void>, llvm::detail::DenseMapPair<clang::ParmVarDecl const*, clang::interp::ParamOffset>>::grow(unsigned int)
|
void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBuckets(OldBuckets, OldBuckets+OldNumBuckets);
// Free the old table.
deallocate_buffer(OldBuckets, sizeof(BucketT) * OldNumBuckets,
alignof(BucketT));
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl 0x10(%rdi), %ebx
movq (%rdi), %r14
leal -0x1(%rsi), %edi
callq 0x45e847
cmpl $0x41, %eax
pushq $0x40
popq %rsi
cmovael %eax, %esi
movq %r15, %rdi
callq 0xe9a076
testq %r14, %r14
je 0xfd66dc
shlq $0x4, %rbx
leaq (%r14,%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0xfd66ea
pushq $0x8
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x464066
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xe9a0a8
nop
|
/llvm/ADT/DenseMap.h
|
llvm::DenseMap<clang::FunctionDecl const*, std::unique_ptr<clang::interp::Function, std::default_delete<clang::interp::Function>>, llvm::DenseMapInfo<clang::FunctionDecl const*, void>, llvm::detail::DenseMapPair<clang::FunctionDecl const*, std::unique_ptr<clang::interp::Function, std::default_delete<clang::interp::Function>>>>::grow(unsigned int)
|
void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBuckets(OldBuckets, OldBuckets+OldNumBuckets);
// Free the old table.
deallocate_buffer(OldBuckets, sizeof(BucketT) * OldNumBuckets,
alignof(BucketT));
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl 0x10(%rdi), %ebx
movq (%rdi), %r14
leal -0x1(%rsi), %edi
callq 0x45e847
cmpl $0x41, %eax
pushq $0x40
popq %rsi
cmovael %eax, %esi
movq %r15, %rdi
callq 0xe99596
testq %r14, %r14
je 0xfd68d0
shlq $0x4, %rbx
leaq (%r14,%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0xfd68de
pushq $0x8
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x464066
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xe995c8
nop
|
/llvm/ADT/DenseMap.h
|
clang::interp::Compiler<clang::interp::ByteCodeEmitter>::collectBaseOffset(clang::QualType, clang::QualType)
|
unsigned Compiler<Emitter>::collectBaseOffset(const QualType BaseType,
const QualType DerivedType) {
const auto extractRecordDecl = [](QualType Ty) -> const CXXRecordDecl * {
if (const auto *PT = dyn_cast<PointerType>(Ty))
return PT->getPointeeType()->getAsCXXRecordDecl();
return Ty->getAsCXXRecordDecl();
};
const CXXRecordDecl *BaseDecl = extractRecordDecl(BaseType);
const CXXRecordDecl *DerivedDecl = extractRecordDecl(DerivedType);
return Ctx.collectBaseOffset(BaseDecl, DerivedDecl);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x7(%rsp), %r15
movq %r15, %rdi
callq 0xfe4182
movq %rax, %r12
movq %r15, %rdi
movq %rbx, %rsi
callq 0xfe4182
movq 0x1e8(%r14), %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0xe994a4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/AST/Interp/Compiler.cpp
|
clang::interp::Compiler<clang::interp::ByteCodeEmitter>::visitZeroInitializer(clang::interp::PrimType, clang::QualType, clang::Expr const*)
|
bool Compiler<Emitter>::visitZeroInitializer(PrimType T, QualType QT,
const Expr *E) {
switch (T) {
case PT_Bool:
return this->emitZeroBool(E);
case PT_Sint8:
return this->emitZeroSint8(E);
case PT_Uint8:
return this->emitZeroUint8(E);
case PT_Sint16:
return this->emitZeroSint16(E);
case PT_Uint16:
return this->emitZeroUint16(E);
case PT_Sint32:
return this->emitZeroSint32(E);
case PT_Uint32:
return this->emitZeroUint32(E);
case PT_Sint64:
return this->emitZeroSint64(E);
case PT_Uint64:
return this->emitZeroUint64(E);
case PT_IntAP:
return this->emitZeroIntAP(Ctx.getBitWidth(QT), E);
case PT_IntAPS:
return this->emitZeroIntAPS(Ctx.getBitWidth(QT), E);
case PT_Ptr:
return this->emitNullPtr(nullptr, E);
case PT_FnPtr:
return this->emitNullFnPtr(nullptr, E);
case PT_MemberPtr:
return this->emitNullMemberPtr(nullptr, E);
case PT_Float: {
return this->emitConstFloat(APFloat::getZero(Ctx.getFloatSemantics(QT)), E);
}
}
llvm_unreachable("unknown primitive type");
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r14
movq %rdi, %rbx
movl %esi, %eax
leaq 0x2bb1fa(%rip), %rcx # 0x1293d50
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
orq $0x4, %r14
movq %rsp, %rsi
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0xfd59a0
jmp 0xfd8d16
orq $0x4, %r14
movq %rsp, %rdx
movq %r14, (%rdx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0xfd3648
jmp 0xfd8d16
movq 0x1e8(%rbx), %rdi
movq %rdx, %rsi
callq 0xe99336
leaq 0x28(%rsp), %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0xe56216
leaq 0x8(%rsp), %r15
leaq 0x30(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x491982
orq $0x4, %r14
leaq 0x20(%rsp), %rdx
movq %r14, (%rdx)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xfcee46
movl %eax, %ebx
movq %r15, %rdi
callq 0x468578
movq %r12, %rdi
callq 0x468578
jmp 0xfd8d18
orq $0x4, %r14
movq %rsp, %rsi
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0xfd59d8
jmp 0xfd8d16
orq $0x4, %r14
movq %rsp, %rdx
movq %r14, (%rdx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0xfd361c
jmp 0xfd8d16
movq 0x1e8(%rbx), %rdi
movq %rdx, %rsi
callq 0xfd8856
orq $0x4, %r14
movq %rsp, %rdx
movq %r14, (%rdx)
movq %rbx, %rdi
movl %eax, %esi
callq 0xfd5a36
jmp 0xfd8d16
orq $0x4, %r14
movq %rsp, %rsi
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0xfd59bc
jmp 0xfd8d16
orq $0x4, %r14
movq %rsp, %rsi
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0xfd59ca
jmp 0xfd8d16
orq $0x4, %r14
movq %rsp, %rsi
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0xfd5a02
jmp 0xfd8d16
orq $0x4, %r14
movq %rsp, %rsi
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0xfd59ae
jmp 0xfd8d16
orq $0x4, %r14
movq %rsp, %rsi
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0xfd59e6
jmp 0xfd8d16
orq $0x4, %r14
movq %rsp, %rdx
movq %r14, (%rdx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0xfd3632
jmp 0xfd8d16
orq $0x4, %r14
movq %rsp, %rsi
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0xfd59f4
jmp 0xfd8d16
orq $0x4, %r14
movq %rsp, %rsi
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0xfd5a10
jmp 0xfd8d16
movq 0x1e8(%rbx), %rdi
movq %rdx, %rsi
callq 0xfd8856
orq $0x4, %r14
movq %rsp, %rdx
movq %r14, (%rdx)
movq %rbx, %rdi
movl %eax, %esi
callq 0xfd5a1e
movl %eax, %ebx
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/AST/Interp/Compiler.cpp
|
clang::interp::LocalScope<clang::interp::ByteCodeEmitter>::destroyLocals()
|
bool destroyLocals() {
if (!Idx)
return true;
bool Success = this->emitDestructors();
this->Ctx->emitDestroy(*Idx, SourceInfo{});
removeStoredOpaqueValues();
this->Idx = std::nullopt;
return Success;
}
|
pushq %rbp
pushq %rbx
pushq %rax
movb $0x1, %bpl
cmpb $0x1, 0x24(%rdi)
jne 0xfde1c2
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x28(%rax)
movl %eax, %ebp
movq 0x8(%rbx), %rdi
movl 0x20(%rbx), %esi
movq %rsp, %rdx
andq $0x0, (%rdx)
callq 0xfcfcbc
movq %rbx, %rdi
callq 0xff0e9c
cmpb $0x1, 0x24(%rbx)
jne 0xfde1c2
movb $0x0, 0x24(%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
|
/AST/Interp/Compiler.h
|
clang::interp::Compiler<clang::interp::ByteCodeEmitter>::VisitCompoundAssignOperator(clang::CompoundAssignOperator const*)
|
bool Compiler<Emitter>::VisitCompoundAssignOperator(
const CompoundAssignOperator *E) {
const Expr *LHS = E->getLHS();
const Expr *RHS = E->getRHS();
std::optional<PrimType> LHSComputationT =
classify(E->getComputationLHSType());
std::optional<PrimType> LT = classify(LHS->getType());
std::optional<PrimType> RT = classify(RHS->getType());
std::optional<PrimType> ResultT = classify(E->getType());
if (!Ctx.getLangOpts().CPlusPlus14)
return this->visit(RHS) && this->visit(LHS) && this->emitError(E);
if (!LT || !RT || !ResultT || !LHSComputationT)
return false;
// Handle floating point operations separately here, since they
// require special care.
if (ResultT == PT_Float || RT == PT_Float)
return VisitFloatCompoundAssignOperator(E);
if (E->getType()->isPointerType())
return VisitPointerCompoundAssignOperator(E);
assert(!E->getType()->isPointerType() && "Handled above");
assert(!E->getType()->isFloatingType() && "Handled above");
// C++17 onwards require that we evaluate the RHS first.
// Compute RHS and save it in a temporary variable so we can
// load it again later.
// FIXME: Compound assignments are unsequenced in C, so we might
// have to figure out how to reject them.
if (!visit(RHS))
return false;
unsigned TempOffset = this->allocateLocalPrimitive(E, *RT, /*IsConst=*/true);
if (!this->emitSetLocal(*RT, TempOffset, E))
return false;
// Get LHS pointer, load its value and cast it to the
// computation type if necessary.
if (!visit(LHS))
return false;
if (!this->emitLoad(*LT, E))
return false;
if (LT != LHSComputationT) {
if (!this->emitCast(*LT, *LHSComputationT, E))
return false;
}
// Get the RHS value on the stack.
if (!this->emitGetLocal(*RT, TempOffset, E))
return false;
// Perform operation.
switch (E->getOpcode()) {
case BO_AddAssign:
if (!this->emitAdd(*LHSComputationT, E))
return false;
break;
case BO_SubAssign:
if (!this->emitSub(*LHSComputationT, E))
return false;
break;
case BO_MulAssign:
if (!this->emitMul(*LHSComputationT, E))
return false;
break;
case BO_DivAssign:
if (!this->emitDiv(*LHSComputationT, E))
return false;
break;
case BO_RemAssign:
if (!this->emitRem(*LHSComputationT, E))
return false;
break;
case BO_ShlAssign:
if (!this->emitShl(*LHSComputationT, *RT, E))
return false;
break;
case BO_ShrAssign:
if (!this->emitShr(*LHSComputationT, *RT, E))
return false;
break;
case BO_AndAssign:
if (!this->emitBitAnd(*LHSComputationT, E))
return false;
break;
case BO_XorAssign:
if (!this->emitBitXor(*LHSComputationT, E))
return false;
break;
case BO_OrAssign:
if (!this->emitBitOr(*LHSComputationT, E))
return false;
break;
default:
llvm_unreachable("Unimplemented compound assign operator");
}
// And now cast from LHSComputationT to ResultT.
if (ResultT != LHSComputationT) {
if (!this->emitCast(*LHSComputationT, *ResultT, E))
return false;
}
// And store the result in LHS.
if (DiscardResult) {
if (LHS->refersToBitField())
return this->emitStoreBitFieldPop(*ResultT, E);
return this->emitStorePop(*ResultT, E);
}
if (LHS->refersToBitField())
return this->emitStoreBitField(*ResultT, E);
return this->emitStore(*ResultT, E);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r13
movq %rdi, %rbx
movq 0x10(%rsi), %r15
movq 0x18(%rsi), %r14
movq 0x20(%rsi), %rsi
callq 0xfd84fc
movq %rax, 0x30(%rsp)
movq 0x8(%r15), %rsi
movq %rbx, %rdi
callq 0xfd84fc
movq %rax, %rbp
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0xfd84fc
movq %rax, 0x20(%rsp)
movq 0x8(%r13), %rsi
movq %rbx, %rdi
callq 0xfd84fc
movq %rax, %r12
movq 0x1e8(%rbx), %rdi
callq 0xe99134
testb $0x10, 0x1(%rax)
jne 0xfde85f
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfd8674
testb %al, %al
je 0xfdebca
movq %rbx, %rdi
movq %r15, %rsi
callq 0xfd8674
testb %al, %al
je 0xfdebca
orq $0x4, %r13
leaq 0x8(%rsp), %rsi
movq %r13, (%rsi)
movq %rbx, %rdi
callq 0xfd0048
movl %eax, %r15d
jmp 0xfdebcd
movq %r12, 0x18(%rsp)
movq %r15, 0x40(%rsp)
movq %rbp, %r12
shrq $0x20, %r12
xorl %r15d, %r15d
testb $0x1, %r12b
je 0xfdebcd
movabsq $0x100000000, %rax # imm = 0x100000000
movq 0x20(%rsp), %rdx
andq %rdx, %rax
je 0xfdebcd
movq 0x18(%rsp), %r15
shrq $0x20, %r15
testb $0x1, %r15b
je 0xfdebca
movq 0x30(%rsp), %rcx
shrq $0x20, %rcx
testb $0x1, %cl
je 0xfdebca
cmpl $0xb, 0x18(%rsp)
je 0xfde8fb
cmpl $0xb, %edx
je 0xfde8fb
movq 0x8(%r13), %rax
andq $-0x10, %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
andq $-0x10, %rax
movq (%rax), %rax
cmpb $0x28, 0x10(%rax)
jne 0xfde914
movq %rbx, %rdi
movq %r13, %rsi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xfdee8e
movq %rbx, %rdi
movq %r13, %rsi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xfdec32
movq %rcx, 0x28(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfd8674
testb %al, %al
je 0xfdebca
movq %r15, 0x38(%rsp)
movq %r13, %rax
orq $0x2, %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
pushq $0x1
popq %rcx
xorl %r15d, %r15d
movq %rbx, %rdi
movq 0x20(%rsp), %r14
movl %r14d, %edx
xorl %r8d, %r8d
callq 0xfd8d26
movl %eax, %edx
movq %r13, %rax
orq $0x4, %rax
movq %rax, 0x10(%rsp)
leaq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movq %rbx, %rdi
movl %r14d, %esi
movl %edx, %r14d
callq 0xfd3c74
testb %al, %al
je 0xfdebcd
movq %rbx, %rdi
movq 0x40(%rsp), %r15
movq %r15, %rsi
callq 0xfd8674
testb %al, %al
je 0xfdebca
leaq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
movq %rax, (%rdx)
movq %rbx, %rdi
movl %ebp, %esi
callq 0xfd2e86
testb %al, %al
je 0xfdebca
cmpb 0x28(%rsp), %r12b
setne %al
movq 0x30(%rsp), %r12
cmpl %r12d, %ebp
setne %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0xfde9f8
leaq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rax, (%rcx)
movq %rbx, %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0xfcd776
testb %al, %al
je 0xfdebca
leaq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rax, (%rcx)
movq %rbx, %rdi
movq 0x20(%rsp), %rsi
movl %r14d, %edx
callq 0xfd0b7c
testb %al, %al
je 0xfdebca
movl (%r13), %eax
shrl $0x12, %eax
andl $0x3f, %eax
addl $-0x16, %eax
leaq 0x2b5427(%rip), %rcx # 0x1293e58
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
movq %rax, (%rdx)
movq %rbx, %rdi
movl %r12d, %esi
callq 0xfd314c
jmp 0xfdeb55
leaq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
movq %rax, (%rdx)
movq %rbx, %rdi
movl %r12d, %esi
callq 0xfd560e
jmp 0xfdeb55
leaq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
movq %rax, (%rdx)
movq %rbx, %rdi
movl %r12d, %esi
callq 0xfcd05a
jmp 0xfdeb55
leaq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
movq %rax, (%rdx)
movq %rbx, %rdi
movl %r12d, %esi
callq 0xfd3a0e
jmp 0xfdeb55
leaq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
movq %rax, (%rdx)
movq %rbx, %rdi
movl %r12d, %esi
callq 0xfcbf0a
jmp 0xfdeb55
leaq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
movq %rax, (%rdx)
movq %rbx, %rdi
movl %r12d, %esi
callq 0xfccf80
jmp 0xfdeb55
leaq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
movq %rax, (%rdx)
movq %rbx, %rdi
movl %r12d, %esi
callq 0xfcfcd4
jmp 0xfdeb55
leaq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rax, (%rcx)
movq %rbx, %rdi
movl %r12d, %esi
movq 0x20(%rsp), %rdx
callq 0xfd3e84
jmp 0xfdeb55
leaq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rax, (%rcx)
movq %rbx, %rdi
movl %r12d, %esi
movq 0x20(%rsp), %rdx
callq 0xfd47e2
jmp 0xfdeb55
leaq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rax
movq %rax, (%rdx)
movq %rbx, %rdi
movl %r12d, %esi
callq 0xfcd134
testb %al, %al
movq 0x18(%rsp), %r14
je 0xfdebca
movq 0x28(%rsp), %rax
cmpb %al, 0x38(%rsp)
setne %al
cmpl %r12d, %r14d
setne %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0xfdeb96
leaq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rax, (%rcx)
movq %rbx, %rdi
movl %r12d, %esi
movl %r14d, %edx
callq 0xfcd776
testb %al, %al
je 0xfdebca
movzwl 0x1(%r15), %eax
andl $0x1c, %eax
cmpb $0x1, 0x248(%rbx)
jne 0xfdebdf
leaq 0x8(%rsp), %rdx
cmpw $0x4, %ax
jne 0xfdec02
movq 0x10(%rsp), %rax
movq %rax, (%rdx)
movq %rbx, %rdi
movl %r14d, %esi
callq 0xfd53ae
jmp 0xfde857
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8(%rsp), %rdx
cmpw $0x4, %ax
jne 0xfdec1a
movq 0x10(%rsp), %rax
movq %rax, (%rdx)
movq %rbx, %rdi
movl %r14d, %esi
callq 0xfd52aa
jmp 0xfde857
movq 0x10(%rsp), %rax
movq %rax, (%rdx)
movq %rbx, %rdi
movl %r14d, %esi
callq 0xfd54b2
jmp 0xfde857
movq 0x10(%rsp), %rax
movq %rax, (%rdx)
movq %rbx, %rdi
movl %r14d, %esi
callq 0xfd514e
jmp 0xfde857
|
/AST/Interp/Compiler.cpp
|
clang::interp::Compiler<clang::interp::ByteCodeEmitter>::VisitPointerCompoundAssignOperator(clang::CompoundAssignOperator const*)
|
bool Compiler<Emitter>::VisitPointerCompoundAssignOperator(
const CompoundAssignOperator *E) {
BinaryOperatorKind Op = E->getOpcode();
const Expr *LHS = E->getLHS();
const Expr *RHS = E->getRHS();
std::optional<PrimType> LT = classify(LHS->getType());
std::optional<PrimType> RT = classify(RHS->getType());
if (Op != BO_AddAssign && Op != BO_SubAssign)
return false;
if (!LT || !RT)
return false;
if (!visit(LHS))
return false;
if (!this->emitLoad(*LT, LHS))
return false;
if (!visit(RHS))
return false;
if (Op == BO_AddAssign) {
if (!this->emitAddOffset(*RT, E))
return false;
} else {
if (!this->emitSubOffset(*RT, E))
return false;
}
if (DiscardResult)
return this->emitStorePopPtr(E);
return this->emitStorePtr(E);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %r15d
shrl $0x12, %r15d
andl $0x3f, %r15d
movq 0x10(%rsi), %r13
movq 0x18(%rsi), %r12
movq 0x8(%r13), %rsi
callq 0xfd84fc
movq %rax, %rbp
movq 0x8(%r12), %rsi
movq %rbx, %rdi
callq 0xfd84fc
movq %rax, %rsi
leal -0x1b(%r15), %ecx
xorl %eax, %eax
cmpl $-0x2, %ecx
jb 0xfdef8e
movabsq $0x100000000, %rcx # imm = 0x100000000
movq %rbp, %rdx
andq %rcx, %rdx
je 0xfdef8e
andq %rsi, %rcx
je 0xfdef8e
movq %rsi, 0x10(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0xfd8674
testb %al, %al
je 0xfdef8c
orq $0x4, %r13
leaq 0x8(%rsp), %rdx
movq %r13, (%rdx)
movq %rbx, %rdi
movl %ebp, %esi
callq 0xfd2e86
testb %al, %al
je 0xfdef8c
movq %rbx, %rdi
movq %r12, %rsi
callq 0xfd8674
testb %al, %al
je 0xfdef8c
orq $0x4, %r14
leaq 0x8(%rsp), %rdx
cmpl $0x19, %r15d
jne 0xfdef5d
movq %r14, (%rdx)
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
callq 0xfcc058
jmp 0xfdef6d
movq %r14, (%rdx)
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
callq 0xfd5712
testb %al, %al
je 0xfdef8c
cmpb $0x1, 0x248(%rbx)
jne 0xfdef9d
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0xfd55d6
jmp 0xfdefad
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0xfd5272
jmp 0xfdef8e
nop
|
/AST/Interp/Compiler.cpp
|
clang::interp::Compiler<clang::interp::EvalEmitter>::VisitPointerCompoundAssignOperator(clang::CompoundAssignOperator const*)
|
bool Compiler<Emitter>::VisitPointerCompoundAssignOperator(
const CompoundAssignOperator *E) {
BinaryOperatorKind Op = E->getOpcode();
const Expr *LHS = E->getLHS();
const Expr *RHS = E->getRHS();
std::optional<PrimType> LT = classify(LHS->getType());
std::optional<PrimType> RT = classify(RHS->getType());
if (Op != BO_AddAssign && Op != BO_SubAssign)
return false;
if (!LT || !RT)
return false;
if (!visit(LHS))
return false;
if (!this->emitLoad(*LT, LHS))
return false;
if (!visit(RHS))
return false;
if (Op == BO_AddAssign) {
if (!this->emitAddOffset(*RT, E))
return false;
} else {
if (!this->emitSubOffset(*RT, E))
return false;
}
if (DiscardResult)
return this->emitStorePopPtr(E);
return this->emitStorePtr(E);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %r15d
shrl $0x12, %r15d
andl $0x3f, %r15d
movq 0x10(%rsi), %r13
movq 0x18(%rsi), %r12
movq 0x8(%r13), %rsi
callq 0xfe5330
movq %rax, %rbp
movq 0x8(%r12), %rsi
movq %rbx, %rdi
callq 0xfe5330
movq %rax, %rsi
leal -0x1b(%r15), %ecx
xorl %eax, %eax
cmpl $-0x2, %ecx
jb 0xfebcc4
movabsq $0x100000000, %rcx # imm = 0x100000000
movq %rbp, %rdx
andq %rcx, %rdx
je 0xfebcc4
andq %rsi, %rcx
je 0xfebcc4
movq %rsi, 0x10(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0xfe54a8
testb %al, %al
je 0xfebcc2
orq $0x4, %r13
leaq 0x8(%rsp), %rdx
movq %r13, (%rdx)
movq %rbx, %rdi
movl %ebp, %esi
callq 0xebf87c
testb %al, %al
je 0xfebcc2
movq %rbx, %rdi
movq %r12, %rsi
callq 0xfe54a8
testb %al, %al
je 0xfebcc2
orq $0x4, %r14
leaq 0x8(%rsp), %rdx
cmpl $0x19, %r15d
jne 0xfebc93
movq %r14, (%rdx)
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
callq 0xe9bec0
jmp 0xfebca3
movq %r14, (%rdx)
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
callq 0xed22e2
testb %al, %al
je 0xfebcc2
cmpb $0x1, 0x3a0(%rbx)
jne 0xfebcd3
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0xed13d0
jmp 0xfebce3
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0xecf4fc
jmp 0xfebcc4
nop
|
/AST/Interp/Compiler.cpp
|
llvm::SmallVectorTemplateBase<llvm::SmallVector<clang::interp::Scope::Local, 8u>, false>::moveElementsForGrow(llvm::SmallVector<clang::interp::Scope::Local, 8u>*)
|
void SmallVectorTemplateBase<T, TriviallyCopyable>::moveElementsForGrow(
T *NewElts) {
// Move the elements over.
this->uninitialized_move(this->begin(), this->end(), NewElts);
// Destroy the original elements.
destroy_range(this->begin(), this->end());
}
|
pushq %rbx
movq %rsi, %rdx
movq %rdi, %rbx
movq (%rdi), %rdi
movl 0x8(%rbx), %eax
imulq $0x90, %rax, %rsi
addq %rdi, %rsi
callq 0xff126a
movq (%rbx), %rdi
movl 0x8(%rbx), %eax
imulq $0x90, %rax, %rsi
addq %rdi, %rsi
popq %rbx
jmp 0xe99980
|
/llvm/ADT/SmallVector.h
|
void moveArrayTy<clang::interp::Integral<32u, false>>(clang::interp::Block*, std::byte const*, std::byte*, clang::interp::Descriptor const*)
|
static void moveArrayTy(Block *, const std::byte *Src, std::byte *Dst,
const Descriptor *D) {
// FIXME: Get rid of the const_cast.
InitMapPtr &SrcIMP =
*reinterpret_cast<InitMapPtr *>(const_cast<std::byte *>(Src));
if (SrcIMP) {
// We only ever invoke the moveFunc when moving block contents to a
// DeadBlock. DeadBlocks don't need InitMaps, so we destroy them here.
SrcIMP = std::nullopt;
}
Src += sizeof(InitMapPtr);
Dst += sizeof(InitMapPtr);
for (unsigned I = 0, NE = D->getNumElems(); I < NE; ++I) {
const auto *SrcPtr = &reinterpret_cast<const T *>(Src)[I];
auto *DstPtr = &reinterpret_cast<T *>(Dst)[I];
new (DstPtr) T(std::move(*SrcPtr));
}
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r14
cmpb $0x1, 0x18(%rsi)
jne 0xff35c5
movq %r14, %rdi
callq 0xff341a
movl 0xc(%r15), %eax
cmpl $-0x1, %eax
je 0xff35d6
xorl %edx, %edx
divl 0x8(%r15)
jmp 0xff35d8
xorl %eax, %eax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0xff35ed
movl 0x20(%r14,%rcx,4), %edx
movl %edx, 0x20(%rbx,%rcx,4)
incq %rcx
jmp 0xff35da
popq %rbx
popq %r14
popq %r15
retq
|
/AST/Interp/Descriptor.cpp
|
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>>::find(unsigned int 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();
}
|
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
callq 0x4e8e92
testb %al, %al
je 0xff65d1
movq 0x8(%rsp), %rax
movl 0x10(%rbx), %edx
shlq $0x3, %rdx
addq (%rbx), %rdx
jmp 0xff65de
movl 0x10(%rbx), %eax
shlq $0x3, %rax
addq (%rbx), %rax
movq %rax, %rdx
addq $0x10, %rsp
popq %rbx
retq
|
/llvm/ADT/DenseMap.h
|
clang::HeaderSearch::getUniqueFrameworkName(llvm::StringRef)
|
StringRef HeaderSearch::getUniqueFrameworkName(StringRef Framework) {
return FrameworkNames.insert(Framework).first->first();
}
|
pushq %rax
addq $0x7e8, %rdi # imm = 0x7E8
callq 0x4f1bfc
movq (%rax), %rax
movq (%rax), %rdx
addq $0x8, %rax
popq %rcx
retq
|
/Lex/HeaderSearch.cpp
|
bool 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>>::LookupBucketFor<clang::DirectoryEntry const*>(clang::DirectoryEntry const* const&, llvm::detail::DenseMapPair<clang::DirectoryEntry const*, bool> const*&) const
|
unsigned getNumBuckets() const {
return NumBuckets;
}
|
movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0xffb75c
pushq %rbx
movq (%rdi), %rdi
movq (%rsi), %rsi
movl %esi, %eax
shrl $0x4, %eax
movl %esi, %r8d
shrl $0x9, %r8d
xorl %eax, %r8d
decl %ecx
movl $0x1, %r10d
xorl %r9d, %r9d
andl %ecx, %r8d
movq %r8, %rax
shlq $0x4, %rax
leaq (%rdi,%rax), %r11
movq (%rdi,%rax), %rbx
movb $0x1, %al
cmpq %rbx, %rsi
je 0xffb76c
cmpq $-0x1000, %rbx # imm = 0xF000
je 0xffb763
xorq $-0x2000, %rbx # imm = 0xE000
orq %r9, %rbx
cmoveq %r11, %r9
addl %r10d, %r8d
incl %r10d
jmp 0xffb724
xorl %r11d, %r11d
xorl %eax, %eax
jmp 0xffb76d
testq %r9, %r9
cmovneq %r9, %r11
xorl %eax, %eax
popq %rbx
movq %r11, (%rdx)
retq
nop
|
/llvm/ADT/DenseMap.h
|
llvm::DenseMap<clang::DirectoryEntry const*, bool, llvm::DenseMapInfo<clang::DirectoryEntry const*, void>, llvm::detail::DenseMapPair<clang::DirectoryEntry const*, bool>>::allocateBuckets(unsigned int)
|
bool allocateBuckets(unsigned Num) {
NumBuckets = Num;
if (NumBuckets == 0) {
Buckets = nullptr;
return false;
}
Buckets = static_cast<BucketT *>(
allocate_buffer(sizeof(BucketT) * NumBuckets, alignof(BucketT)));
return true;
}
|
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, 0x10(%rdi)
testl %esi, %esi
je 0xffb859
movl %ebp, %edi
shlq $0x4, %rdi
pushq $0x8
popq %rsi
callq 0x464061
jmp 0xffb85b
xorl %eax, %eax
testl %ebp, %ebp
setne %cl
movq %rax, (%rbx)
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
/llvm/ADT/DenseMap.h
|
clang::Lexer::tryReadUCN(char const*&, char const*, clang::Token*)
|
uint32_t Lexer::tryReadUCN(const char *&StartPtr, const char *SlashLoc,
Token *Result) {
unsigned CharSize;
std::optional<uint32_t> CodePointOpt;
char Kind = getCharAndSize(StartPtr, CharSize);
if (Kind == 'u' || Kind == 'U')
CodePointOpt = tryReadNumericUCN(StartPtr, SlashLoc, Result);
else if (Kind == 'N')
CodePointOpt = tryReadNamedUCN(StartPtr, SlashLoc, Result);
if (!CodePointOpt)
return 0;
uint32_t CodePoint = *CodePointOpt;
// Don't apply C family restrictions to UCNs in assembly mode
if (LangOpts.AsmPreprocessor)
return CodePoint;
// C23 6.4.3p2: A universal character name shall not designate a code point
// where the hexadecimal value is:
// - in the range D800 through DFFF inclusive; or
// - greater than 10FFFF.
// A universal-character-name outside the c-char-sequence of a character
// constant, or the s-char-sequence of a string-literal shall not designate
// a control character or a character in the basic character set.
// C++11 [lex.charset]p2: If the hexadecimal value for a
// universal-character-name corresponds to a surrogate code point (in the
// range 0xD800-0xDFFF, inclusive), the program is ill-formed. Additionally,
// if the hexadecimal value for a universal-character-name outside the
// c-char-sequence, s-char-sequence, or r-char-sequence of a character or
// string literal corresponds to a control character (in either of the
// ranges 0x00-0x1F or 0x7F-0x9F, both inclusive) or to a character in the
// basic source character set, the program is ill-formed.
if (CodePoint < 0xA0) {
// We don't use isLexingRawMode() here because we need to warn about bad
// UCNs even when skipping preprocessing tokens in a #if block.
if (Result && PP) {
if (CodePoint < 0x20 || CodePoint >= 0x7F)
Diag(BufferPtr, diag::err_ucn_control_character);
else {
char C = static_cast<char>(CodePoint);
Diag(BufferPtr, diag::err_ucn_escape_basic_scs) << StringRef(&C, 1);
}
}
return 0;
} else if (CodePoint >= 0xD800 && CodePoint <= 0xDFFF) {
// C++03 allows UCNs representing surrogate characters. C99 and C++11 don't.
// We don't use isLexingRawMode() here because we need to diagnose bad
// UCNs even when skipping preprocessing tokens in a #if block.
if (Result && PP) {
if (LangOpts.CPlusPlus && !LangOpts.CPlusPlus11)
Diag(BufferPtr, diag::warn_ucn_escape_surrogate);
else
Diag(BufferPtr, diag::err_ucn_escape_invalid);
}
return 0;
}
return CodePoint;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq (%rsi), %rsi
leaq 0x4(%rsp), %rdx
callq 0x1001274
movl %eax, %ecx
andb $-0x21, %al
cmpb $0x55, %al
jne 0x1000b68
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x1003930
jmp 0x1000b84
xorl %eax, %eax
cmpb $0x4e, %cl
jne 0x1000c25
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x1003d4e
btq $0x20, %rax
jb 0x1000b92
xorl %eax, %eax
jmp 0x1000c25
movabsq $0x100000000, %rdx # imm = 0x100000000
movq 0x88(%rbx), %rcx
movq (%rcx), %rcx
testq %rdx, %rcx
jne 0x1000c25
cmpl $0x9f, %eax
ja 0x1000be2
testq %r14, %r14
je 0x1000b8b
cmpq $0x0, 0x8(%rbx)
je 0x1000b8b
leal -0x7f(%rax), %ecx
cmpl $-0x60, %ecx
ja 0x1000c34
movq 0x98(%rbx), %rdx
leaq 0x78(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x4a1, %ecx # imm = 0x4A1
jmp 0x1000c82
movl %eax, %edx
andl $0xfffff800, %edx # imm = 0xFFFFF800
cmpl $0xd800, %edx # imm = 0xD800
jne 0x1000c25
testq %r14, %r14
je 0x1000b8b
cmpq $0x0, 0x8(%rbx)
je 0x1000b8b
andl $0xc00, %ecx # imm = 0xC00
movq 0x98(%rbx), %rdx
cmpl $0x400, %ecx # imm = 0x400
jne 0x1000c72
leaq 0x38(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x57d, %ecx # imm = 0x57D
jmp 0x1000c82
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x3(%rsp), %r15
movb %al, (%r15)
movq 0x98(%rbx), %rdx
leaq 0x58(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x4a2, %ecx # imm = 0x4A2
callq 0x1000436
leaq 0x8(%rsp), %rsi
movq %r15, (%rsi)
movq $0x1, 0x8(%rsi)
movq %r14, %rdi
callq 0x4a3d52
jmp 0x1000c87
leaq 0x18(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x4a4, %ecx # imm = 0x4A4
callq 0x1000436
movq %r14, %rdi
callq 0x4a3d6a
jmp 0x1000b8b
|
/Lex/Lexer.cpp
|
llvm::DenseMapBase<llvm::DenseMap<long, llvm::TinyPtrVector<clang::Module*>, llvm::DenseMapInfo<long, void>, llvm::detail::DenseMapPair<long, llvm::TinyPtrVector<clang::Module*>>>, long, llvm::TinyPtrVector<clang::Module*>, llvm::DenseMapInfo<long, void>, llvm::detail::DenseMapPair<long, llvm::TinyPtrVector<clang::Module*>>>::moveFromOldBuckets(llvm::detail::DenseMapPair<long, llvm::TinyPtrVector<clang::Module*>>*, llvm::detail::DenseMapPair<long, llvm::TinyPtrVector<clang::Module*>>*)
|
void moveFromOldBuckets(BucketT *OldBucketsBegin, BucketT *OldBucketsEnd) {
initEmpty();
// Insert all the old elements.
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
for (BucketT *B = OldBucketsBegin, *E = OldBucketsEnd; B != E; ++B) {
if (!KeyInfoT::isEqual(B->getFirst(), EmptyKey) &&
!KeyInfoT::isEqual(B->getFirst(), TombstoneKey)) {
// Insert the key/value into the new table.
BucketT *DestBucket;
bool FoundVal = LookupBucketFor(B->getFirst(), DestBucket);
(void)FoundVal; // silence warning.
assert(!FoundVal && "Key already in new map?");
DestBucket->getFirst() = std::move(B->getFirst());
::new (&DestBucket->getSecond()) ValueT(std::move(B->getSecond()));
incrementNumEntries();
// Free the value.
B->getSecond().~ValueT();
}
B->getFirst().~KeyT();
}
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x10154aa
addq $0x8, %r14
movabsq $0x7ffffffffffffffd, %r13 # imm = 0x7FFFFFFFFFFFFFFD
leaq 0x8(%rsp), %r12
leaq -0x8(%r14), %rsi
cmpq %rbx, %rsi
je 0x10167ba
cmpq %r13, (%rsi)
jg 0x10167b4
movq %r15, %rdi
movq %r12, %rdx
callq 0x10165ca
movq -0x8(%r14), %rax
movq 0x8(%rsp), %rcx
movq %rax, (%rcx)
movq (%r14), %rax
movq %rax, 0x8(%rcx)
andq $0x0, (%r14)
incl 0x8(%r15)
movq %r14, %rdi
callq 0xdbef0a
addq $0x10, %r14
jmp 0x1016778
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/llvm/ADT/DenseMap.h
|
(anonymous namespace)::PragmaUnsafeBufferUsageHandler::HandlePragma(clang::Preprocessor&, clang::PragmaIntroducer, clang::Token&)
|
void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
Token &FirstToken) override {
Token Tok;
PP.LexUnexpandedToken(Tok);
if (Tok.isNot(tok::identifier)) {
PP.Diag(Tok, diag::err_pp_pragma_unsafe_buffer_usage_syntax);
return;
}
IdentifierInfo *II = Tok.getIdentifierInfo();
SourceLocation Loc = Tok.getLocation();
if (II->isStr("begin")) {
if (PP.enterOrExitSafeBufferOptOutRegion(true, Loc))
PP.Diag(Loc, diag::err_pp_double_begin_pragma_unsafe_buffer_usage);
} else if (II->isStr("end")) {
if (PP.enterOrExitSafeBufferOptOutRegion(false, Loc))
PP.Diag(Loc, diag::err_pp_unmatched_end_begin_pragma_unsafe_buffer_usage);
} else
PP.Diag(Tok, diag::err_pp_pragma_unsafe_buffer_usage_syntax);
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %rbx
leaq 0x8(%rsp), %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x54f528
cmpw $0x5, 0x10(%r14)
jne 0x1034871
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x4f5f74
movq %rax, %r14
movl (%r15), %eax
movl %eax, 0x4(%rsp)
leaq 0x1782bd(%rip), %rsi # 0x11acaf8
movq %r14, %rdi
callq 0x633326
testb %al, %al
je 0x1034890
pushq $0x1
popq %rsi
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
callq 0x1039dfe
testb %al, %al
je 0x10348d7
movl 0x4(%rsp), %edx
leaq 0x60(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x455, %ecx # imm = 0x455
jmp 0x10348ca
leaq 0x80(%rsp), %r14
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
movl $0x48c, %ecx # imm = 0x48C
callq 0x6914c2
jmp 0x10348cf
leaq 0x2236c3(%rip), %rsi # 0x1257f5a
movq %r14, %rdi
callq 0x63334a
testb %al, %al
je 0x10348e4
leaq 0x4(%rsp), %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1039dfe
testb %al, %al
je 0x10348d7
movl 0x4(%rsp), %edx
leaq 0x40(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x493, %ecx # imm = 0x493
callq 0x4fda86
movq %r14, %rdi
callq 0x4a3d6a
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x20(%rsp), %r14
jmp 0x1034879
nop
|
/Lex/Pragma.cpp
|
clang::PreprocessingRecord::allocateSkippedRanges(unsigned int)
|
unsigned PreprocessingRecord::allocateSkippedRanges(unsigned NumRanges) {
unsigned Result = SkippedRanges.size();
SkippedRanges.resize(SkippedRanges.size() + NumRanges);
SkippedRangesAllLoaded = false;
return Result;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xa8(%rdi), %r14
subq 0xa0(%rdi), %r14
addq $0xa0, %rdi
sarq $0x3, %r14
movl %esi, %esi
addq %r14, %rsi
callq 0x10359d2
movb $0x0, 0xb8(%rbx)
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/Lex/PreprocessingRecord.cpp
|
clang::Preprocessor::getTotalMemory() const
|
size_t Preprocessor::getTotalMemory() const {
return BP.getTotalMemory()
+ llvm::capacity_in_bytes(MacroExpandedTokens)
+ Predefines.capacity() /* Predefines buffer. */
// FIXME: Include sizes from all submodules, and include MacroInfo sizes,
// and ModuleMacros.
+ llvm::capacity_in_bytes(CurSubmoduleState->Macros)
+ llvm::capacity_in_bytes(PragmaPushMacroInfo)
+ llvm::capacity_in_bytes(PoisonReasons)
+ llvm::capacity_in_bytes(CommentHandlers);
}
|
pushq %rbx
movq %rdi, %rbx
addq $0x80, %rdi
callq 0x792824
movq %rax, %rcx
movl 0x9a4(%rbx), %eax
imulq $0x18, %rax, %rax
addq %rcx, %rax
leaq 0x938(%rbx), %rcx
cmpq %rcx, 0x928(%rbx)
je 0x1037785
movq 0x938(%rbx), %rcx
jmp 0x1037788
pushq $0xf
popq %rcx
movq 0x698(%rbx), %rdx
movl 0x10(%rdx), %edx
movl 0x8e0(%rbx), %esi
shlq $0x5, %rsi
addq %rsi, %rax
addq %rcx, %rax
movl 0xbc0(%rbx), %ecx
addq %rdx, %rcx
shlq $0x4, %rcx
addq 0x2d8(%rbx), %rax
subq 0x2c8(%rbx), %rax
addq %rcx, %rax
popq %rbx
retq
|
/Lex/Preprocessor.cpp
|
clang::getOperatorSpelling(clang::OverloadedOperatorKind)
|
const char *clang::getOperatorSpelling(OverloadedOperatorKind Operator) {
switch (Operator) {
case OO_None:
case NUM_OVERLOADED_OPERATORS:
return nullptr;
#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
case OO_##Name: return Spelling;
#include "clang/Basic/OperatorKinds.def"
}
llvm_unreachable("Invalid OverloadedOperatorKind!");
}
|
movslq %edi, %rax
leaq 0x94db35(%rip), %rcx # 0x19bc250
movq (%rcx,%rax,8), %rax
retq
|
/Basic/IdentifierTable.cpp
|
clang::IdentifierTable::getFutureCompatDiagKind(clang::IdentifierInfo const&, clang::LangOptions const&)
|
diag::kind
IdentifierTable::getFutureCompatDiagKind(const IdentifierInfo &II,
const LangOptions &LangOpts) {
assert(II.isFutureCompatKeyword() && "diagnostic should not be needed");
unsigned Flags = llvm::StringSwitch<unsigned>(II.getName())
#define KEYWORD(NAME, FLAGS) .Case(#NAME, FLAGS)
#include "clang/Basic/TokenKinds.def"
#undef KEYWORD
;
if (LangOpts.CPlusPlus) {
if ((Flags & KEYCXX11) == KEYCXX11)
return diag::warn_cxx11_keyword;
// char8_t is not modeled as a CXX20_KEYWORD because it's not
// unconditionally enabled in C++20 mode. (It can be disabled
// by -fno-char8_t.)
if (((Flags & KEYCXX20) == KEYCXX20) ||
((Flags & CHAR8SUPPORT) == CHAR8SUPPORT))
return diag::warn_cxx20_keyword;
} else {
if ((Flags & KEYC99) == KEYC99)
return diag::warn_c99_keyword;
if ((Flags & KEYC23) == KEYC23)
return diag::warn_c23_keyword;
}
llvm_unreachable(
"Keyword not known to come from a newer Standard or proposed Standard");
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, 0x8(%rsp)
movq 0x10(%rsi), %rax
movl (%rax), %ecx
addq $0x10, %rax
leaq 0x10(%rsp), %rdi
movq %rax, (%rdi)
movq %rcx, 0x8(%rdi)
movb $0x0, 0x14(%rdi)
leaq 0x3b361a(%rip), %rsi # 0x1421de8
pushq $0x4
popq %r12
movq %r12, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x16ac45(%rip), %rsi # 0x11d942b
pushq $0x5
popq %r14
movq %rax, %rdi
movq %r14, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x43db46(%rip), %rsi # 0x14ac347
movq %rax, %rdi
movq %r12, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x221299(%rip), %rsi # 0x128fab1
movq %rax, %rdi
movq %r12, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x1638a6(%rip), %rsi # 0x11d20d5
movq %rax, %rdi
movq %r14, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x159201(%rip), %rsi # 0x11c7a47
pushq $0x8
popq %rdx
movq %rax, %rdi
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x3b954f(%rip), %rsi # 0x1427dac
pushq $0x7
popq %rdx
movq %rax, %rdi
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x3a4158(%rip), %rsi # 0x14129cc
pushq $0x2
popq %r15
movq %rax, %rdi
movq %r15, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x13920c(%rip), %rsi # 0x11a7a9b
pushq $0x6
popq %rbx
movq %rax, %rdi
movq %rbx, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x3cac09(%rip), %rsi # 0x14394b2
movq %rax, %rdi
movq %r12, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x1771e3(%rip), %rsi # 0x11e5aa3
movq %rax, %rdi
movq %r12, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x159568(%rip), %rsi # 0x11c7e3f
movq %rax, %rdi
movq %rbx, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x44ad32(%rip), %rsi # 0x14b9620
movq %rax, %rdi
movq %r14, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x161908(%rip), %rsi # 0x11d020d
pushq $0x3
popq %r13
movq %rax, %rdi
movq %r13, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x178c05(%rip), %rsi # 0x11e7525
movq %rax, %rdi
movq %r12, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x1a7088(%rip), %rsi # 0x12159bf
movq %rax, %rdi
movq %r15, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x2cf595(%rip), %rsi # 0x133dee3
movq %rax, %rdi
movq %r13, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x229dbf(%rip), %rsi # 0x1298724
movq %rax, %rdi
pushq $0x7
popq %rbp
movq %rbp, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x13a9a8(%rip), %rsi # 0x11a9327
movq %rax, %rdi
movq %rbp, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x221138(%rip), %rsi # 0x128face
movq %rax, %rdi
movq %r12, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x1665b3(%rip), %rsi # 0x11d4f60
movq %rax, %rdi
pushq $0x8
popq %r14
movq %r14, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x12c50b(%rip), %rsi # 0x119aed3
movq %rax, %rdi
movq %rbx, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x2210e0(%rip), %rsi # 0x128fabf
movq %rax, %rdi
pushq $0x5
popq %r13
movq %r13, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x153235(%rip), %rsi # 0x11c1c2f
movq %rax, %rdi
movq %rbx, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x229d21(%rip), %rsi # 0x1298732
movq %rax, %rdi
movq %rbx, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x229d04(%rip), %rsi # 0x129872c
pushq $0xc
popq %rdx
pushq $0x2
popq %r15
movq %rax, %rdi
movl %r15d, %ecx
callq 0x5100d4
leaq 0x21d31d(%rip), %rsi # 0x128bd5e
movq %rax, %rdi
movq %rbx, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x3d37cf(%rip), %rsi # 0x1442227
movq %rax, %rdi
movq %rbx, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x3d5326(%rip), %rsi # 0x1443d95
movq %rax, %rdi
movq %rbx, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x1fff36(%rip), %rsi # 0x126e9bc
movq %rax, %rdi
movq %rbp, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x1770ae(%rip), %rsi # 0x11e5b4b
movq %rax, %rdi
movq %r13, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x157a52(%rip), %rsi # 0x11c6506
movq %rax, %rdi
movq %r14, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x3d4e1c(%rip), %rsi # 0x14438e7
movq %rax, %rdi
movq %r12, %rdx
movq %r12, %rbx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x1a711b(%rip), %rsi # 0x1215c00
movq %rax, %rdi
movq %r14, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x178a23(%rip), %rsi # 0x11e751f
movq %rax, %rdi
movq %r13, %rdx
movq %r13, %r12
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x182903(%rip), %rsi # 0x11f1419
movq %rax, %rdi
movq %r14, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x1a7270(%rip), %rsi # 0x1215d9d
movq %rax, %rdi
movq %r14, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x20eca2(%rip), %rsi # 0x127d7e6
movq %rax, %rdi
movq %rbp, %rdx
movl $0x7fff7ff, %ecx # imm = 0x7FFF7FF
callq 0x5100d4
leaq 0x174d44(%rip), %rsi # 0x11e389f
movq %rax, %rdi
movq %r13, %rdx
movl $0x80, %ecx
callq 0x5100d4
leaq 0x1a7262(%rip), %rsi # 0x1215dd4
movq %rax, %rdi
movq %r14, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x229bb0(%rip), %rsi # 0x1298739
movq %rax, %rdi
movq %r14, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x1a723d(%rip), %rsi # 0x1215ddd
pushq $0xa
popq %rbp
movq %rax, %rdi
movq %rbp, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x1fcaa4(%rip), %rsi # 0x126b65e
pushq $0x9
popq %r13
movq %rax, %rdi
movq %r13, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x176410(%rip), %rsi # 0x11e4fe5
pushq $0xe
popq %rdx
movq %rax, %rdi
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x1824cd(%rip), %rsi # 0x11f10b9
pushq $0xd
popq %rdx
movq %rax, %rdi
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x13e4b1(%rip), %rsi # 0x11ad0b4
movq %rax, %rdi
movq %r14, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x210d26(%rip), %rsi # 0x127f940
movq %rax, %rdi
movq %rbp, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x210d1a(%rip), %rsi # 0x127f94b
movq %rax, %rdi
movq %r13, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x14c2be(%rip), %rsi # 0x11baf06
pushq $0xa
popq %rcx
movq %rax, %rdi
pushq $0x3
popq %rdx
callq 0x5100d4
leaq 0x21d129(%rip), %rsi # 0x128bd86
movq %rax, %rdi
movq %rbx, %rdx
movl $0x420, %ecx # imm = 0x420
callq 0x5100d4
leaq 0x42d338(%rip), %rsi # 0x149bfac
movq %rax, %rdi
movq %r12, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x1a6f70(%rip), %rsi # 0x1215bf9
movq %rax, %rdi
movq %r12, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x17743b(%rip), %rsi # 0x11e60d9
movq %rax, %rdi
movq %rbp, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x203bde(%rip), %rsi # 0x1272891
movq %rax, %rdi
pushq $0x6
popq %rbx
movq %rbx, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x177419(%rip), %rsi # 0x11e60e4
movq %rax, %rdi
pushq $0xc
popq %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x1b9e54(%rip), %rsi # 0x1228b34
movq %rax, %rdi
movq %r14, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x15897a(%rip), %rsi # 0x11c766f
movq %rax, %rdi
movq %rbx, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x1a700f(%rip), %rsi # 0x1215d19
movq %rax, %rdi
movq %r12, %rdx
movl $0x420, %ecx # imm = 0x420
callq 0x5100d4
leaq 0x21c8f7(%rip), %rsi # 0x128b618
movq %rax, %rdi
movq %rbx, %rdx
movq %rbx, %r12
movl %r15d, %ecx
callq 0x5100d4
leaq 0x2182a4(%rip), %rsi # 0x1286fdd
movq %rax, %rdi
pushq $0x7
popq %rbp
movq %rbp, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x443919(%rip), %rsi # 0x14b266a
movq %rax, %rdi
movq %r13, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x1a6e3a(%rip), %rsi # 0x1215ba0
movq %rax, %rdi
pushq $0x3
popq %rbx
movq %rbx, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x3cbfcb(%rip), %rsi # 0x143ad49
movq %rax, %rdi
movq %r14, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x21d4c7(%rip), %rsi # 0x128c25a
movq %rax, %rdi
movq %rbp, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x21d4bb(%rip), %rsi # 0x128c263
movq %rax, %rdi
movq %r13, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x21d4b1(%rip), %rsi # 0x128c26e
movq %rax, %rdi
movq %r12, %rdx
movq %r12, %r13
movl %r15d, %ecx
callq 0x5100d4
leaq 0x17731c(%rip), %rsi # 0x11e60f1
pushq $0x10
popq %rdx
movq %rax, %rdi
movl %r15d, %ecx
callq 0x5100d4
leaq 0x177318(%rip), %rsi # 0x11e6102
pushq $0xb
popq %rdx
movq %rax, %rdi
movl %r15d, %ecx
callq 0x5100d4
leaq 0x21cc32(%rip), %rsi # 0x128ba31
movq %rax, %rdi
movq %r14, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x1b64bc(%rip), %rsi # 0x12252d0
movq %rax, %rdi
pushq $0x4
popq %rbp
movq %rbp, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x42d7d4(%rip), %rsi # 0x149c600
movq %rax, %rdi
pushq $0x5
popq %r12
movq %r12, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x3b3b9f(%rip), %rsi # 0x14229e4
movq %rax, %rdi
movq %rbp, %rdx
movl $0x420, %ecx # imm = 0x420
callq 0x5100d4
leaq 0x1a6ff8(%rip), %rsi # 0x1215e54
movq %rax, %rdi
movq %rbx, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x1a6e35(%rip), %rsi # 0x1215ca6
movq %rax, %rdi
movq %r14, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x177288(%rip), %rsi # 0x11e610e
movq %rax, %rdi
movq %r13, %rbx
movq %r13, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x13c7e4(%rip), %rsi # 0x11ab682
movq %rax, %rdi
movq %r12, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x21d243(%rip), %rsi # 0x128c0f6
movq %rax, %rdi
pushq $0x7
popq %r13
movq %r13, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x138de3(%rip), %rsi # 0x11a7caf
movq %rax, %rdi
movq %r13, %rdx
movl $0x2000, %ecx # imm = 0x2000
callq 0x5100d4
leaq 0x1a6d27(%rip), %rsi # 0x1215c0a
pushq $0x1
popq %rcx
movq %rax, %rdi
movq %r14, %rdx
callq 0x5100d4
leaq 0x148a2a(%rip), %rsi # 0x11b7922
pushq $0xb
popq %rcx
movq %rax, %rdi
movq %rbx, %rdx
callq 0x5100d4
leaq 0x22b282(%rip), %rsi # 0x129a18f
movq %rax, %rdi
movq %r13, %rdx
movl $0x404, %ecx # imm = 0x404
callq 0x5100d4
leaq 0x217f75(%rip), %rsi # 0x1286e99
movq %rax, %rdi
movq %r13, %rdx
movl $0x404, %ecx # imm = 0x404
callq 0x5100d4
leaq 0x229c8f(%rip), %rsi # 0x1298bca
movq %rax, %rdi
movq %r14, %rdx
movl $0x804, %ecx # imm = 0x804
callq 0x5100d4
leaq 0x229c83(%rip), %rsi # 0x1298bd5
movq %rax, %rdi
movq %r14, %rdx
movl $0x804, %ecx # imm = 0x804
callq 0x5100d4
leaq 0x21c661(%rip), %rsi # 0x128b5ca
movq %rax, %rdi
pushq $0x9
popq %r12
movq %r12, %rdx
movl $0x404, %ecx # imm = 0x404
callq 0x5100d4
leaq 0x229b65(%rip), %rsi # 0x1298ae9
pushq $0x4
popq %rbp
movq %rax, %rdi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x5100d4
leaq 0x2038e5(%rip), %rsi # 0x1272880
movq %rax, %rdi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x5100d4
leaq 0x1a6d77(%rip), %rsi # 0x1215d26
movq %rax, %rdi
movq %r13, %rdx
movl $0x404, %ecx # imm = 0x404
callq 0x5100d4
leaq 0x22b1a2(%rip), %rsi # 0x129a168
movq %rax, %rdi
pushq $0xd
popq %rbp
movq %rbp, %rdx
movl $0x400404, %ecx # imm = 0x400404
callq 0x5100d4
leaq 0x22b1e1(%rip), %rsi # 0x129a1c1
movq %rax, %rdi
pushq $0xc
popq %rdx
movl $0x404, %ecx # imm = 0x404
callq 0x5100d4
leaq 0x3b2e3e(%rip), %rsi # 0x1421e35
movq %rax, %rdi
movq %r14, %rdx
movl $0x140000, %ecx # imm = 0x140000
callq 0x5100d4
leaq 0x17851c(%rip), %rsi # 0x11e752a
movq %rax, %rdi
movq %r12, %rdx
movl $0x140000, %ecx # imm = 0x140000
callq 0x5100d4
leaq 0x20e635(%rip), %rsi # 0x127d65a
movq %rax, %rdi
movq %r14, %rdx
movl $0x140000, %ecx # imm = 0x140000
callq 0x5100d4
leaq 0x149db0(%rip), %rsi # 0x11b8dec
movq %rax, %rdi
movq %rbx, %rdx
movl $0x80000, %ecx # imm = 0x80000
callq 0x5100d4
leaq 0x437fac(%rip), %rsi # 0x14a6fff
movq %rax, %rdi
movq %rbx, %rdx
movl $0x80000, %ecx # imm = 0x80000
callq 0x5100d4
leaq 0x21c56b(%rip), %rsi # 0x128b5d5
movq %rax, %rdi
movq %r12, %rdx
movl $0x100000, %ecx # imm = 0x100000
callq 0x5100d4
leaq 0x13c77d(%rip), %rsi # 0x11ab7fe
movq %rax, %rdi
movq %r12, %rdx
movl $0x100000, %ecx # imm = 0x100000
callq 0x5100d4
leaq 0x1a6be1(%rip), %rsi # 0x1215c79
movq %rax, %rdi
movq %r13, %rdx
movl $0x100000, %ecx # imm = 0x100000
callq 0x5100d4
leaq 0x177070(%rip), %rsi # 0x11e611f
movq %rax, %rdi
movq %r14, %rdx
movl $0x100000, %ecx # imm = 0x100000
callq 0x5100d4
leaq 0x143ec1(%rip), %rsi # 0x11b2f87
movq %rax, %rdi
movq %r13, %rdx
movl $0x8000, %ecx # imm = 0x8000
callq 0x5100d4
leaq 0x181ff4(%rip), %rsi # 0x11f10d1
movq %rax, %rdi
movq %r14, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x20ee29(%rip), %rsi # 0x127df1d
movq %rax, %rdi
movq %rbx, %r13
movq %rbx, %rdx
movl $0x408, %ecx # imm = 0x408
callq 0x5100d4
leaq 0x229a4b(%rip), %rsi # 0x1298b59
movq %rax, %rdi
movq %rbp, %rdx
movl $0x400, %ecx # imm = 0x400
callq 0x5100d4
leaq 0x220a32(%rip), %rsi # 0x128fb57
movq %rax, %rdi
movq %rbx, %rdx
movl $0x4000000, %ecx # imm = 0x4000000
callq 0x5100d4
leaq 0x220a94(%rip), %rsi # 0x128fbd0
movq %rax, %rdi
movq %rbx, %rdx
movl $0x4000000, %ecx # imm = 0x4000000
callq 0x5100d4
leaq 0x182120(%rip), %rsi # 0x11f1273
movq %rax, %rdi
pushq $0x4
popq %rdx
movl $0x4000000, %ecx # imm = 0x4000000
callq 0x5100d4
leaq 0x181f7b(%rip), %rsi # 0x11f10e5
movq %rax, %rdi
pushq $0xa
popq %rbp
movq %rbp, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x181f6c(%rip), %rsi # 0x11f10f0
movq %rax, %rdi
movq %rbp, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x181f60(%rip), %rsi # 0x11f10fb
movq %rax, %rdi
pushq $0xb
popq %rbx
movq %rbx, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x13df21(%rip), %rsi # 0x11ad0d6
movq %rax, %rdi
movq %r13, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x217ccd(%rip), %rsi # 0x1286e97
movq %rax, %rdi
movq %r12, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x229561(%rip), %rsi # 0x1298742
movq %rax, %rdi
movq %rbx, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x229556(%rip), %rsi # 0x129874e
pushq $0x15
popq %rdx
movq %rax, %rdi
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x229555(%rip), %rsi # 0x1298764
pushq $0x12
popq %r12
movq %rax, %rdi
movq %r12, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x205c0b(%rip), %rsi # 0x1274e35
movq %rax, %rdi
pushq $0xe
popq %rbx
movq %rbx, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x205c00(%rip), %rsi # 0x1274e44
pushq $0x13
popq %rdx
movq %rax, %rdi
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x205bfd(%rip), %rsi # 0x1274e58
movq %rax, %rdi
movq %r12, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x205bf9(%rip), %rsi # 0x1274e6b
pushq $0x11
popq %rdx
pushq $0x10
popq %rcx
movq %rax, %rdi
callq 0x5100d4
leaq 0x205bf6(%rip), %rsi # 0x1274e7d
movq %rax, %rdi
movq %rbx, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x205bee(%rip), %rsi # 0x1274e8c
movq %rax, %rdi
pushq $0x10
popq %rbx
movq %rbx, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x205be5(%rip), %rsi # 0x1274e9d
pushq $0x19
popq %r12
movq %rax, %rdi
movq %r12, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x2294a6(%rip), %rsi # 0x1298777
pushq $0x1c
popq %rdx
movq %rax, %rdi
movl $0x80, %ecx
callq 0x5100d4
leaq 0x2294ac(%rip), %rsi # 0x1298794
movq %rax, %rdi
movq %rbx, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x205646(%rip), %rsi # 0x1274945
movq %rax, %rdi
pushq $0xd
popq %r13
movq %r13, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x181dc0(%rip), %rsi # 0x11f10da
movq %rax, %rdi
movq %rbp, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x12fa91(%rip), %rsi # 0x119edc2
movq %rax, %rdi
movq %r14, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x1b3909(%rip), %rsi # 0x1222c51
movq %rax, %rdi
pushq $0x6
popq %rbp
movq %rbp, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x22078d(%rip), %rsi # 0x128faef
movq %rax, %rdi
movq %r14, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x22942c(%rip), %rsi # 0x12987a5
movq %rax, %rdi
pushq $0x9
popq %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x1b38ba(%rip), %rsi # 0x1222c4a
movq %rax, %rdi
movq %rbp, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x181d09(%rip), %rsi # 0x11f10b0
movq %rax, %rdi
movq %r14, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x2054ff(%rip), %rsi # 0x12748bd
movq %rax, %rdi
pushq $0xc
popq %rbx
movq %rbx, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x1a69ce(%rip), %rsi # 0x1215da6
movq %rax, %rdi
pushq $0x13
popq %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x181d3a(%rip), %rsi # 0x11f1129
movq %rax, %rdi
pushq $0xb
popq %rbp
movq %rbp, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x13dcd4(%rip), %rsi # 0x11ad0dd
movq %rax, %rdi
movq %r13, %rdx
pushq $0x10
popq %r14
movl %r14d, %ecx
callq 0x5100d4
leaq 0x2054a9(%rip), %rsi # 0x12748cb
movq %rax, %rdi
movq %rbp, %rdx
movl %r14d, %ecx
callq 0x5100d4
leaq 0x205485(%rip), %rsi # 0x12748bc
movq %rax, %rdi
movq %r13, %rdx
movl %r14d, %ecx
callq 0x5100d4
leaq 0x20547e(%rip), %rsi # 0x12748ca
movq %rax, %rdi
movq %rbx, %rdx
movq %rbx, %r13
movl %r14d, %ecx
callq 0x5100d4
leaq 0x1764b2(%rip), %rsi # 0x11e5916
pushq $0x14
popq %rdx
movq %rax, %rdi
movq %rdx, %rbx
movl %r14d, %ecx
callq 0x5100d4
leaq 0x17662c(%rip), %rsi # 0x11e5aa8
movq %rax, %rdi
movq %rbp, %rdx
movl %r14d, %ecx
callq 0x5100d4
leaq 0x176412(%rip), %rsi # 0x11e58a3
movq %rax, %rdi
pushq $0x11
popq %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x229307(%rip), %rsi # 0x12987af
pushq $0x1b
popq %rdx
movq %rax, %rdi
movl %r15d, %ecx
callq 0x5100d4
leaq 0x176521(%rip), %rsi # 0x11e59de
movq %rax, %rdi
movq %r12, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x1764d7(%rip), %rsi # 0x11e59ab
pushq $0x17
popq %rdx
movq %rax, %rdi
movl %r15d, %ecx
callq 0x5100d4
leaq 0x176382(%rip), %rsi # 0x11e586b
movq %rax, %rdi
pushq $0x12
popq %rbp
movq %rbp, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x1764c2(%rip), %rsi # 0x11e59c3
pushq $0x1a
popq %rdx
movq %rax, %rdi
movl %r15d, %ecx
callq 0x5100d4
leaq 0x1762ee(%rip), %rsi # 0x11e5804
pushq $0xf
popq %rdx
movq %rax, %rdi
movl %r15d, %ecx
callq 0x5100d4
leaq 0x2292a0(%rip), %rsi # 0x12987cb
movq %rax, %rdi
movq %r12, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x2292a5(%rip), %rsi # 0x12987e5
movq %rax, %rdi
movq %r12, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x2292aa(%rip), %rsi # 0x12987ff
pushq $0x1e
popq %rdx
movq %rax, %rdi
movl %r15d, %ecx
callq 0x5100d4
leaq 0x2292b4(%rip), %rsi # 0x129881e
movq %rax, %rdi
movq %rbx, %r14
movq %rbx, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x2292b1(%rip), %rsi # 0x1298833
movq %rax, %rdi
movq %rbp, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x2292af(%rip), %rsi # 0x1298846
movq %rax, %rdi
movq %r12, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x2292b4(%rip), %rsi # 0x1298860
movq %rax, %rdi
movq %rbx, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x2292b4(%rip), %rsi # 0x1298875
movq %rax, %rdi
movq %rbp, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x2292b2(%rip), %rsi # 0x1298888
movq %rax, %rdi
movq %r12, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x2292b7(%rip), %rsi # 0x12988a2
pushq $0x18
popq %rbp
movq %rax, %rdi
movq %rbp, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x2292b8(%rip), %rsi # 0x12988bb
movq %rax, %rdi
movq %rbp, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x1761b4(%rip), %rsi # 0x11e57cc
movq %rax, %rdi
pushq $0xd
popq %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x1761ad(%rip), %rsi # 0x11e57da
movq %rax, %rdi
pushq $0xe
popq %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x1761d2(%rip), %rsi # 0x11e5814
movq %rax, %rdi
movq %r13, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x1761dd(%rip), %rsi # 0x11e5834
movq %rax, %rdi
pushq $0xa
popq %rbx
movq %rbx, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x176220(%rip), %rsi # 0x11e588f
movq %rax, %rdi
pushq $0x13
popq %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x176231(%rip), %rsi # 0x11e58b5
movq %rax, %rdi
movq %rbx, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x176227(%rip), %rsi # 0x11e58c0
movq %rax, %rdi
pushq $0x9
popq %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x176230(%rip), %rsi # 0x11e58de
movq %rax, %rdi
movq %rbx, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x176268(%rip), %rsi # 0x11e592b
movq %rax, %rdi
movq %r13, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x176339(%rip), %rsi # 0x11e5a11
movq %rax, %rdi
pushq $0x8
popq %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x17633a(%rip), %rsi # 0x11e5a27
movq %rax, %rdi
pushq $0x10
popq %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x1763be(%rip), %rsi # 0x11e5ac0
movq %rax, %rdi
movq %r14, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x1763be(%rip), %rsi # 0x11e5ad5
movq %rax, %rdi
movq %r13, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x1763b6(%rip), %rsi # 0x11e5ae2
movq %rax, %rdi
movq %r12, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x1763bb(%rip), %rsi # 0x11e5afc
movq %rax, %rdi
pushq $0x1c
popq %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x1763c3(%rip), %rsi # 0x11e5b19
movq %rax, %rdi
pushq $0x17
popq %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x1763db(%rip), %rsi # 0x11e5b46
movq %rax, %rdi
movq %rbx, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x229166(%rip), %rsi # 0x12988e6
pushq $0x23
popq %rdx
movq %rax, %rdi
movl %r15d, %ecx
callq 0x5100d4
leaq 0x229175(%rip), %rsi # 0x129890a
pushq $0x16
popq %rbp
movq %rax, %rdi
movq %rbp, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x229174(%rip), %rsi # 0x1298921
pushq $0x25
popq %rdx
movq %rax, %rdi
movl %r15d, %ecx
callq 0x5100d4
leaq 0x18197e(%rip), %rsi # 0x11f1140
movq %rax, %rdi
movq %rbp, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x181980(%rip), %rsi # 0x11f1157
movq %rax, %rdi
pushq $0xd
popq %rbx
movq %rbx, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x181976(%rip), %rsi # 0x11f1165
movq %rax, %rdi
movq %rbp, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x181978(%rip), %rsi # 0x11f117c
movq %rax, %rdi
pushq $0x7
popq %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x18196b(%rip), %rsi # 0x11f1184
movq %rax, %rdi
movq %rbx, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x181964(%rip), %rsi # 0x11f1192
movq %rax, %rdi
pushq $0xf
popq %r14
movq %r14, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x18195b(%rip), %rsi # 0x11f11a2
movq %rax, %rdi
pushq $0x14
popq %rbp
movq %rbp, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x181958(%rip), %rsi # 0x11f11b7
movq %rax, %rdi
pushq $0xe
popq %r12
movq %r12, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x18194e(%rip), %rsi # 0x11f11c6
movq %rax, %rdi
pushq $0xb
popq %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x181945(%rip), %rsi # 0x11f11d2
movq %rax, %rdi
movq %r12, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x18193f(%rip), %rsi # 0x11f11e1
movq %rax, %rdi
movq %r14, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x18193a(%rip), %rsi # 0x11f11f1
movq %rax, %rdi
pushq $0x10
popq %r13
movq %r13, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x181932(%rip), %rsi # 0x11f1202
movq %rax, %rdi
movq %rbp, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x181932(%rip), %rsi # 0x11f1217
movq %rax, %rdi
pushq $0x11
popq %rbx
movq %rbx, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x18192c(%rip), %rsi # 0x11f1229
movq %rax, %rdi
movq %rbx, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x181929(%rip), %rsi # 0x11f123b
movq %rax, %rdi
movq %rbx, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x229020(%rip), %rsi # 0x1298947
movq %rax, %rdi
pushq $0x1a
popq %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x229026(%rip), %rsi # 0x1298962
pushq $0x22
popq %rdx
movq %rax, %rdi
movl %r15d, %ecx
callq 0x5100d4
leaq 0x175ed0(%rip), %rsi # 0x11e5821
movq %rax, %rdi
pushq $0x12
popq %rbx
movq %rbx, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x1761c8(%rip), %rsi # 0x11e5b31
movq %rax, %rdi
movq %rbp, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x17607a(%rip), %rsi # 0x11e59f8
movq %rax, %rdi
pushq $0xc
popq %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x176104(%rip), %rsi # 0x11e5a97
movq %rax, %rdi
movq %r13, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x17609f(%rip), %rsi # 0x11e5a47
movq %rax, %rdi
movq %rbx, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x228fc8(%rip), %rsi # 0x1298985
movq %rax, %rdi
movq %rbx, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x1761a5(%rip), %rsi # 0x11e5b77
movq %rax, %rdi
pushq $0x1e
popq %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x228fb1(%rip), %rsi # 0x1298998
movq %rax, %rdi
pushq $0x25
popq %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x228fc2(%rip), %rsi # 0x12989be
movq %rax, %rdi
pushq $0x23
popq %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x212cb6(%rip), %rsi # 0x12826c7
movq %rax, %rdi
xorl %edx, %edx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x228fbd(%rip), %rsi # 0x12989e2
movq %rax, %rdi
pushq $0x16
popq %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x175efc(%rip), %rsi # 0x11e5938
movq %rax, %rdi
movq %r13, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x176009(%rip), %rsi # 0x11e5a5a
movq %rax, %rdi
movq %r13, %rdx
movq %r13, %rbp
movl %r15d, %ecx
callq 0x5100d4
leaq 0x175d80(%rip), %rsi # 0x11e57e9
movq %rax, %rdi
movq %r14, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x175e4c(%rip), %rsi # 0x11e58ca
movq %rax, %rdi
pushq $0x13
popq %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x175e75(%rip), %rsi # 0x11e5908
movq %rax, %rdi
pushq $0xd
popq %r14
movq %r14, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x175d93(%rip), %rsi # 0x11e583f
movq %rax, %rdi
movq %rbx, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x17609e(%rip), %rsi # 0x11e5b5f
movq %rax, %rdi
pushq $0x9
popq %r13
movq %r13, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x175d1f(%rip), %rsi # 0x11e57f9
movq %rax, %rdi
pushq $0xa
popq %rbx
movq %rbx, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x175df7(%rip), %rsi # 0x11e58e9
movq %rax, %rdi
movq %r14, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x175f31(%rip), %rsi # 0x11e5a38
movq %rax, %rdi
pushq $0xe
popq %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x175e2d(%rip), %rsi # 0x11e5949
movq %rax, %rdi
pushq $0x15
popq %r12
movq %r12, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x175f36(%rip), %rsi # 0x11e5a6b
movq %rax, %rdi
movq %r12, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x175dad(%rip), %rsi # 0x11e58f7
movq %rax, %rdi
movq %rbp, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x175ea6(%rip), %rsi # 0x11e5a05
movq %rax, %rdi
pushq $0xb
popq %r12
movq %r12, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x175f13(%rip), %rsi # 0x11e5a8b
movq %rax, %rdi
movq %r12, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x175cc5(%rip), %rsi # 0x11e5852
movq %rax, %rdi
movq %r14, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x175e78(%rip), %rsi # 0x11e5a1a
movq %rax, %rdi
pushq $0xc
popq %rbp
movq %rbp, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x175dc2(%rip), %rsi # 0x11e597c
movq %rax, %rdi
pushq $0x1a
popq %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x175d90(%rip), %rsi # 0x11e595f
movq %rax, %rdi
pushq $0x1c
popq %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x175db3(%rip), %rsi # 0x11e5997
movq %rax, %rdi
pushq $0x13
popq %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x175c67(%rip), %rsi # 0x11e5860
movq %rax, %rdi
movq %rbx, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x175f5b(%rip), %rsi # 0x11e5b69
movq %rax, %rdi
movq %r14, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x175e91(%rip), %rsi # 0x11e5ab4
movq %rax, %rdi
movq %r12, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x175f19(%rip), %rsi # 0x11e5b51
movq %rax, %rdi
movq %r14, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x175e34(%rip), %rsi # 0x11e5a81
movq %rax, %rdi
movq %r13, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x175c1c(%rip), %rsi # 0x11e587e
movq %rax, %rdi
pushq $0x10
popq %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x228d82(%rip), %rsi # 0x12989f9
movq %rax, %rdi
pushq $0x18
popq %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x228d86(%rip), %rsi # 0x1298a12
movq %rax, %rdi
movq %rbp, %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x228d7e(%rip), %rsi # 0x1298a1f
movq %rax, %rdi
pushq $0xe
popq %rdx
movl %r15d, %ecx
callq 0x5100d4
leaq 0x13ab2b(%rip), %rsi # 0x11aa7e1
movq %rax, %rdi
pushq $0x12
popq %rbx
movq %rbx, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x21c412(%rip), %rsi # 0x128c0e2
movq %rax, %rdi
movq %rbx, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x228d54(%rip), %rsi # 0x1298a3b
pushq $0x24
popq %rdx
movq %rax, %rdi
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x174e8a(%rip), %rsi # 0x11e4b88
movq %rax, %rdi
pushq $0xa
popq %rbx
movq %rbx, %rdx
xorl %ecx, %ecx
callq 0x5100d4
leaq 0x1817eb(%rip), %rsi # 0x11f1500
movq %rax, %rdi
pushq $0x7
popq %r15
movq %r15, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x181bc6(%rip), %rsi # 0x11f18f6
movq %rax, %rdi
movq %r13, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x1818b4(%rip), %rsi # 0x11f15fb
movq %rax, %rdi
movq %rbx, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x181c27(%rip), %rsi # 0x11f1985
movq %rax, %rdi
movq %rbx, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x181b37(%rip), %rsi # 0x11f18ac
movq %rax, %rdi
movq %r13, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x181c2c(%rip), %rsi # 0x11f19b8
movq %rax, %rdi
movq %rbp, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x1814d5(%rip), %rsi # 0x11f1278
movq %rax, %rdi
movq %r14, %rdx
pushq $0x10
popq %rbp
movl %ebp, %ecx
callq 0x5100d4
leaq 0x1814ad(%rip), %rsi # 0x11f1267
movq %rax, %rdi
pushq $0xb
popq %r12
movq %r12, %rdx
movl %ebp, %ecx
callq 0x5100d4
leaq 0x212a02(%rip), %rsi # 0x12827d4
movq %rax, %rdi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x5100d4
leaq 0x181a5c(%rip), %rsi # 0x11f1842
movq %rax, %rdi
pushq $0x8
popq %r14
movq %r14, %rdx
movl $0x200200, %ecx # imm = 0x200200
callq 0x5100d4
leaq 0x181a53(%rip), %rsi # 0x11f1854
movq %rax, %rdi
movq %r15, %rdx
movl $0x200200, %ecx # imm = 0x200200
callq 0x5100d4
leaq 0x181a15(%rip), %rsi # 0x11f182d
movq %rax, %rdi
movq %rbx, %rdx
movl $0x200200, %ecx # imm = 0x200200
callq 0x5100d4
leaq 0x181a33(%rip), %rsi # 0x11f1862
movq %rax, %rdi
movq %r13, %rdx
movl $0x200200, %ecx # imm = 0x200200
callq 0x5100d4
leaq 0x1819f2(%rip), %rsi # 0x11f1838
movq %rax, %rdi
movq %r13, %rdx
movl $0x200200, %ecx # imm = 0x200200
callq 0x5100d4
leaq 0x1819ee(%rip), %rsi # 0x11f184b
movq %rax, %rdi
movq %r14, %rdx
movq %r14, %rbx
movl $0x200200, %ecx # imm = 0x200200
callq 0x5100d4
leaq 0x181990(%rip), %rsi # 0x11f1807
movq %rax, %rdi
movq %r12, %rdx
movq %r12, %r14
movl $0x200200, %ecx # imm = 0x200200
callq 0x5100d4
leaq 0x181982(%rip), %rsi # 0x11f1813
movq %rax, %rdi
pushq $0xc
popq %r12
movq %r12, %rdx
movl $0x200200, %ecx # imm = 0x200200
callq 0x5100d4
leaq 0x181974(%rip), %rsi # 0x11f1820
movq %rax, %rdi
movq %r12, %rdx
movl $0x200200, %ecx # imm = 0x200200
callq 0x5100d4
leaq 0x228b9d(%rip), %rsi # 0x1298a60
movq %rax, %rdi
pushq $0x10
popq %r15
movq %r15, %rdx
movl $0x200200, %ecx # imm = 0x200200
callq 0x5100d4
leaq 0x228b93(%rip), %rsi # 0x1298a71
movq %rax, %rdi
movq %rbx, %rdx
movl $0x220240, %ecx # imm = 0x220240
callq 0x5100d4
leaq 0x22007b(%rip), %rsi # 0x128ff70
movq %rax, %rdi
movq %r13, %rdx
movl $0x200200, %ecx # imm = 0x200200
callq 0x5100d4
leaq 0x22007b(%rip), %rsi # 0x128ff87
movq %rax, %rdi
pushq $0xf
popq %rbx
movq %rbx, %rdx
movl $0x200200, %ecx # imm = 0x200200
callq 0x5100d4
leaq 0x22007e(%rip), %rsi # 0x128ffa4
movq %rax, %rdi
movq %r15, %rdx
movl $0x200200, %ecx # imm = 0x200200
callq 0x5100d4
leaq 0x220085(%rip), %rsi # 0x128ffc2
movq %rax, %rdi
movq %r13, %rdx
movl $0x200200, %ecx # imm = 0x200200
callq 0x5100d4
leaq 0x220085(%rip), %rsi # 0x128ffd9
movq %rax, %rdi
movq %rbx, %rdx
movl $0x200200, %ecx # imm = 0x200200
callq 0x5100d4
leaq 0x22008b(%rip), %rsi # 0x128fff6
movq %rax, %rdi
movq %rbx, %rdx
movl $0x200200, %ecx # imm = 0x200200
callq 0x5100d4
leaq 0x220091(%rip), %rsi # 0x1290013
movq %rax, %rdi
pushq $0x15
popq %rdx
movl $0x200200, %ecx # imm = 0x200200
callq 0x5100d4
leaq 0x22009d(%rip), %rsi # 0x1290036
movq %rax, %rdi
pushq $0xe
popq %rbx
movq %rbx, %rdx
movl $0x200200, %ecx # imm = 0x200200
callq 0x5100d4
leaq 0x22009f(%rip), %rsi # 0x1290052
movq %rax, %rdi
pushq $0x14
popq %r15
movq %r15, %rdx
movl $0x200200, %ecx # imm = 0x200200
callq 0x5100d4
leaq 0x2200a6(%rip), %rsi # 0x1290074
movq %rax, %rdi
movq %r15, %rdx
movl $0x200200, %ecx # imm = 0x200200
callq 0x5100d4
leaq 0x2200b1(%rip), %rsi # 0x1290096
movq %rax, %rdi
pushq $0x1a
popq %rdx
movl $0x200200, %ecx # imm = 0x200200
callq 0x5100d4
leaq 0x2200c2(%rip), %rsi # 0x12900be
movq %rax, %rdi
movq %r13, %rdx
movl $0x200200, %ecx # imm = 0x200200
callq 0x5100d4
leaq 0x15e740(%rip), %rsi # 0x11ce753
movq %rax, %rdi
pushq $0x4
popq %r15
movq %r15, %rdx
movl $0x200200, %ecx # imm = 0x200200
callq 0x5100d4
leaq 0x17609c(%rip), %rsi # 0x11e60ca
movq %rax, %rdi
movq %rbx, %rdx
movl $0x200000, %ecx # imm = 0x200000
callq 0x5100d4
leaq 0x1816fb(%rip), %rsi # 0x11f1740
movq %rax, %rdi
movq %r12, %rdx
movl $0x1000000, %ecx # imm = 0x1000000
callq 0x5100d4
leaq 0x21c2bd(%rip), %rsi # 0x128c319
movq %rax, %rdi
pushq $0x7
popq %r12
movq %r12, %rdx
movl $0x2000000, %ecx # imm = 0x2000000
callq 0x5100d4
leaq 0x21c2ab(%rip), %rsi # 0x128c322
movq %rax, %rdi
movq %r12, %rdx
movl $0x2000000, %ecx # imm = 0x2000000
callq 0x5100d4
leaq 0x181595(%rip), %rsi # 0x11f1623
movq %rax, %rdi
movq %r14, %rdx
movl $0x2000000, %ecx # imm = 0x2000000
callq 0x5100d4
leaq 0x13d4cd(%rip), %rsi # 0x11ad572
movq %rax, %rdi
pushq $0x2
popq %rdx
movl $0x2000000, %ecx # imm = 0x2000000
callq 0x5100d4
leaq 0x174ba5(%rip), %rsi # 0x11e4c61
movq %rax, %rdi
pushq $0x5
popq %rbx
movq %rbx, %rdx
movl $0x2000000, %ecx # imm = 0x2000000
callq 0x5100d4
leaq 0x125fa0(%rip), %rsi # 0x1196076
movq %rax, %rdi
pushq $0x3
popq %rdx
movl $0x2000000, %ecx # imm = 0x2000000
callq 0x5100d4
leaq 0x22898d(%rip), %rsi # 0x1298a7a
pushq $0x21
popq %rdx
movq %rax, %rdi
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x18177d(%rip), %rsi # 0x11f1881
movq %rax, %rdi
pushq $0x8
popq %r14
movq %r14, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x21247b(%rip), %rsi # 0x128259a
movq %rax, %rdi
movq %r14, %rdx
movl $0x20040, %ecx # imm = 0x20040
callq 0x5100d4
leaq 0x181150(%rip), %rsi # 0x11f1286
pushq $0x40
popq %rcx
movq %rax, %rdi
movq %r12, %rdx
callq 0x5100d4
leaq 0x228951(%rip), %rsi # 0x1298a9c
movq %rax, %rdi
pushq $0x6
popq %r12
movq %r12, %rdx
movl $0x20040, %ecx # imm = 0x20040
callq 0x5100d4
leaq 0x2ce65e(%rip), %rsi # 0x133e7c4
movq %rax, %rdi
movq %r12, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x3f2251(%rip), %rsi # 0x14623ce
movq %rax, %rdi
movq %r15, %rdx
movl $0x4000, %ecx # imm = 0x4000
callq 0x5100d4
leaq 0x1a5b9a(%rip), %rsi # 0x1215d2e
movq %rax, %rdi
movq %r14, %rdx
movl $0x10000, %ecx # imm = 0x10000
callq 0x5100d4
leaq 0x1a5b8c(%rip), %rsi # 0x1215d37
movq %rax, %rdi
pushq $0x11
popq %r13
movq %r13, %rdx
movl $0x10000, %ecx # imm = 0x10000
callq 0x5100d4
leaq 0x175b9d(%rip), %rsi # 0x11e5d63
movq %rax, %rdi
movq %r13, %rdx
movl $0x10000, %ecx # imm = 0x10000
callq 0x5100d4
leaq 0x2288c6(%rip), %rsi # 0x1298aa3
movq %rax, %rdi
pushq $0xf
popq %r15
movq %r15, %rdx
movl $0x10000, %ecx # imm = 0x10000
callq 0x5100d4
leaq 0x1ac4ca(%rip), %rsi # 0x121c6c2
movq %rax, %rdi
pushq $0xb
popq %rdx
movl $0x10000, %ecx # imm = 0x10000
callq 0x5100d4
leaq 0x1ac4bf(%rip), %rsi # 0x121c6ce
movq %rax, %rdi
movq %r15, %rdx
movl $0x10000, %ecx # imm = 0x10000
callq 0x5100d4
leaq 0x20dcd8(%rip), %rsi # 0x127defe
movq %rax, %rdi
movq %r14, %rdx
movl $0x10000, %ecx # imm = 0x10000
callq 0x5100d4
leaq 0x2215da(%rip), %rsi # 0x1291817
movq %rax, %rdi
movq %r14, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x2215cd(%rip), %rsi # 0x1291821
movq %rax, %rdi
pushq $0x9
popq %r15
movq %r15, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x2215d0(%rip), %rsi # 0x129183f
movq %rax, %rdi
pushq $0x10
popq %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x2215a6(%rip), %rsi # 0x129182c
movq %rax, %rdi
movq %r13, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x181742(%rip), %rsi # 0x11f19df
movq %rax, %rdi
movq %r15, %rdx
movq %r15, %r13
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x221547(%rip), %rsi # 0x12917fe
movq %rax, %rdi
pushq $0x7
popq %r15
movq %r15, %rdx
movl %ebp, %ecx
callq 0x5100d4
leaq 0x221504(%rip), %rsi # 0x12917d3
movq %rax, %rdi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x5100d4
leaq 0x221524(%rip), %rsi # 0x1291807
movq %rax, %rdi
movq %r12, %rdx
movl %ebp, %ecx
callq 0x5100d4
leaq 0x221518(%rip), %rsi # 0x129180f
movq %rax, %rdi
movq %r12, %rdx
movl %ebp, %ecx
callq 0x5100d4
leaq 0x228886(%rip), %rsi # 0x1298b91
movq %rax, %rdi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x5100d4
leaq 0x20d179(%rip), %rsi # 0x127d498
movq %rax, %rdi
movq %r14, %rdx
movl $0x110, %ecx # imm = 0x110
callq 0x5100d4
leaq 0x228861(%rip), %rsi # 0x1298b97
movq %rax, %rdi
movq %rbx, %rdx
movl $0x110, %ecx # imm = 0x110
callq 0x5100d4
leaq 0x228850(%rip), %rsi # 0x1298b9d
movq %rax, %rdi
movq %r13, %rdx
movl $0x110, %ecx # imm = 0x110
callq 0x5100d4
leaq 0x1771d0(%rip), %rsi # 0x11e7534
movq %rax, %rdi
movq %r15, %rdx
movl $0x110, %ecx # imm = 0x110
callq 0x5100d4
leaq 0x2141a3(%rip), %rsi # 0x128451e
movq %rax, %rdi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x5100d4
leaq 0x1735e3(%rip), %rsi # 0x11e3972
movq %rax, %rdi
pushq $0xb
popq %r15
movq %r15, %rdx
movl %ebp, %ecx
callq 0x5100d4
leaq 0x1735d7(%rip), %rsi # 0x11e397e
movq %rax, %rdi
pushq $0xf
popq %r12
movq %r12, %rdx
movl %ebp, %ecx
callq 0x5100d4
leaq 0x1812bb(%rip), %rsi # 0x11f167a
movq %rax, %rdi
pushq $0x14
popq %rdx
movl %ebp, %ecx
callq 0x5100d4
leaq 0x1812bc(%rip), %rsi # 0x11f168f
movq %rax, %rdi
pushq $0x16
popq %rdx
movl %ebp, %ecx
callq 0x5100d4
leaq 0x1812bf(%rip), %rsi # 0x11f16a6
movq %rax, %rdi
pushq $0x15
popq %rdx
movl %ebp, %ecx
callq 0x5100d4
leaq 0x17481a(%rip), %rsi # 0x11e4c15
movq %rax, %rdi
movq %r15, %rdx
movl %ebp, %ecx
callq 0x5100d4
leaq 0x1a3c05(%rip), %rsi # 0x1214014
movq %rax, %rdi
pushq $0x17
popq %rbx
movq %rbx, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x1b27b7(%rip), %rsi # 0x1222be0
movq %rax, %rdi
pushq $0x18
popq %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x175ce8(%rip), %rsi # 0x11e6128
movq %rax, %rdi
pushq $0x12
popq %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x1e75d6(%rip), %rsi # 0x1257a2d
movq %rax, %rdi
pushq $0x13
popq %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x20d1f8(%rip), %rsi # 0x127d666
movq %rax, %rdi
pushq $0x21
popq %rdx
movl $0x800000, %ecx # imm = 0x800000
callq 0x5100d4
leaq 0x1747cd(%rip), %rsi # 0x11e4c52
movq %rax, %rdi
movq %r14, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x1747bf(%rip), %rsi # 0x11e4c5b
movq %rax, %rdi
movq %r15, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x180fe8(%rip), %rsi # 0x11f149b
movq %rax, %rdi
movq %rbx, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x17479d(%rip), %rsi # 0x11e4c67
movq %rax, %rdi
movq %r13, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x174790(%rip), %rsi # 0x11e4c71
movq %rax, %rdi
movq %r13, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x174783(%rip), %rsi # 0x11e4c7b
movq %rax, %rdi
movq %r12, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x2219af(%rip), %rsi # 0x1291ebe
movq %rax, %rdi
movq %r12, %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x22197c(%rip), %rsi # 0x1291ea2
movq %rax, %rdi
pushq $0x1a
popq %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
leaq 0x180d10(%rip), %rsi # 0x11f124d
movq %rax, %rdi
pushq $0x11
popq %rdx
movl $0x7ffe7ff, %ecx # imm = 0x7FFE7FF
callq 0x5100d4
movl 0x10(%rax), %ecx
movq 0x8(%rsp), %rax
testb $0x4, 0x1(%rax)
jne 0x1070568
andl $0x1, %ecx
leal (%rcx,%rcx,2), %eax
addl $0x51e, %eax # imm = 0x51E
jmp 0x1070577
movl $0x528, %eax # imm = 0x528
testb $0x4, %cl
jne 0x1070577
movl $0x52e, %eax # imm = 0x52E
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/Basic/IdentifierTable.cpp
|
clang::LangOptions::remapPathPrefix(llvm::SmallVectorImpl<char>&) const
|
void LangOptions::remapPathPrefix(SmallVectorImpl<char> &Path) const {
for (const auto &Entry : MacroPrefixMap)
if (llvm::sys::path::replace_path_prefix(Path, Entry.first, Entry.second))
break;
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x260(%rdi), %r15
addq $0x250, %r14 # imm = 0x250
cmpq %r14, %r15
je 0x1070e56
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
movq 0x40(%r15), %rcx
movq 0x48(%r15), %r8
movq %rbx, %rdi
xorl %r9d, %r9d
callq 0x481a65
testb %al, %al
jne 0x1070e56
movq %r15, %rdi
callq 0x4366e0
movq %rax, %r15
jmp 0x1070e25
popq %rbx
popq %r14
popq %r15
retq
|
/Basic/LangOptions.cpp
|
llvm::DenseMap<clang::FileID, std::unique_ptr<std::map<unsigned int, clang::SourceLocation, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, clang::SourceLocation>>>, std::default_delete<std::map<unsigned int, clang::SourceLocation, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, clang::SourceLocation>>>>>, llvm::DenseMapInfo<clang::FileID, void>, llvm::detail::DenseMapPair<clang::FileID, std::unique_ptr<std::map<unsigned int, clang::SourceLocation, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, clang::SourceLocation>>>, std::default_delete<std::map<unsigned int, clang::SourceLocation, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, clang::SourceLocation>>>>>>>::init(unsigned int)
|
void init(unsigned InitNumEntries) {
auto InitBuckets = BaseT::getMinBucketToReserveForEntries(InitNumEntries);
if (allocateBuckets(InitBuckets)) {
this->BaseT::initEmpty();
} else {
NumEntries = 0;
NumTombstones = 0;
}
}
|
pushq %rbx
movq %rdi, %rbx
callq 0x1081cfa
movq %rbx, %rdi
movl %eax, %esi
callq 0x1081d1c
testb %al, %al
je 0x1081cf2
movq %rbx, %rdi
popq %rbx
jmp 0x1081d4e
andq $0x0, 0x8(%rbx)
popq %rbx
retq
nop
|
/llvm/ADT/DenseMap.h
|
llvm::DenseMapBase<llvm::DenseMap<std::pair<clang::FileID, clang::FileID>, clang::InBeforeInTUCacheEntry, llvm::DenseMapInfo<std::pair<clang::FileID, clang::FileID>, void>, llvm::detail::DenseMapPair<std::pair<clang::FileID, clang::FileID>, clang::InBeforeInTUCacheEntry>>, std::pair<clang::FileID, clang::FileID>, clang::InBeforeInTUCacheEntry, llvm::DenseMapInfo<std::pair<clang::FileID, clang::FileID>, void>, llvm::detail::DenseMapPair<std::pair<clang::FileID, clang::FileID>, clang::InBeforeInTUCacheEntry>>::moveFromOldBuckets(llvm::detail::DenseMapPair<std::pair<clang::FileID, clang::FileID>, clang::InBeforeInTUCacheEntry>*, llvm::detail::DenseMapPair<std::pair<clang::FileID, clang::FileID>, clang::InBeforeInTUCacheEntry>*)
|
void moveFromOldBuckets(BucketT *OldBucketsBegin, BucketT *OldBucketsEnd) {
initEmpty();
// Insert all the old elements.
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
for (BucketT *B = OldBucketsBegin, *E = OldBucketsEnd; B != E; ++B) {
if (!KeyInfoT::isEqual(B->getFirst(), EmptyKey) &&
!KeyInfoT::isEqual(B->getFirst(), TombstoneKey)) {
// Insert the key/value into the new table.
BucketT *DestBucket;
bool FoundVal = LookupBucketFor(B->getFirst(), DestBucket);
(void)FoundVal; // silence warning.
assert(!FoundVal && "Key already in new map?");
DestBucket->getFirst() = std::move(B->getFirst());
::new (&DestBucket->getSecond()) ValueT(std::move(B->getSecond()));
incrementNumEntries();
// Free the value.
B->getSecond().~ValueT();
}
B->getFirst().~KeyT();
}
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x1081cb0
movq %rsp, %r12
cmpq %rbx, %r14
je 0x10829b7
movl (%r14), %eax
movl 0x4(%r14), %ecx
movl %eax, %edx
orl %ecx, %edx
je 0x10829b1
andl %ecx, %eax
cmpl $-0x1, %eax
je 0x10829b1
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x1082790
movq (%rsp), %rax
movl (%r14), %ecx
movl %ecx, (%rax)
movl 0x4(%r14), %ecx
movl %ecx, 0x4(%rax)
movq 0x18(%r14), %rcx
movq %rcx, 0x18(%rax)
movups 0x8(%r14), %xmm0
movups %xmm0, 0x8(%rax)
incl 0x8(%r15)
addq $0x20, %r14
jmp 0x1082965
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/llvm/ADT/DenseMap.h
|
bool llvm::is_contained<llvm::StringLiteral const (&) [3], llvm::StringRef>(llvm::StringLiteral const (&) [3], llvm::StringRef const&)
|
bool is_contained(R &&Range, const E &Element) {
if constexpr (detail::HasMemberContains<R, E>)
return Range.contains(Element);
else if constexpr (detail::HasMemberFind<R, E>)
return Range.find(Element) != Range.end();
else
return std::find(adl_begin(Range), adl_end(Range), Element) !=
adl_end(Range);
}
|
pushq %rbx
movq %rsi, %rdx
leaq 0x30(%rdi), %rbx
movq %rbx, %rsi
callq 0x10a847d
cmpq %rbx, %rax
setne %al
popq %rbx
retq
|
/llvm/ADT/STLExtras.h
|
clang::targets::WebAssembly64TargetInfo::~WebAssembly64TargetInfo()
|
class LLVM_LIBRARY_VISIBILITY WebAssembly64TargetInfo
: public WebAssemblyTargetInfo {
public:
explicit WebAssembly64TargetInfo(const llvm::Triple &T,
const TargetOptions &Opts)
: WebAssemblyTargetInfo(T, Opts) {
LongAlign = LongWidth = 64;
PointerAlign = PointerWidth = 64;
SizeType = UnsignedLong;
PtrDiffType = SignedLong;
IntPtrType = SignedLong;
if (T.isOSEmscripten())
resetDataLayout("e-m:e-p:64:64-p10:8:8-p20:8:8-i64:64-f128:64-n32:64-"
"S128-ni:1:10:20");
else
resetDataLayout(
"e-m:e-p:64:64-p10:8:8-p20:8:8-i64:64-n32:64-S128-ni:1:10:20");
}
|
pushq %rbx
movq %rdi, %rbx
callq 0x109b388
movl $0x220, %esi # imm = 0x220
movq %rbx, %rdi
popq %rbx
jmp 0x4360d0
nop
|
/Basic/Targets/WebAssembly.h
|
llvm::omp::getBestVariantMatchForContext(llvm::SmallVectorImpl<llvm::omp::VariantMatchInfo> const&, llvm::omp::OMPContext const&)
|
int llvm::omp::getBestVariantMatchForContext(
const SmallVectorImpl<VariantMatchInfo> &VMIs, const OMPContext &Ctx) {
APInt BestScore(64, 0);
int BestVMIIdx = -1;
const VariantMatchInfo *BestVMI = nullptr;
for (unsigned u = 0, e = VMIs.size(); u < e; ++u) {
const VariantMatchInfo &VMI = VMIs[u];
SmallVector<unsigned, 8> ConstructMatches;
// If the variant is not applicable its not the best.
if (!isVariantApplicableInContextHelper(VMI, Ctx, &ConstructMatches,
/* DeviceSetOnly */ false))
continue;
// Check if its clearly not the best.
APInt Score = getVariantMatchScore(VMI, Ctx, ConstructMatches);
if (Score.ult(BestScore))
continue;
// Equal score need subset checks.
if (Score.eq(BestScore)) {
// Strict subset are never best.
if (isStrictSubset(VMI, *BestVMI))
continue;
// Same score and the current best is no strict subset so we keep it.
if (!isStrictSubset(*BestVMI, VMI))
continue;
}
// New best found.
BestVMI = &VMI;
BestVMIIdx = u;
BestScore = Score;
}
return BestVMIIdx;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, 0x38(%rsp)
movq %rdi, %rbx
leaq 0x68(%rsp), %rsi
movl $0x40, 0x8(%rsi)
andq $0x0, (%rsi)
movq %rsi, %rdi
callq 0x468540
movq %rbx, 0x30(%rsp)
movl 0x8(%rbx), %eax
movq %rax, 0x40(%rsp)
pushq $-0x1
popq %rax
movl %eax, (%rsp)
xorl %r12d, %r12d
leaq 0x88(%rsp), %r14
leaq 0x58(%rsp), %r13
leaq 0x4(%rsp), %rbp
leaq 0x78(%rsp), %rbx
xorl %eax, %eax
cmpq 0x40(%rsp), %r12
je 0x10c3d53
movq %rax, 0x8(%rsp)
imulq $0x170, %r12, %r15 # imm = 0x170
movq 0x30(%rsp), %rax
addq (%rax), %r15
leaq 0x98(%rsp), %rax
movq %rax, 0x88(%rsp)
movabsq $0x800000000, %rax # imm = 0x800000000
movq %rax, 0x90(%rsp)
movq %r15, %rdi
movq 0x38(%rsp), %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x10c37fa
testl %eax, %eax
je 0x10c3d3e
movq %r12, 0x18(%rsp)
movl $0x40, 0x60(%rsp)
pushq $0x1
popq %rax
movq %rax, 0x58(%rsp)
movq %rax, %r12
movq %r13, %rdi
callq 0x468540
movb 0xe0(%r15), %r14b
movq %r15, %rdi
callq 0x10c6ae4
movq %rax, 0x48(%rsp)
movl %edx, 0x50(%rsp)
leal 0x2(%r14), %ecx
movq %r12, %rsi
movq %r12, %rax
shlq %cl, %rax
movq %rax, 0x10(%rsp)
leaq 0x108(%r15), %r12
leal 0x1(%r14), %ecx
movq %rsi, %rax
shlq %cl, %rax
movq %rax, 0x28(%rsp)
movq %rsi, %rax
movl %r14d, %ecx
shlq %cl, %rax
movq %rax, 0x20(%rsp)
movq %r15, %rax
cmpl $-0x1, %edx
je 0x10c3c8f
movl %edx, 0x4(%rsp)
movq %r12, %rdi
movq %rbp, %rsi
callq 0x10c6b2e
testl %eax, %eax
je 0x10c3c25
movq %rbx, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0x10c6b3a
cmpl $0x41, 0x80(%rsp)
movq %rbx, %rax
jb 0x10c3c10
movq 0x78(%rsp), %rax
movq (%rax), %rsi
movq %r13, %rdi
callq 0x4921c4
movq %rbx, %rdi
callq 0x468360
jmp 0x10c3c3f
movl 0x4(%rsp), %r14d
movl %r14d, %edi
callq 0x10c3ef7
cmpl $0x4, %eax
ja 0x10c3c4f
pushq $0x1a
popq %rcx
btl %eax, %ecx
jae 0x10c3c4f
leaq 0x48(%rsp), %rdi
callq 0x10c6b0c
movl 0x50(%rsp), %edx
jmp 0x10c3bd1
cmpl $0xb, %r14d
je 0x10c3c3f
movl %r14d, %edi
callq 0x10c4125
cmpl $0xc, %eax
je 0x10c3c80
cmpl $0x7, %eax
je 0x10c3c76
cmpl $0x6, %eax
jne 0x10c3c3f
movq %r13, %rdi
movq 0x20(%rsp), %rsi
jmp 0x10c3c88
movq %r13, %rdi
movq 0x28(%rsp), %rsi
jmp 0x10c3c88
movq %r13, %rdi
movq 0x10(%rsp), %rsi
callq 0x4921c4
jmp 0x10c3c3f
movl 0xe0(%rax), %r14d
shlq $0x2, %r14
xorl %r12d, %r12d
cmpq %r12, %r14
je 0x10c3cc2
movq 0x88(%rsp), %rax
movb (%rax,%r12), %cl
pushq $0x1
popq %rsi
shlq %cl, %rsi
movq %r13, %rdi
callq 0x4921c4
addq $0x4, %r12
jmp 0x10c3c9d
movq %r13, %rdi
leaq 0x68(%rsp), %r14
movq %r14, %rsi
callq 0x49390c
testb %al, %al
je 0x10c3cdd
movq 0x18(%rsp), %r12
jmp 0x10c3d2e
movq %r13, %rdi
movq %r14, %rsi
callq 0x492baa
testb %al, %al
movq 0x18(%rsp), %r12
je 0x10c3d1a
movq %r15, %rdi
movq %r15, 0x10(%rsp)
movq 0x8(%rsp), %rsi
callq 0x10c3d72
testb %al, %al
jne 0x10c3d2e
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x10c3d72
testb %al, %al
je 0x10c3d2e
movq %r14, %rdi
movq %r13, %rsi
callq 0x492952
movq %r15, 0x8(%rsp)
movl %r12d, (%rsp)
movq %r13, %rdi
callq 0x468360
leaq 0x88(%rsp), %r14
movq %r14, %rdi
callq 0x468820
incq %r12
movq 0x8(%rsp), %rax
jmp 0x10c3b08
leaq 0x68(%rsp), %rdi
callq 0x468360
movl (%rsp), %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/Frontend/OpenMP/OMPContext.cpp
|
void llvm::cl::ValuesClass::apply<llvm::cl::opt<llvm::GVDAGType, false, llvm::cl::parser<llvm::GVDAGType>>>(llvm::cl::opt<llvm::GVDAGType, false, llvm::cl::parser<llvm::GVDAGType>>&) const
|
void apply(Opt &O) const {
for (const auto &Value : Values)
O.getParser().addLiteralOption(Value.Name, Value.Value,
Value.Description);
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq (%rdi), %r14
movl 0x8(%rdi), %eax
addq $0x98, %rbx
imulq $0x28, %rax, %r15
testq %r15, %r15
je 0x10cb91d
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x10(%r14), %rcx
movq 0x18(%r14), %r8
movq 0x20(%r14), %r9
movq %rbx, %rdi
callq 0x10cb924
addq $0x28, %r14
addq $-0x28, %r15
jmp 0x10cb8f3
popq %rbx
popq %r14
popq %r15
retq
nop
|
/llvm/Support/CommandLine.h
|
llvm::cl::opt<bool, false, llvm::cl::parser<bool>>::opt<char [44], llvm::cl::OptionHidden, llvm::cl::desc, llvm::cl::initializer<bool>>(char const (&) [44], llvm::cl::OptionHidden const&, llvm::cl::desc const&, llvm::cl::initializer<bool> const&)
|
explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
xorl %esi, %esi
xorl %edx, %edx
callq 0x453f88
movb $0x0, 0x80(%r14)
andq $0x0, 0x90(%r14)
leaq 0x8279b8(%rip), %rax # 0x18f7298
addq $0x10, %rax
movq %rax, 0x88(%r14)
leaq 0x827e8e(%rip), %rax # 0x18f7780
addq $0x10, %rax
movq %rax, (%r14)
leaq 0x827bf8(%rip), %rax # 0x18f74f8
addq $0x10, %rax
movq %rax, 0x98(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0xa0(%r14)
leaq -0xc7b79d(%rip), %rax # 0x454180
movq %rax, 0xb8(%r14)
leaq -0xc7b7a9(%rip), %rax # 0x454182
movq %rax, 0xb0(%r14)
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x10cfef6
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x456a0c
nop
|
/llvm/Support/CommandLine.h
|
llvm::InstrProfSymtab::InstrProfSymtab()
|
InstrProfSymtab() : VTableAddrMap(VTableAddrMapAllocator) {}
|
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x1c(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movl $0x8, 0x2c(%rdi)
movups %xmm0, 0x30(%rdi)
movabsq $0x800000000, %rax # imm = 0x800000000
movq %rax, 0x40(%rdi)
addq $0x78, %rdi
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x58(%rbx)
movups %xmm0, 0x68(%rbx)
xorl %esi, %esi
callq 0x10d529e
leaq 0xa8(%rbx), %rax
leaq 0xd0(%rbx), %rcx
xorps %xmm0, %xmm0
movups %xmm0, 0xb0(%rbx)
movups %xmm0, 0xa0(%rbx)
movups %xmm0, 0x90(%rbx)
movq %rcx, 0xc0(%rbx)
movabsq $0x400000000, %rcx # imm = 0x400000000
movq %rcx, 0xc8(%rbx)
leaq 0x100(%rbx), %rcx
movq %rcx, 0xf0(%rbx)
movups %xmm0, 0xf8(%rbx)
movq $0x1, 0x108(%rbx)
andq $0x0, 0x170(%rbx)
movq %rax, 0x178(%rbx)
movups %xmm0, 0x110(%rbx)
movups %xmm0, 0x120(%rbx)
movups %xmm0, 0x130(%rbx)
movups %xmm0, 0x140(%rbx)
movups %xmm0, 0x150(%rbx)
movups %xmm0, 0x160(%rbx)
movb $0x0, 0x180(%rbx)
popq %rbx
retq
|
/llvm/ProfileData/InstrProf.h
|
llvm::InstrProfReader::error(llvm::instrprof_error, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
Error error(instrprof_error Err, const std::string &ErrMsg = "") {
LastError = Err;
LastErrorMsg = ErrMsg;
if (Err == instrprof_error::success)
return Error::success();
return make_error<InstrProfError>(Err, ErrMsg);
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movl %edx, %ebp
movq %rdi, %rbx
movl %edx, 0xc(%rsp)
movl %edx, 0x8(%rsi)
leaq 0x10(%rsi), %rdi
movq %rcx, %rsi
callq 0x4367b0
testl %ebp, %ebp
je 0x10d3709
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x10d551c
jmp 0x10d370d
andq $0x0, (%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
|
/llvm/ProfileData/InstrProfReader.h
|
llvm::OnDiskIterableChainedHashTable<llvm::memprof::FrameLookupTrait>::Create(unsigned char const*, unsigned char const*, unsigned char const*, llvm::memprof::FrameLookupTrait const&)
|
static OnDiskIterableChainedHashTable *
Create(const unsigned char *Buckets, const unsigned char *const Payload,
const unsigned char *const Base, const Info &InfoObj = Info()) {
assert(Buckets > Base);
auto NumBucketsAndEntries =
OnDiskIterableChainedHashTable<Info>::readNumBucketsAndEntries(Buckets);
return new OnDiskIterableChainedHashTable<Info>(
NumBucketsAndEntries.first, NumBucketsAndEntries.second,
Buckets, Payload, Base, InfoObj);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x10(%rdi), %r12
pushq $0x30
popq %rdi
callq 0x436820
movups (%r15), %xmm0
movups %xmm0, (%rax)
movq %r12, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq %r14, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/llvm/Support/OnDiskHashTable.h
|
llvm::cl::opt<int, false, llvm::cl::parser<int>>::opt<char [28], llvm::cl::OptionHidden, llvm::cl::initializer<int>, llvm::cl::desc>(char const (&) [28], llvm::cl::OptionHidden const&, llvm::cl::initializer<int> const&, llvm::cl::desc const&)
|
explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
xorl %esi, %esi
xorl %edx, %edx
callq 0x453f88
andl $0x0, 0x80(%r14)
andq $0x0, 0x90(%r14)
leaq 0x80c616(%rip), %rax # 0x18f7a58
addq $0x10, %rax
movq %rax, 0x88(%r14)
leaq 0x80c25c(%rip), %rax # 0x18f76b0
addq $0x10, %rax
movq %rax, (%r14)
leaq 0x80c0f6(%rip), %rax # 0x18f7558
addq $0x10, %rax
movq %rax, 0x98(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0xa0(%r14)
leaq -0x217b5(%rip), %rax # 0x10c9cca
movq %rax, 0xb8(%r14)
leaq -0x217c1(%rip), %rax # 0x10c9ccc
movq %rax, 0xb0(%r14)
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x10eba7e
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x456a0c
nop
|
/llvm/Support/CommandLine.h
|
llvm::MachO::swapStruct(llvm::MachO::mach_header_64&)
|
[[nodiscard]] constexpr T byteswap(T V) noexcept {
if constexpr (sizeof(T) == 1) {
return V;
} else if constexpr (sizeof(T) == 2) {
uint16_t UV = V;
#if defined(_MSC_VER) && !defined(_DEBUG)
// The DLL version of the runtime lacks these functions (bug!?), but in a
// release build they're replaced with BSWAP instructions anyway.
return _byteswap_ushort(UV);
#else
uint16_t Hi = UV << 8;
uint16_t Lo = UV >> 8;
return Hi | Lo;
#endif
} else if constexpr (sizeof(T) == 4) {
uint32_t UV = V;
#if __has_builtin(__builtin_bswap32)
return __builtin_bswap32(UV);
#elif defined(_MSC_VER) && !defined(_DEBUG)
return _byteswap_ulong(UV);
#else
uint32_t Byte0 = UV & 0x000000FF;
uint32_t Byte1 = UV & 0x0000FF00;
uint32_t Byte2 = UV & 0x00FF0000;
uint32_t Byte3 = UV & 0xFF000000;
return (Byte0 << 24) | (Byte1 << 8) | (Byte2 >> 8) | (Byte3 >> 24);
#endif
} else if constexpr (sizeof(T) == 8) {
uint64_t UV = V;
#if __has_builtin(__builtin_bswap64)
return __builtin_bswap64(UV);
#elif defined(_MSC_VER) && !defined(_DEBUG)
return _byteswap_uint64(UV);
#else
uint64_t Hi = llvm::byteswap<uint32_t>(UV);
uint32_t Lo = llvm::byteswap<uint32_t>(UV >> 32);
return (Hi << 32) | Lo;
#endif
} else {
static_assert(!sizeof(T *), "Don't know how to handle the given type.");
return 0;
}
}
|
movdqu (%rdi), %xmm0
movdqu 0x10(%rdi), %xmm1
pxor %xmm2, %xmm2
movdqa %xmm0, %xmm3
punpckhbw %xmm2, %xmm3 # xmm3 = xmm3[8],xmm2[8],xmm3[9],xmm2[9],xmm3[10],xmm2[10],xmm3[11],xmm2[11],xmm3[12],xmm2[12],xmm3[13],xmm2[13],xmm3[14],xmm2[14],xmm3[15],xmm2[15]
pshuflw $0x1b, %xmm3, %xmm3 # xmm3 = xmm3[3,2,1,0,4,5,6,7]
pshufhw $0x1b, %xmm3, %xmm3 # xmm3 = xmm3[0,1,2,3,7,6,5,4]
punpcklbw %xmm2, %xmm0 # xmm0 = xmm0[0],xmm2[0],xmm0[1],xmm2[1],xmm0[2],xmm2[2],xmm0[3],xmm2[3],xmm0[4],xmm2[4],xmm0[5],xmm2[5],xmm0[6],xmm2[6],xmm0[7],xmm2[7]
pshuflw $0x1b, %xmm0, %xmm0 # xmm0 = xmm0[3,2,1,0,4,5,6,7]
pshufhw $0x1b, %xmm0, %xmm0 # xmm0 = xmm0[0,1,2,3,7,6,5,4]
packuswb %xmm3, %xmm0
movdqu %xmm0, (%rdi)
movdqa %xmm1, %xmm0
punpckhbw %xmm2, %xmm0 # xmm0 = xmm0[8],xmm2[8],xmm0[9],xmm2[9],xmm0[10],xmm2[10],xmm0[11],xmm2[11],xmm0[12],xmm2[12],xmm0[13],xmm2[13],xmm0[14],xmm2[14],xmm0[15],xmm2[15]
pshuflw $0x1b, %xmm0, %xmm0 # xmm0 = xmm0[3,2,1,0,4,5,6,7]
pshufhw $0x1b, %xmm0, %xmm0 # xmm0 = xmm0[0,1,2,3,7,6,5,4]
punpcklbw %xmm2, %xmm1 # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1],xmm1[2],xmm2[2],xmm1[3],xmm2[3],xmm1[4],xmm2[4],xmm1[5],xmm2[5],xmm1[6],xmm2[6],xmm1[7],xmm2[7]
pshuflw $0x1b, %xmm1, %xmm1 # xmm1 = xmm1[3,2,1,0,4,5,6,7]
pshufhw $0x1b, %xmm1, %xmm1 # xmm1 = xmm1[0,1,2,3,7,6,5,4]
packuswb %xmm0, %xmm1
movdqu %xmm1, 0x10(%rdi)
retq
|
/llvm/ADT/bit.h
|
llvm::object::WasmObjectFile::parseExportSection(llvm::object::WasmObjectFile::ReadContext&)
|
Error WasmObjectFile::parseExportSection(ReadContext &Ctx) {
uint32_t Count = readVaruint32(Ctx);
Exports.reserve(Count);
Symbols.reserve(Count);
for (uint32_t I = 0; I < Count; I++) {
wasm::WasmExport Ex;
Ex.Name = readString(Ctx);
Ex.Kind = readUint8(Ctx);
Ex.Index = readVaruint32(Ctx);
const wasm::WasmSignature *Signature = nullptr;
const wasm::WasmGlobalType *GlobalType = nullptr;
const wasm::WasmTableType *TableType = nullptr;
wasm::WasmSymbolInfo Info;
Info.Name = Ex.Name;
Info.Flags = 0;
switch (Ex.Kind) {
case wasm::WASM_EXTERNAL_FUNCTION: {
if (!isDefinedFunctionIndex(Ex.Index))
return make_error<GenericBinaryError>("invalid function export",
object_error::parse_failed);
getDefinedFunction(Ex.Index).ExportName = Ex.Name;
Info.Kind = wasm::WASM_SYMBOL_TYPE_FUNCTION;
Info.ElementIndex = Ex.Index;
unsigned FuncIndex = Info.ElementIndex - NumImportedFunctions;
wasm::WasmFunction &Function = Functions[FuncIndex];
Signature = &Signatures[Function.SigIndex];
break;
}
case wasm::WASM_EXTERNAL_GLOBAL: {
if (!isValidGlobalIndex(Ex.Index))
return make_error<GenericBinaryError>("invalid global export",
object_error::parse_failed);
Info.Kind = wasm::WASM_SYMBOL_TYPE_DATA;
uint64_t Offset = 0;
if (isDefinedGlobalIndex(Ex.Index)) {
auto Global = getDefinedGlobal(Ex.Index);
if (!Global.InitExpr.Extended) {
auto Inst = Global.InitExpr.Inst;
if (Inst.Opcode == wasm::WASM_OPCODE_I32_CONST) {
Offset = Inst.Value.Int32;
} else if (Inst.Opcode == wasm::WASM_OPCODE_I64_CONST) {
Offset = Inst.Value.Int64;
}
}
}
Info.DataRef = wasm::WasmDataReference{0, Offset, 0};
break;
}
case wasm::WASM_EXTERNAL_TAG:
if (!isValidTagIndex(Ex.Index))
return make_error<GenericBinaryError>("invalid tag export",
object_error::parse_failed);
Info.Kind = wasm::WASM_SYMBOL_TYPE_TAG;
Info.ElementIndex = Ex.Index;
break;
case wasm::WASM_EXTERNAL_MEMORY:
break;
case wasm::WASM_EXTERNAL_TABLE:
Info.Kind = wasm::WASM_SYMBOL_TYPE_TABLE;
Info.ElementIndex = Ex.Index;
break;
default:
return make_error<GenericBinaryError>("unexpected export kind",
object_error::parse_failed);
}
Exports.push_back(Ex);
if (Ex.Kind != wasm::WASM_EXTERNAL_MEMORY) {
Symbols.emplace_back(Info, GlobalType, TableType, Signature);
LLVM_DEBUG(dbgs() << "Adding symbol: " << Symbols.back() << "\n");
}
}
if (Ctx.Ptr != Ctx.End)
return make_error<GenericBinaryError>("export section ended prematurely",
object_error::parse_failed);
return Error::success();
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, 0x8(%rsp)
movq %rdx, %rdi
callq 0x10fe406
movl %eax, %ebp
leaq 0x1a8(%r13), %r12
movl %eax, %ebx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1101b50
leaq 0x218(%r13), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x11000aa
movq %r13, 0x18(%rsp)
movq %r15, 0x10(%rsp)
subl $0x1, %ebp
jb 0x10fdbfb
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq %r14, %rdi
callq 0x10fe426
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq %r14, %rdi
callq 0x10fe680
movb %al, 0x30(%rsp)
movq %r14, %rdi
callq 0x10fe406
andq $0x0, 0x38(%rsp)
movl %eax, %ebx
andq $0x0, 0x48(%rsp)
movl %eax, 0x34(%rsp)
andq $0x0, 0x40(%rsp)
xorl %eax, %eax
movb %al, 0x78(%rsp)
movb %al, 0x90(%rsp)
movb %al, 0xa8(%rsp)
movaps 0x20(%rsp), %xmm0
movaps %xmm0, 0x50(%rsp)
andl $0x0, 0x64(%rsp)
movzbl 0x30(%rsp), %eax
cmpq $0x4, %rax
ja 0x10fdc37
leaq 0x32a208(%rip), %rcx # 0x1427c5c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
movl %ebx, %ecx
jmpq *%rax
movq %r13, %rdi
movl %ebx, %esi
callq 0x10fec96
testb %al, %al
je 0x10fdc9a
movl 0x290(%r13), %eax
subl %eax, %ebx
movq 0x200(%r13), %rax
shlq $0x7, %rbx
movaps 0x20(%rsp), %xmm0
movups %xmm0, 0x40(%rax,%rbx)
cmpb $0x0, 0x50(%rax,%rbx)
jne 0x10fdaa1
addq %rbx, %rax
addq $0x40, %rax
movb $0x1, 0x10(%rax)
movb $0x0, 0x60(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0xb0(%rsp)
subl 0x290(%r13), %eax
movq 0x200(%r13), %rcx
shlq $0x7, %rax
movl 0x4(%rcx,%rax), %eax
shlq $0x6, %rax
addq 0x118(%r13), %rax
movq %rax, 0x38(%rsp)
jmp 0x10fdb93
movl 0x294(%r13), %esi
movq 0x180(%r13), %rax
subq 0x178(%r13), %rax
cqto
pushq $0x18
popq %rdi
idivq %rdi
addq %rsi, %rax
cmpq %rcx, %rax
jbe 0x10fdc79
movb $0x4, 0x60(%rsp)
jmp 0x10fdb11
movb $0x5, 0x60(%rsp)
movl %ebx, 0xb0(%rsp)
jmp 0x10fdb93
movq %r12, %r15
movq %r13, %rdi
movl 0x288(%r13), %r13d
movq 0x160(%rdi), %r12
movq 0x168(%rdi), %rax
subq %r12, %rax
cqto
pushq $0x48
popq %rsi
idivq %rsi
addq %r13, %rax
cmpq %rcx, %rax
jbe 0x10fdc58
movb $0x1, 0x60(%rsp)
movl %ebx, %esi
callq 0x10fece4
testb %al, %al
je 0x10fdb6b
subl %r13d, %ebx
imulq $0x48, %rbx, %rax
cmpb $0x0, 0x8(%r12,%rax)
je 0x10fdbcc
xorl %eax, %eax
movq %r15, %r12
movq 0x18(%rsp), %r13
movq 0x10(%rsp), %r15
andl $0x0, 0xb0(%rsp)
movq %rax, 0xb8(%rsp)
andq $0x0, 0xc0(%rsp)
movq %r12, %rdi
leaq 0x20(%rsp), %rsi
callq 0x1101c38
cmpb $0x2, 0x30(%rsp)
je 0x10fd9cc
movq %r15, %rdi
leaq 0x50(%rsp), %rsi
leaq 0x48(%rsp), %rdx
leaq 0x40(%rsp), %rcx
leaq 0x38(%rsp), %r8
callq 0x10fed36
jmp 0x10fd9cc
leaq (%r12,%rax), %rcx
movq 0x18(%r12,%rax), %rax
movzbl 0x10(%rcx), %ecx
cmpl $0x42, %ecx
movq 0x18(%rsp), %r13
je 0x10fdbef
cmpl $0x41, %ecx
movq %r15, %r12
jne 0x10fdbf4
cltq
jmp 0x10fdb75
movq %r15, %r12
jmp 0x10fdb75
xorl %eax, %eax
jmp 0x10fdb75
movq 0x8(%r14), %rax
cmpq 0x10(%r14), %rax
je 0x10fdc29
leaq 0x50(%rsp), %rdx
movl $0x3, (%rdx)
leaq 0x32ab03(%rip), %rsi # 0x142871a
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x10fe457
jmp 0x10fdcb9
movq 0x8(%rsp), %rbx
andq $0x0, (%rbx)
jmp 0x10fdcb9
leaq 0x4(%rsp), %rdx
movl $0x3, (%rdx)
leaq 0x32aaba(%rip), %rsi # 0x1428703
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x10ffbfe
jmp 0x10fdcb9
leaq 0x4(%rsp), %rdx
movl $0x3, (%rdx)
leaq 0x32aa70(%rip), %rsi # 0x14286da
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x1100ff3
jmp 0x10fdcb9
leaq 0x4(%rsp), %rdx
movl $0x3, (%rdx)
leaq 0x32aa65(%rip), %rsi # 0x14286f0
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x1101c15
jmp 0x10fdcb9
leaq 0x4(%rsp), %rdx
movl $0x3, (%rdx)
leaq 0x32aa16(%rip), %rsi # 0x14286c2
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x1100326
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/Object/WasmObjectFile.cpp
|
llvm::AsmToken::getStringContents() const
|
[[nodiscard]] StringRef slice(size_t Start, size_t End) const {
Start = std::min(Start, Length);
End = std::clamp(End, Start, Length);
return StringRef(Data + Start, End - Start);
}
|
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
xorl %esi, %esi
movq %rcx, %rdi
addq $-0x1, %rdi
setb %sil
adcq $0x0, %rax
cmpq %rsi, %rdi
pushq $0x1
popq %rdx
cmovaeq %rdi, %rdx
cmpq %rcx, %rdx
cmovaeq %rcx, %rdx
subq %rsi, %rdx
retq
|
/llvm/ADT/StringRef.h
|
bool llvm::function_ref<bool ()>::callback_fn<(anonymous namespace)::AsmParser::parseDirectiveAscii(llvm::StringRef, bool)::$_0>(long)
|
static Ret callback_fn(intptr_t callable, Params ...params) {
return (*reinterpret_cast<Callable*>(callable))(
std::forward<Params>(params)...);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq (%rdi), %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x108(%rax)
movb $0x1, %bpl
testb %al, %al
jne 0x113509d
leaq 0x8(%rsp), %r15
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *0xd0(%rax)
testb %al, %al
jne 0x113509d
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x38(%rax)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq (%rax), %rcx
movq %rax, %rdi
callq *0x1f0(%rcx)
movq 0x8(%r14), %rax
movb (%rax), %al
testb %al, %al
jne 0x1135078
movq %rbx, %rdi
callq 0x114022c
cmpl $0x3, (%rax)
je 0x1135029
movq 0x8(%r14), %rax
movb (%rax), %al
testb $0x1, %al
je 0x113509b
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x38(%rax)
movq (%rax), %rcx
leaq 0x305d8c(%rip), %rsi # 0x143ae1b
pushq $0x1
popq %rdx
movq %rax, %rdi
callq *0x1f0(%rcx)
xorl %ebp, %ebp
leaq 0x8(%rsp), %rdi
callq 0x436d30
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/llvm/ADT/STLFunctionalExtras.h
|
llvm::APFloat::getNaN(llvm::fltSemantics const&, bool, unsigned long)
|
static APFloat getNaN(const fltSemantics &Sem, bool Negative = false,
uint64_t payload = 0) {
if (payload) {
APInt intPayload(64, payload);
return getQNaN(Sem, Negative, &intPayload);
} else {
return getQNaN(Sem, Negative, nullptr);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
testq %rcx, %rcx
je 0x1135759
leaq 0x8(%rsp), %r15
movl $0x40, 0x8(%r15)
movq %rcx, (%r15)
movq %r15, %rdi
callq 0x468540
movzbl %bpl, %edx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0xe7b740
movq %r15, %rdi
callq 0x468360
jmp 0x113576a
movzbl %bpl, %edx
movq %rbx, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0xe7b740
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/llvm/ADT/APFloat.h
|
llvm::AsmRewrite& llvm::SmallVectorTemplateBase<llvm::AsmRewrite, true>::growAndEmplaceBack<llvm::AsmRewriteKind, llvm::SMLoc&, long>(llvm::AsmRewriteKind&&, llvm::SMLoc&, long&&)
|
T &growAndEmplaceBack(ArgTypes &&... Args) {
// Use push_back with a copy in case Args has an internal reference,
// side-stepping reference invalidation problems without losing the realloc
// optimization.
push_back(T(std::forward<ArgTypes>(Args)...));
return this->back();
}
|
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
movl (%rsi), %eax
movq (%rdx), %rdx
movl (%rcx), %ecx
movq %rsp, %rsi
movl %eax, (%rsi)
movq %rdx, 0x8(%rsi)
movl %ecx, 0x10(%rsi)
xorl %eax, %eax
movb %al, 0x14(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rsi)
movups %xmm0, 0x48(%rsi)
movups %xmm0, 0x58(%rsi)
andq $0x0, 0x68(%rsi)
movups %xmm0, 0x18(%rsi)
movups %xmm0, 0x21(%rsi)
movl $0x1, 0x70(%rsi)
movb %al, 0x78(%rsi)
callq 0x1132ade
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
shlq $0x7, %rcx
addq %rcx, %rax
addq $-0x80, %rax
addq $0x80, %rsp
popq %rbx
retq
|
/llvm/ADT/SmallVector.h
|
(anonymous namespace)::AsmParser::applyModifierToExpr(llvm::MCExpr const*, llvm::MCSymbolRefExpr::VariantKind)
|
const MCExpr *
AsmParser::applyModifierToExpr(const MCExpr *E,
MCSymbolRefExpr::VariantKind Variant) {
// Ask the target implementation about this expression first.
const MCExpr *NewE = getTargetParser().applyModifierToExpr(E, Variant, Ctx);
if (NewE)
return NewE;
// Recurse over the given expression, rebuilding it to apply the given variant
// if there is exactly one symbol.
switch (E->getKind()) {
case MCExpr::Target:
case MCExpr::Constant:
return nullptr;
case MCExpr::SymbolRef: {
const MCSymbolRefExpr *SRE = cast<MCSymbolRefExpr>(E);
if (SRE->getKind() != MCSymbolRefExpr::VK_None) {
TokError("invalid variant on expression '" + getTok().getIdentifier() +
"' (already modified)");
return E;
}
return MCSymbolRefExpr::create(&SRE->getSymbol(), Variant, getContext());
}
case MCExpr::Unary: {
const MCUnaryExpr *UE = cast<MCUnaryExpr>(E);
const MCExpr *Sub = applyModifierToExpr(UE->getSubExpr(), Variant);
if (!Sub)
return nullptr;
return MCUnaryExpr::create(UE->getOpcode(), Sub, getContext());
}
case MCExpr::Binary: {
const MCBinaryExpr *BE = cast<MCBinaryExpr>(E);
const MCExpr *LHS = applyModifierToExpr(BE->getLHS(), Variant);
const MCExpr *RHS = applyModifierToExpr(BE->getRHS(), Variant);
if (!LHS && !RHS)
return nullptr;
if (!LHS)
LHS = BE->getLHS();
if (!RHS)
RHS = BE->getRHS();
return MCBinaryExpr::create(BE->getOpcode(), LHS, RHS, getContext());
}
}
llvm_unreachable("Invalid expression kind!");
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq 0xe0(%rbx), %rcx
movq (%rdi), %rax
callq *0xa8(%rax)
testq %rax, %rax
jne 0x1138416
movzbl (%r14), %eax
leaq 0x30060d(%rip), %rcx # 0x1438a18
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorl %eax, %eax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%r14), %rsi
movzwl %bp, %edx
movq %rbx, %rdi
callq 0x11383d0
testq %rax, %rax
je 0x1138414
movq %rax, %r15
movl $0xffffff, %ebp # imm = 0xFFFFFF
andl 0x1(%r14), %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
movl %ebp, %edi
movq %r15, %rsi
movq %rax, %rdx
xorl %ecx, %ecx
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x114b626
movq 0x10(%r14), %rsi
movzwl %bp, %ebp
movq %rbx, %rdi
movl %ebp, %edx
callq 0x11383d0
movq %rax, %r15
movq 0x18(%r14), %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x11383d0
movq %rax, %r12
movq %r15, %rax
orq %r12, %rax
je 0x1138414
testq %r15, %r15
jne 0x11384a7
movq 0x10(%r14), %r15
testq %r12, %r12
jne 0x11384b0
movq 0x18(%r14), %r12
movl $0xffffff, %ebp # imm = 0xFFFFFF
andl 0x1(%r14), %ebp
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
movl %ebp, %edi
movq %r15, %rsi
movq %r12, %rdx
movq %rax, %rcx
xorl %r8d, %r8d
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x114b5d6
cmpw $0x0, 0x1(%r14)
je 0x1138552
movq %rbx, %rdi
callq 0x114022c
movq %rax, %rdi
callq 0x1135c4c
leaq 0x30(%rsp), %rsi
movw $0x503, 0x20(%rsi) # imm = 0x503
leaq 0x302723(%rip), %rcx # 0x143ac31
movq %rcx, (%rsi)
movq %rax, 0x10(%rsi)
movq %rdx, 0x18(%rsi)
leaq 0x302731(%rip), %rax # 0x143ac51
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movw $0x103, 0x20(%rdx) # imm = 0x103
leaq 0x58(%rsp), %r15
movq %r15, %rdi
callq 0x4539cc
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x1140486
movq %r14, %rax
jmp 0x1138416
movq 0x10(%r14), %r14
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
movzwl %bp, %esi
movq %r14, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x114b6ce
|
/MC/MCParser/AsmParser.cpp
|
bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::COFFAsmParser, &(anonymous namespace)::COFFAsmParser::ParseDirectiveSafeSEH(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)
|
static bool HandleDirective(MCAsmParserExtension *Target,
StringRef Directive,
SMLoc DirectiveLoc) {
T *Obj = static_cast<T*>(Target);
return (Obj->*Handler)(Directive, DirectiveLoc);
}
|
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0xc0(%rax)
testb %al, %al
je 0x1139831
leaq 0x30013e(%rip), %rax # 0x143996d
jmp 0x113989c
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x8(%rax), %rax
cmpl $0x9, (%rax)
jne 0x1139895
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
leaq 0x10(%rsp), %rsi
movw $0x105, 0x20(%rsi) # imm = 0x105
movaps (%rsp), %xmm0
movups %xmm0, (%rsi)
movq %rax, %rdi
callq 0x1146000
movq %rax, %r14
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0xb8(%rax)
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq (%rax), %rcx
movq %rax, %rdi
movq %r14, %rsi
callq *0x158(%rcx)
xorl %eax, %eax
jmp 0x11398b2
leaq 0x2ffe80(%rip), %rax # 0x143971c
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movw $0x103, 0x20(%rsi) # imm = 0x103
movq %rbx, %rdi
callq 0x1138cb2
addq $0x38, %rsp
popq %rbx
popq %r14
retq
|
/llvm/MC/MCParser/MCAsmParserExtension.h
|
bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::ELFAsmParser, &(anonymous namespace)::ELFAsmParser::ParseDirectivePopSection(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc)
|
static bool HandleDirective(MCAsmParserExtension *Target,
StringRef Directive,
SMLoc DirectiveLoc) {
T *Obj = static_cast<T*>(Target);
return (Obj->*Handler)(Directive, DirectiveLoc);
}
|
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, %rdi
callq 0x115479c
testb %al, %al
je 0x113f386
xorl %eax, %eax
jmp 0x113f3a3
leaq 0x2fbd3c(%rip), %rax # 0x143b0c9
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movw $0x103, 0x20(%rsi) # imm = 0x103
movq %rbx, %rdi
callq 0x1138cb2
addq $0x30, %rsp
popq %rbx
retq
nop
|
/llvm/MC/MCParser/MCAsmParserExtension.h
|
bool llvm::DenseMapBase<llvm::DenseMap<unsigned int, llvm::MCCVFunctionInfo::LineInfo, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::MCCVFunctionInfo::LineInfo>>, unsigned int, llvm::MCCVFunctionInfo::LineInfo, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::MCCVFunctionInfo::LineInfo>>::LookupBucketFor<unsigned int>(unsigned int const&, llvm::detail::DenseMapPair<unsigned int, llvm::MCCVFunctionInfo::LineInfo> const*&) const
|
unsigned getNumBuckets() const {
return NumBuckets;
}
|
movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x114444c
pushq %rbx
movq (%rdi), %rdi
movl (%rsi), %esi
imull $0x25, %esi, %r8d
decl %ecx
movl $0x1, %r10d
xorl %r9d, %r9d
andl %ecx, %r8d
movq %r8, %rax
shlq $0x4, %rax
leaq (%rdi,%rax), %r11
movl (%rdi,%rax), %ebx
movb $0x1, %al
cmpl %ebx, %esi
je 0x114445c
cmpl $-0x1, %ebx
je 0x1144453
testq %r9, %r9
cmovneq %r9, %r11
cmpl $-0x2, %ebx
cmoveq %r11, %r9
addl %r10d, %r8d
incl %r10d
jmp 0x114441a
xorl %r11d, %r11d
xorl %eax, %eax
jmp 0x114445d
testq %r9, %r9
cmovneq %r9, %r11
xorl %eax, %eax
popq %rbx
movq %r11, (%rdx)
retq
nop
|
/llvm/ADT/DenseMap.h
|
llvm::MCContext::recordELFMergeableSectionInfo(llvm::StringRef, unsigned int, unsigned int, unsigned int)
|
void MCContext::recordELFMergeableSectionInfo(StringRef SectionName,
unsigned Flags, unsigned UniqueID,
unsigned EntrySize) {
bool IsMergeable = Flags & ELF::SHF_MERGE;
if (UniqueID == GenericSectionID) {
ELFSeenGenericMergeableSections.insert(SectionName);
// Minor performance optimization: avoid hash map lookup in
// isELFGenericMergeableSection, which will return true for SectionName.
IsMergeable = true;
}
// For mergeable sections or non-mergeable sections with a generic mergeable
// section name we enter their Unique ID into the ELFEntrySizeMap so that
// compatible globals can be assigned to the same section.
if (IsMergeable || isELFGenericMergeableSection(SectionName)) {
ELFEntrySizeMap.insert(std::make_pair(
std::make_tuple(SectionName, Flags, EntrySize), UniqueID));
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %r9d, %ebp
movl %r8d, %ebx
movl %ecx, %r15d
movq %rdi, %r14
movq %rsi, (%rsp)
movq %rdx, 0x8(%rsp)
cmpl $-0x1, %r8d
je 0x11471eb
testb $0x10, %r15b
jne 0x11471ff
movq %r14, %rdi
callq 0x1147234
testb %al, %al
jne 0x11471ff
jmp 0x1147229
leaq 0x968(%r14), %rsi
leaq 0x10(%rsp), %rdi
movq %rsp, %rdx
callq 0x46702a
addq $0x950, %r14 # imm = 0x950
movups (%rsp), %xmm0
leaq 0x10(%rsp), %rdx
movups %xmm0, 0x8(%rdx)
movl %ebp, (%rdx)
movl %r15d, 0x4(%rdx)
movl %ebx, 0x18(%rdx)
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x1147270
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/MC/MCContext.cpp
|
llvm::detail::DenseMapPair<std::pair<unsigned int, unsigned int>, llvm::MCSymbol*>* llvm::DenseMapBase<llvm::DenseMap<std::pair<unsigned int, unsigned int>, llvm::MCSymbol*, llvm::DenseMapInfo<std::pair<unsigned int, unsigned int>, void>, llvm::detail::DenseMapPair<std::pair<unsigned int, unsigned int>, llvm::MCSymbol*>>, std::pair<unsigned int, unsigned int>, llvm::MCSymbol*, llvm::DenseMapInfo<std::pair<unsigned int, unsigned int>, void>, llvm::detail::DenseMapPair<std::pair<unsigned int, unsigned int>, llvm::MCSymbol*>>::InsertIntoBucketImpl<std::pair<unsigned int, unsigned int>>(std::pair<unsigned int, unsigned int> const&, std::pair<unsigned int, unsigned int> const&, llvm::detail::DenseMapPair<std::pair<unsigned int, unsigned int>, llvm::MCSymbol*>*)
|
BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
BucketT *TheBucket) {
incrementEpoch();
// If the load of the hash table is more than 3/4, or if fewer than 1/8 of
// the buckets are empty (meaning that many are filled with tombstones),
// grow the table.
//
// The later case is tricky. For example, if we had one empty bucket with
// tons of tombstones, failing lookups (e.g. for insertion) would have to
// probe almost the entire table until it found the empty bucket. If the
// table completely filled with tombstones, no lookup would ever succeed,
// causing infinite loops in lookup.
unsigned NewNumEntries = getNumEntries() + 1;
unsigned NumBuckets = getNumBuckets();
if (LLVM_UNLIKELY(NewNumEntries * 4 >= NumBuckets * 3)) {
this->grow(NumBuckets * 2);
LookupBucketFor(Lookup, TheBucket);
NumBuckets = getNumBuckets();
} else if (LLVM_UNLIKELY(NumBuckets-(NewNumEntries+getNumTombstones()) <=
NumBuckets/8)) {
this->grow(NumBuckets);
LookupBucketFor(Lookup, TheBucket);
}
assert(TheBucket);
// Only update the state after we've grown our bucket space appropriately
// so that when growing buckets we have self-consistent entry count.
incrementNumEntries();
// If we are writing over a tombstone, remember this.
const KeyT EmptyKey = getEmptyKey();
if (!KeyInfoT::isEqual(TheBucket->getFirst(), EmptyKey))
decrementNumTombstones();
return TheBucket;
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movq %rcx, (%rsp)
movl 0x8(%rdi), %eax
movl 0x10(%rdi), %esi
leal 0x4(,%rax,4), %ecx
leal (%rsi,%rsi,2), %edx
cmpl %edx, %ecx
jae 0x1149567
notl %eax
addl %esi, %eax
subl 0xc(%rbx), %eax
movl %esi, %ecx
shrl $0x3, %ecx
cmpl %ecx, %eax
jbe 0x1149569
incl 0x8(%rbx)
movq (%rsp), %rax
cmpl $-0x1, (%rax)
jne 0x114955c
cmpl $-0x1, 0x4(%rax)
je 0x114955f
decl 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
addl %esi, %esi
movq %rbx, %rdi
callq 0x1149582
movq %rsp, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x114941a
jmp 0x114954a
nop
|
/llvm/ADT/DenseMap.h
|
split(llvm::StringRef, char, std::pair<llvm::StringRef, llvm::StringRef>&)
|
static Error split(StringRef Str, char Separator,
std::pair<StringRef, StringRef> &Split) {
assert(!Str.empty() && "parse error, string can't be empty here");
Split = Str.split(Separator);
if (Split.second.empty() && Split.first != Str)
return reportError("Trailing separator in datalayout string");
if (!Split.second.empty() && Split.first.empty())
return reportError("Expected token before separator in datalayout string");
return Error::success();
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %r8, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
movl %ecx, %edx
callq 0x45ac2e
movups (%r15), %xmm0
movups %xmm0, (%r14)
movups 0x10(%r15), %xmm0
movups %xmm0, 0x10(%r14)
cmpq $0x0, 0x18(%r14)
je 0x1158d27
cmpq $0x0, 0x8(%r14)
je 0x1158d4a
andq $0x0, (%rbx)
jmp 0x1158d67
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x476ce5
testb %al, %al
je 0x1158d74
leaq 0x2efe34(%rip), %rax # 0x1448b7c
jmp 0x1158d51
leaq 0x2efe53(%rip), %rax # 0x1448ba4
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
movw $0x103, 0x20(%rsi) # imm = 0x103
movq %rbx, %rdi
callq 0x1158dcc
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
cmpq $0x0, 0x18(%r14)
jne 0x1158d1a
jmp 0x1158d21
|
/IR/DataLayout.cpp
|
llvm::Error getIntInBytes<unsigned int>(llvm::StringRef, unsigned int&)
|
static Error getIntInBytes(StringRef R, IntTy &Result) {
if (Error Err = getInt<IntTy>(R, Result))
return Err;
if (Result % 8)
return reportError("number of bits must be a byte width multiple");
Result /= 8;
return Error::success();
}
|
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdi, %rbx
callq 0x1158d7d
cmpq $0x0, (%rbx)
jne 0x1158e39
movl (%r14), %eax
testb $0x7, %al
je 0x1158e2f
leaq 0x2efdf1(%rip), %rax # 0x1448c0a
movq %rsp, %rsi
movq %rax, (%rsi)
movw $0x103, 0x20(%rsi) # imm = 0x103
movq %rbx, %rdi
callq 0x1158dcc
jmp 0x1158e39
shrl $0x3, %eax
movl %eax, (%r14)
andq $0x0, (%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
|
/IR/DataLayout.cpp
|
getAddrSpace(llvm::StringRef, unsigned int&)
|
static Error getAddrSpace(StringRef R, unsigned &AddrSpace) {
if (Error Err = getInt(R, AddrSpace))
return Err;
if (!isUInt<24>(AddrSpace))
return reportError("Invalid address space, must be a 24-bit integer");
return Error::success();
}
|
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdi, %rbx
callq 0x1158d7d
cmpq $0x0, (%rbx)
jne 0x1158f11
cmpl $0x1000000, (%r14) # imm = 0x1000000
jae 0x1158ef6
andq $0x0, (%rbx)
jmp 0x1158f11
leaq 0x2ef771(%rip), %rax # 0x144866e
movq %rsp, %rsi
movq %rax, (%rsi)
movw $0x103, 0x20(%rsi) # imm = 0x103
movq %rbx, %rdi
callq 0x1158dcc
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
|
/IR/DataLayout.cpp
|
llvm::cl::opt<(anonymous namespace)::PassDebugLevel, false, llvm::cl::parser<(anonymous namespace)::PassDebugLevel>>::printOptionValue(unsigned long, bool) const
|
void printOptionValue(size_t GlobalWidth, bool Force) const override {
if (Force || !this->getDefault().compare(this->getValue())) {
cl::printOptionDiff<ParserClass>(*this, Parser, this->getValue(),
this->getDefault(), GlobalWidth);
}
}
|
movq %rsi, %r8
movq %rdi, %rsi
movl 0x80(%rdi), %eax
testl %edx, %edx
je 0x1159954
subq $0x18, %rsp
leaq 0x98(%rsi), %rdi
leaq 0x88(%rsi), %rcx
leaq 0x9edfed(%rip), %r9 # 0x1b47928
leaq 0x8(%rsp), %rdx
movq %r9, (%rdx)
movb $0x1, 0xc(%rdx)
movl %eax, 0x8(%rdx)
callq 0x45b55e
addq $0x18, %rsp
retq
cmpb $0x1, 0x94(%rsi)
jne 0x1159922
cmpl %eax, 0x90(%rsi)
jne 0x1159922
retq
|
/llvm/Support/CommandLine.h
|
llvm::cl::opt<llvm::ChangePrinter, false, llvm::cl::parser<llvm::ChangePrinter>>::opt<char [14], llvm::cl::desc, llvm::cl::OptionHidden, llvm::cl::ValueExpected, llvm::cl::initializer<llvm::ChangePrinter>, llvm::cl::ValuesClass>(char const (&) [14], llvm::cl::desc const&, llvm::cl::OptionHidden const&, llvm::cl::ValueExpected const&, llvm::cl::initializer<llvm::ChangePrinter> const&, llvm::cl::ValuesClass const&)
|
explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
movq 0x50(%rsp), %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0x453f88
andl $0x0, 0x80(%r14)
andq $0x0, 0x90(%r14)
leaq 0x9ed0cf(%rip), %rax # 0x1b47a20
addq $0x10, %rax
movq %rax, 0x88(%r14)
leaq 0x9ed005(%rip), %rax # 0x1b47968
addq $0x10, %rax
movq %rax, (%r14)
movq %r14, 0xa0(%r14)
leaq 0x9ed058(%rip), %rax # 0x1b479d0
addq $0x10, %rax
movq %rax, 0x98(%r14)
leaq 0xb8(%r14), %rax
movq %rax, 0xa8(%r14)
movabsq $0x800000000, %rax # imm = 0x800000000
movq %rax, 0xb0(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x238(%r14)
leaq 0x7e8(%rip), %rax # 0x115b19c
movq %rax, 0x250(%r14)
leaq 0x7dc(%rip), %rax # 0x115b19e
movq %rax, 0x248(%r14)
movq %rbx, (%rsp)
movq %r14, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
movq 0x10(%rsp), %r9
callq 0x115b13c
movq %r14, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x456a0c
|
/llvm/Support/CommandLine.h
|
llvm::AArch64::ExtensionSet::enable(llvm::AArch64::ArchExtKind)
|
void AArch64::ExtensionSet::enable(ArchExtKind E) {
if (Enabled.test(E))
return;
LLVM_DEBUG(llvm::dbgs() << "Enable " << lookupExtensionByID(E).UserVisibleName << "\n");
Touched.set(E);
Enabled.set(E);
// Recursively enable all features that this one depends on. This handles all
// of the simple cases, where the behaviour doesn't depend on the base
// architecture version.
for (auto Dep : ExtensionDependencies)
if (E == Dep.Later)
enable(Dep.Earlier);
// Special cases for dependencies which vary depending on the base
// architecture version.
if (BaseArch) {
// +fp16 implies +fp16fml for v8.4A+, but not v9.0-A+
if (E == AEK_FP16 && BaseArch->is_superset(ARMV8_4A) &&
!BaseArch->is_superset(ARMV9A))
enable(AEK_FP16FML);
// For v8.4A+ and v9.0A+, +crypto also enables +sha3 and +sm4.
if (E == AEK_CRYPTO && BaseArch->is_superset(ARMV8_4A)) {
enable(AEK_SHA3);
enable(AEK_SM4);
}
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r12d
movq %rdi, %rbx
pushq $0x1
popq %r13
pushq $0x4
popq %r14
leaq 0x353f34(%rip), %r15 # 0x14b4190
movq %r13, %rax
movl %r12d, %ecx
shlq %cl, %rax
movl %r12d, %ecx
shrl $0x6, %ecx
movq (%rbx,%rcx,8), %rdx
btq %r12, %rdx
jb 0x1160315
orq %rax, 0x10(%rbx,%rcx,8)
orq %rax, %rdx
movq %rdx, (%rbx,%rcx,8)
movq %r14, %rbp
cmpq $0x214, %rbp # imm = 0x214
je 0x11602aa
cmpl %r12d, (%r15,%rbp)
jne 0x11602a4
movl -0x4(%r15,%rbp), %esi
movq %rbx, %rdi
callq 0x116023c
addq $0x8, %rbp
jmp 0x1160288
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x1160315
cmpl $0x10, %r12d
je 0x11602ef
cmpl $0x24, %r12d
jne 0x1160315
leaq 0x7f7fc2(%rip), %rsi # 0x1958288
callq 0x1160324
testb %al, %al
je 0x1160315
movq 0x20(%rbx), %rdi
leaq 0x7f815e(%rip), %rsi # 0x1958438
callq 0x1160324
pushq $0x1d
popq %rcx
movl %ecx, %r12d
testb %al, %al
je 0x116025c
jmp 0x1160315
leaq 0x7f7f92(%rip), %rsi # 0x1958288
callq 0x1160324
testb %al, %al
je 0x1160315
movq %rbx, %rdi
pushq $0x4a
popq %rsi
callq 0x116023c
pushq $0x4b
popq %rax
movl %eax, %r12d
jmp 0x116025c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/TargetParser/AArch64TargetParser.cpp
|
llvm::Triple::getWatchOSVersion() const
|
VersionTuple Triple::getWatchOSVersion() const {
switch (getOS()) {
default: llvm_unreachable("unexpected OS for Darwin triple");
case Darwin:
case MacOSX:
// Ignore the version from the triple. This is only handled because the
// the clang driver combines OS X and IOS support into a common Darwin
// toolchain that wants to know the iOS version number even when targeting
// OS X.
return VersionTuple(2);
case WatchOS: {
VersionTuple Version = getOSVersion();
if (Version.getMajor() == 0)
return VersionTuple(2);
return Version;
}
case IOS:
llvm_unreachable("conflicting triple info");
case XROS:
llvm_unreachable("watchOS version isn't relevant for xrOS");
case DriverKit:
llvm_unreachable("DriverKit doesn't have a WatchOS version");
}
}
|
cmpl $0x1b, 0x2c(%rdi)
jne 0x1172996
pushq %rax
callq 0x11727ce
movq %rax, %rcx
movq %rdx, %rsi
xorl %edx, %edx
testl %ecx, %ecx
pushq $0x2
popq %rax
cmovneq %rcx, %rax
cmovneq %rsi, %rdx
addq $0x8, %rsp
retq
pushq $0x2
popq %rax
xorl %edx, %edx
retq
|
/TargetParser/Triple.cpp
|
llvm::json::sortedElements(llvm::json::Object const&)
|
std::vector<const Object::value_type *> sortedElements(const Object &O) {
std::vector<const Object::value_type *> Elements;
for (const auto &E : O)
Elements.push_back(&E);
llvm::sort(Elements,
[](const Object::value_type *L, const Object::value_type *R) {
return L->first < R->first;
});
return Elements;
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq %rsi, %rdi
callq 0x106248a
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movq %rdx, 0x8(%r14)
movl 0x10(%r15), %r12d
shlq $0x6, %r12
addq (%r15), %r12
movq %rsp, %r15
cmpq %r12, %rax
je 0x117a1e6
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x117be2e
movq %r14, %rdi
callq 0x1061e6a
movq 0x8(%rsp), %rax
jmp 0x117a1c3
movq (%rbx), %r15
movq 0x8(%rbx), %r14
cmpq %r14, %r15
je 0x117a250
movq %r14, %r12
subq %r15, %r12
movq %r12, %rax
sarq $0x3, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x117bfa9
cmpq $0x81, %r12
jl 0x117a245
leaq 0x80(%r15), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x117c246
cmpq %r14, %r12
je 0x117a250
movq %r12, %rdi
callq 0x117c2af
addq $0x8, %r12
jmp 0x117a232
movq %r15, %rdi
movq %r14, %rsi
callq 0x117c246
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/Support/JSON.cpp
|
llvm::json::OStream::value(llvm::json::Value const&)
|
void llvm::json::OStream::value(const Value &V) {
switch (V.kind()) {
case Value::Null:
valueBegin();
OS << "null";
return;
case Value::Boolean:
valueBegin();
OS << (*V.getAsBoolean() ? "true" : "false");
return;
case Value::Number:
valueBegin();
if (V.Type == Value::T_Integer)
OS << *V.getAsInteger();
else if (V.Type == Value::T_UINT64)
OS << *V.getAsUINT64();
else
OS << format("%.*g", std::numeric_limits<double>::max_digits10,
*V.getAsNumber());
return;
case Value::String:
valueBegin();
quote(OS, *V.getAsString());
return;
case Value::Array:
return array([&] {
for (const Value &E : *V.getAsArray())
value(E);
});
case Value::Object:
return object([&] {
for (const Object::value_type *E : sortedElements(*V.getAsObject()))
attribute(E->first, E->second);
});
}
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x117a176
cmpl $0x5, %eax
ja 0x117ad70
movl %eax, %eax
leaq 0x33f247(%rip), %rcx # 0x14b9e60
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, %rdi
callq 0x117ad7a
movq 0xa0(%r14), %rdi
leaq 0x32f450(%rip), %rsi # 0x14aa088
jmp 0x117acf9
movq %rsp, %rdx
movq %rbx, (%rdx)
movq %r14, 0x8(%rdx)
leaq 0x1694(%rip), %rsi # 0x117c2e2
movq %r14, %rdi
callq 0x4bfa2e
jmp 0x117ad70
movq %r14, %rdi
callq 0x117ad7a
movzwl (%rbx), %eax
movq 0xa0(%r14), %r14
movq %rbx, %rdi
cmpl $0x4, %eax
je 0x117ad22
cmpl $0x3, %eax
jne 0x117ad3b
callq 0x1179e12
movq %r14, %rdi
movq %rax, %rsi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x47f0b2
movq %r14, %rdi
callq 0x117ad7a
movq 0xa0(%r14), %r14
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1061e48
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x117ade6
jmp 0x117ad70
movq %r14, %rdi
callq 0x117ad7a
movq 0xa0(%r14), %rdi
leaq 0x2a7d02(%rip), %rsi # 0x14229e4
leaq 0x9b030(%rip), %rax # 0x1215d19
testb $0x1, 0x8(%rbx)
cmoveq %rax, %rsi
cmpw $0x1, (%rbx)
cmovneq %rax, %rsi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x45143e
movq %rsp, %rdx
movq %rbx, (%rdx)
movq %r14, 0x8(%rdx)
leaq 0x1608(%rip), %rsi # 0x117c320
movq %r14, %rdi
callq 0x4bf6f0
jmp 0x117ad70
callq 0x117adc4
movq %r14, %rdi
movq %rax, %rsi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x47f0a0
callq 0x1179dca
leaq 0x33f17d(%rip), %rax # 0x14b9ec4
movq %rsp, %rsi
movq %rax, 0x8(%rsi)
leaq 0x77d1ab(%rip), %rax # 0x18f7f00
addq $0x10, %rax
movq %rax, (%rsi)
movsd %xmm0, 0x10(%rsi)
movl $0x11, 0x18(%rsi)
movq %r14, %rdi
callq 0x47f0fc
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/Support/JSON.cpp
|
llvm::LockFileManager::processStillExecuting(llvm::StringRef, int)
|
bool LockFileManager::processStillExecuting(StringRef HostID, int PID) {
#if LLVM_ON_UNIX && !defined(__ANDROID__)
SmallString<256> StoredHostID;
if (getHostID(StoredHostID))
return true; // Conservatively assume it's executing on error.
// Check whether the process is dead. If so, we're done.
if (StoredHostID == HostID && getsid(PID) == -1 && errno == ESRCH)
return false;
#endif
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x18(%rsp), %rax
movq %rax, -0x18(%rax)
andq $0x0, -0x10(%rax)
movq $0x100, -0x8(%rax) # imm = 0x100
movq %rsp, %rdi
callq 0x117c7f9
movb $0x1, %bl
testl %eax, %eax
jne 0x117c7e1
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x450e2d
testb %al, %al
je 0x117c7e1
movl %ebp, %edi
callq 0x436dd0
cmpl $-0x1, %eax
jne 0x117c7e1
callq 0x436f30
cmpl $0x3, (%rax)
jne 0x117c7e1
xorl %ebx, %ebx
movq %rsp, %rdi
callq 0x4521fe
movl %ebx, %eax
addq $0x118, %rsp # imm = 0x118
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/Support/LockFileManager.cpp
|
llvm_strlcpy
|
size_t
llvm_strlcpy(char *dst, const char *src, size_t siz)
{
char *d = dst;
const char *s = src;
size_t n = siz;
/* Copy as many bytes as will fit */
if (n != 0) {
while (--n != 0) {
if ((*d++ = *s++) == '\0')
break;
}
}
/* Not enough room in dst, add NUL and traverse rest of src */
if (n == 0) {
if (siz != 0)
*d = '\0'; /* NUL-terminate dst */
while (*s++)
;
}
return(s - src - 1); /* count does not include NUL */
}
|
movq %rsi, %rax
movq %rsi, %rcx
testq %rdx, %rdx
je 0x118aa88
decq %rdx
xorl %ecx, %ecx
cmpq %rcx, %rdx
je 0x118aa81
movb (%rax,%rcx), %sil
movb %sil, (%rdi,%rcx)
incq %rcx
testb %sil, %sil
jne 0x118aa64
addq %rax, %rcx
movq %rcx, %rdx
jmp 0x118aa94
movb $0x0, (%rdi,%rcx)
addq %rax, %rcx
leaq 0x1(%rcx), %rdx
cmpb $0x0, (%rcx)
movq %rdx, %rcx
jne 0x118aa88
notq %rax
addq %rdx, %rax
retq
nop
|
/Support/regstrlcpy.c
|
llvm::itanium_demangle::Node* llvm::itanium_demangle::AbstractManglingParser<llvm::itanium_demangle::ManglingParser<(anonymous namespace)::DefaultAllocator>, (anonymous namespace)::DefaultAllocator>::make<llvm::itanium_demangle::NameType, char const (&) [10]>(char const (&) [10])
|
Node *make(Args &&... args) {
return ASTAllocator.template makeNode<T>(std::forward<Args>(args)...);
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
addq $0x330, %rdi # imm = 0x330
pushq $0x20
popq %rsi
callq 0x118e49e
movq %rax, %r14
movq %rbx, %rdi
callq 0x4362b0
movb $0x8, 0x8(%r14)
movzwl 0x9(%r14), %ecx
andl $0xfffff000, %ecx # imm = 0xFFFFF000
orl $0x540, %ecx # imm = 0x540
movw %cx, 0x9(%r14)
leaq 0x9afa4f(%rip), %rcx # 0x1b424a8
addq $0x10, %rcx
movq %rcx, (%r14)
movq %rax, 0x10(%r14)
movq %rbx, 0x18(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/llvm/Demangle/ItaniumDemangle.h
|
spoa::test::SpoaTest_GlobalConvexWithQualities_Test::SpoaTest_GlobalConvexWithQualities_Test()
|
TEST_F(SpoaTest, GlobalConvexWithQualities) {
Initialize(AlignmentType::kNW, 5, -4, -8, -6, -10, -2, true);
Align();
std::string c =
"ATGATGCGCTTTGTTGGCGCGGTGGCTTGATGCAGGGGCTAATCGACCTCTGGCAACCACTTTTCCATGACA"
"GGAGTTGAATATGGCATTCAGTAATCCCTTCGATGATCCGCAGGGAGCGTTTTACATATTGCGCAATGCGCA"
"GGGGCAATTCAGTCTGTGGCCGCAACAATGCGTCTTACCGGCAGGCTGGGACATTGTGTGTCAGCCGCAGTC"
"ACAGGCGTCCTGCCAGCAGTGGCTGGAAGCCCACTGGCGTACTCTGACACCGACGAATTTTACCCAGTTGCA"
"GGGAGGCACAATGAGCCAGCATTTACCTTTGGTCGCCGCACAGCCCGGCATCTGGATGGCAGAAAAACTGTC"
"AGAATTACCCTCCGCCTGGAGCGTGGCGCATTACGTTGAGTTAACCGGAGAGGTTGATTCGCCATTACTGGC"
"CCGCGCGGTGGTTGCCGGACTAGCGCAAAGCAGATACGC";
Check(c);
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x2abfe
leaq 0x52de4(%rip), %rax # 0x64a58
leaq 0x10(%rbx), %r14
vxorps %xmm0, %xmm0, %xmm0
leaq 0x30(%rbx), %rdi
movq %rax, (%rbx)
vmovups %ymm0, 0x10(%rbx)
vzeroupper
callq 0x12a24
leaq 0x52a31(%rip), %rax # 0x646c8
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq 0x28(%rbx), %rdi
movq %rax, %r15
testq %rdi, %rdi
je 0x11cb2
movq (%rdi), %rax
callq *0x8(%rax)
movq %r14, %rdi
movq $0x0, 0x28(%rbx)
callq 0xfa88
movq %rbx, %rdi
callq 0x2ac44
movq %r15, %rdi
callq 0xaa10
|
/rvaser[P]spoa/test/spoa_test.cpp
|
spoa::test::SpoaTest_SemiGlobalConvexWithQualities_Test::SpoaTest_SemiGlobalConvexWithQualities_Test()
|
TEST_F(SpoaTest, SemiGlobalConvexWithQualities) {
Initialize(AlignmentType::kOV, 5, -4, -8, -6, -10, -2, true);
Align();
std::string c =
"GTATGATGCGCTTTGTTGGCGCGGTGGCTTGATGCAGGGGCTAATCGACCTCTGGCAACCACTTTTCCATGA"
"CAGGAGTTGAATATGGCATTCAGTAATCCCTTCGATGATCCGCAGGGAGCGTTTTACATATTGCGCAATGCG"
"CAGGGGCAATTCAGTCTGTGGCCGCAACAATGCGTCTTACCGGCAGGCTGGGACATTGTGTGTCAGCCGCAG"
"TCACAGGCGTCCTGCCAGCAGTGGCTGGAAGCCCACTGGCGTACTCTGACACCGACGAATTTTACCCAGTTG"
"CAGGGAGGCACAATGAGCCAGCATTTACCTTTGGTCGCCGCACAGCCCGGCATCTGGATGGCAGAAAAACTG"
"TCAGAATTACCCTCCGCCTGGAGCGTGGCGCATTACGTTGAGTTAACCGGAGAGGTTGATTCGCCATTACTG"
"GCCCGCGCGGTGGTTGCCGGACTAGCGCAAAGCAGATACGC";
Check(c);
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x2abfe
leaq 0x52992(%rip), %rax # 0x64a58
leaq 0x10(%rbx), %r14
vxorps %xmm0, %xmm0, %xmm0
leaq 0x30(%rbx), %rdi
movq %rax, (%rbx)
vmovups %ymm0, 0x10(%rbx)
vzeroupper
callq 0x12a24
leaq 0x527ef(%rip), %rax # 0x648d8
movq %rax, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq 0x28(%rbx), %rdi
movq %rax, %r15
testq %rdi, %rdi
je 0x12104
movq (%rdi), %rax
callq *0x8(%rax)
movq %r14, %rdi
movq $0x0, 0x28(%rbx)
callq 0xfa88
movq %rbx, %rdi
callq 0x2ac44
movq %r15, %rdi
callq 0xaa10
|
/rvaser[P]spoa/test/spoa_test.cpp
|
testing::internal::PrettyUnitTestResultPrinter::OnTestIterationStart(testing::UnitTest const&, int)
|
void PrettyUnitTestResultPrinter::OnTestIterationStart(
const UnitTest& unit_test, int iteration) {
if (GTEST_FLAG(repeat) != 1)
printf("\nRepeating all tests (iteration %d) . . .\n\n", iteration + 1);
const char* const filter = GTEST_FLAG(filter).c_str();
// Prints the filter if it's not *. This reminds the user that some
// tests may be skipped.
if (!String::CStringEquals(filter, kUniversalFilter)) {
ColoredPrintf(COLOR_YELLOW,
"Note: %s filter = %s\n", GTEST_NAME_, filter);
}
if (internal::ShouldShard(kTestTotalShards, kTestShardIndex, false)) {
const Int32 shard_index = Int32FromEnvOrDie(kTestShardIndex, -1);
ColoredPrintf(COLOR_YELLOW,
"Note: This is test shard %d of %s.\n",
static_cast<int>(shard_index) + 1,
internal::posix::GetEnv(kTestTotalShards));
}
if (GTEST_FLAG(shuffle)) {
ColoredPrintf(COLOR_YELLOW,
"Note: Randomizing tests' orders with a seed of %d .\n",
unit_test.random_seed());
}
ColoredPrintf(COLOR_GREEN, "[==========] ");
printf("Running %s from %s.\n",
FormatTestCount(unit_test.test_to_run_count()).c_str(),
FormatTestSuiteCount(unit_test.test_suite_to_run_count()).c_str());
fflush(stdout);
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
cmpl $0x1, 0x39b95(%rip) # 0x66728
movq %rsi, %rbx
je 0x2cbaa
incl %edx
leaq 0x2146c(%rip), %rdi # 0x4e00d
xorl %eax, %eax
movl %edx, %esi
callq 0xa080
movq 0x39b27(%rip), %rcx # 0x666d8
testq %rcx, %rcx
je 0x2cbc1
cmpb $0x2a, (%rcx)
jne 0x2cbc1
cmpb $0x0, 0x1(%rcx)
je 0x2cbdb
leaq 0x21471(%rip), %rsi # 0x4e039
leaq 0x21480(%rip), %rdx # 0x4e04f
movl $0x3, %edi
xorl %eax, %eax
callq 0x2ca86
leaq 0x1fe0e(%rip), %rdi # 0x4c9f0
leaq 0x1fe27(%rip), %rsi # 0x4ca10
xorl %edx, %edx
callq 0x2cd42
testb %al, %al
je 0x2cc2c
leaq 0x1fe15(%rip), %rdi # 0x4ca10
movl $0xffffffff, %esi # imm = 0xFFFFFFFF
callq 0x2d0e4
leaq 0x1fde4(%rip), %rdi # 0x4c9f0
leal 0x1(%rax), %ebp
callq 0xa690
leaq 0x21440(%rip), %rsi # 0x4e05b
movl $0x3, %edi
movq %rax, %rcx
movl %ebp, %edx
xorl %eax, %eax
callq 0x2ca86
cmpb $0x1, 0x39afa(%rip) # 0x6672d
jne 0x2cc52
movq 0x40(%rbx), %rax
leaq 0x2143f(%rip), %rsi # 0x4e07f
movl $0x3, %edi
movl 0x1bc(%rax), %edx
xorl %eax, %eax
callq 0x2ca86
leaq 0x2145b(%rip), %rsi # 0x4e0b4
movl $0x2, %edi
xorl %eax, %eax
xorl %ebp, %ebp
callq 0x2ca86
movq 0x40(%rbx), %rdi
callq 0x268b6
leaq 0x21ee3(%rip), %rdx # 0x4eb5a
leaq 0x21467(%rip), %rcx # 0x4e0e5
movq %rsp, %rdi
movl %eax, %esi
callq 0x2d2ea
movq 0x40(%rbx), %rcx
movq 0xb8(%rcx), %rax
movq 0xc0(%rcx), %rcx
cmpq %rcx, %rax
je 0x2ccb3
xorl %ebp, %ebp
movq (%rax), %rdx
addq $0x8, %rax
movzbl 0x70(%rdx), %edx
addl %edx, %ebp
cmpq %rcx, %rax
jne 0x2cca1
movq (%rsp), %rbx
leaq 0x2257a(%rip), %rdx # 0x4f238
leaq 0x2257e(%rip), %rcx # 0x4f243
leaq 0x20(%rsp), %rdi
movl %ebp, %esi
callq 0x2d2ea
leaq 0x30(%rsp), %r14
leaq 0x213e5(%rip), %rdi # 0x4e0c2
movq %rbx, %rsi
xorl %eax, %eax
movq -0x10(%r14), %rdx
callq 0xa080
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0x2ccf9
callq 0xa470
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2cd0c
callq 0xa470
movq 0x3924d(%rip), %rax # 0x65f60
movq (%rax), %rdi
callq 0xa620
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x10(%rsp), %rcx
movq %rax, %rbx
movq -0x10(%rcx), %rdi
cmpq %rcx, %rdi
je 0x2cd3a
callq 0xa470
movq %rbx, %rdi
callq 0xaa10
|
/rvaser[P]spoa/build_O3/_deps/googletest-src/googletest/src/gtest.cc
|
testing::internal::ComparisonBase<testing::internal::EqMatcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, testing::internal::AnyEq>::operator testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&><std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>() const
|
operator Matcher<Lhs>() const {
return Matcher<Lhs>(new Impl<const Lhs&>(rhs_));
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x28, %edi
movq %rsi, %r15
callq 0xa4b0
movq %rax, %r14
leaq 0x22f15(%rip), %rdx # 0x65c60
leaq 0x18(%r14), %rcx
leaq 0x8(%r14), %rdi
movq %rdx, (%r14)
movq %rcx, 0x8(%r14)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
callq 0xf6ee
leaq 0x22d58(%rip), %rax # 0x65ac8
leaq 0x10(%rbx), %rdi
movq %r14, %rsi
movq %rax, (%rbx)
movq %r14, 0x8(%rbx)
callq 0x4847c
leaq 0x22b16(%rip), %rax # 0x658a0
movq %rax, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rdi
movq %rax, %rbx
callq 0xa470
movq %rbx, %rdi
callq 0xaa10
nop
|
/rvaser[P]spoa/build_O3/_deps/googletest-src/googletest/include/gtest/gtest-matchers.h
|
testing::internal::DeathTestImpl::~DeathTestImpl()
|
~DeathTestImpl() override { GTEST_DEATH_TEST_CHECK_(read_fd_ == -1); }
|
pushq %rbx
subq $0xf0, %rsp
leaq 0x22119(%rip), %rax # 0x655c0
movq %rax, (%rdi)
cmpl $-0x1, 0x34(%rdi)
jne 0x434d3
leaq 0x22611(%rip), %rax # 0x65ac8
movq %rax, 0x10(%rdi)
movq 0x20(%rdi), %rdi
addq $0xf0, %rsp
testq %rdi, %rdi
je 0x434d1
popq %rbx
jmp 0x45ae6
popq %rbx
retq
leaq 0xe0(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0xb4d3(%rip), %rsi # 0x4e9b9
leaq 0xb4df(%rip), %rdx # 0x4e9cc
leaq 0xd0(%rsp), %rdi
callq 0x10874
leaq 0xb3cf(%rip), %rsi # 0x4e8d0
leaq 0xd0(%rsp), %rdi
callq 0xab00
leaq 0x80(%rsp), %rdx
movq %rax, %rcx
addq $0x10, %rcx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
cmpq %rcx, %rsi
jne 0x43533
vmovups (%rcx), %xmm0
vmovups %xmm0, (%rdx)
jmp 0x43543
movq %rsi, 0x70(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x80(%rsp)
movq 0x8(%rax), %rdx
leaq 0x70(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0xb467(%rip), %rsi # 0x4e9cd
callq 0xab00
leaq 0x38(%rsp), %rbx
movq %rax, %rcx
addq $0x10, %rcx
movq %rbx, -0x10(%rbx)
movq (%rax), %rdx
cmpq %rcx, %rdx
jne 0x4358d
vmovups (%rcx), %xmm0
vmovups %xmm0, (%rbx)
jmp 0x4359a
movq %rdx, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
movq 0x8(%rax), %rdx
leaq 0x4c(%rsp), %rsi
movq %rdx, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movl $0x199, (%rsi) # imm = 0x199
leaq 0x50(%rsp), %rdi
callq 0x418fc
movq 0x30(%rsp), %r8
movq 0x58(%rsp), %rdx
movq 0x28(%rsp), %rcx
movl $0xf, %edi
leaq (%rdx,%r8), %rax
cmpq %rbx, %rcx
je 0x435e9
movq 0x38(%rsp), %rdi
movq 0x50(%rsp), %rsi
cmpq %rdi, %rax
jbe 0x4360c
leaq 0x60(%rsp), %r9
movl $0xf, %edi
cmpq %r9, %rsi
je 0x43607
movq 0x60(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x43618
leaq 0x28(%rsp), %rdi
callq 0xa160
jmp 0x43626
leaq 0x50(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0xa5b0
leaq 0x18(%rsp), %rdx
leaq 0x10(%rax), %rcx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
cmpq %rcx, %rsi
jne 0x43645
vmovups (%rcx), %xmm0
vmovups %xmm0, (%rdx)
jmp 0x43652
movq %rsi, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
movq 0x8(%rax), %rsi
movq %rax, %rdx
addq $0x8, %rdx
movq %rsi, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0xadf6(%rip), %rsi # 0x4e46c
leaq 0x8(%rsp), %rdi
callq 0xab00
leaq 0xa0(%rsp), %rdx
movq %rax, %rcx
addq $0x10, %rcx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
cmpq %rcx, %rsi
jne 0x436a5
vmovups (%rcx), %xmm0
vmovups %xmm0, (%rdx)
jmp 0x436b8
movq %rsi, 0x90(%rsp)
movq (%rcx), %rdx
movq %rdx, 0xa0(%rsp)
movq 0x8(%rax), %rdx
leaq 0x90(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0xc2ac(%rip), %rsi # 0x4f98a
callq 0xab00
leaq 0xc0(%rsp), %rdx
movq %rax, %rcx
addq $0x10, %rcx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
cmpq %rcx, %rsi
jne 0x43708
vmovups (%rcx), %xmm0
vmovups %xmm0, (%rdx)
jmp 0x4371b
movq %rsi, 0xb0(%rsp)
movq (%rcx), %rdx
movq %rdx, 0xc0(%rsp)
movq 0x8(%rax), %rdx
leaq 0xb0(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
callq 0x36de7
movq %rax, %rdi
callq 0xe380
nop
|
/rvaser[P]spoa/build_O3/_deps/googletest-src/googletest/src/gtest-death-test.cc
|
testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::CreateKey()
|
static pthread_key_t CreateKey() {
pthread_key_t key;
// When a thread exits, DeleteThreadLocalValue() will be called on
// the object managed for that thread.
GTEST_CHECK_POSIX_SUCCESS_(
pthread_key_create(&key, &DeleteThreadLocalValue));
return key;
}
|
pushq %rbx
subq $0x10, %rsp
leaq -0x4a(%rip), %rsi # 0x47db6
leaq 0xc(%rsp), %rdi
callq 0xa910
testl %eax, %eax
je 0x47e73
leaq 0x717d(%rip), %rdx # 0x4ef92
leaq 0x8(%rsp), %rdi
movl $0x3, %esi
movl $0x6f5, %ecx # imm = 0x6F5
movl %eax, %ebx
callq 0x3d9ae
movq 0x1e1b6(%rip), %rdi # 0x65fe8
leaq 0x7c05(%rip), %rsi # 0x4fa3e
movl $0x31, %edx
callq 0xa5d0
movq 0x1e19e(%rip), %rdi # 0x65fe8
leaq 0x71ea(%rip), %rsi # 0x4f03b
movl $0x12, %edx
callq 0xa5d0
movq 0x1e186(%rip), %rdi # 0x65fe8
movl %ebx, %esi
callq 0xa9c0
leaq 0x8(%rsp), %rdi
callq 0x3dae0
movl 0xc(%rsp), %eax
addq $0x10, %rsp
popq %rbx
retq
leaq 0x8(%rsp), %rdi
movq %rax, %rbx
callq 0x3dae0
movq %rbx, %rdi
callq 0xaa10
|
/rvaser[P]spoa/build_O3/_deps/googletest-src/googletest/include/gtest/internal/gtest-port.h
|
testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::DefaultValueHolderFactory::MakeNewHolder() const
|
virtual ValueHolder* MakeNewHolder() const { return new ValueHolder(); }
|
pushq %rax
movl $0x20, %edi
callq 0xa4b0
leaq 0x1dd4c(%rip), %rcx # 0x65bf8
vxorps %xmm0, %xmm0, %xmm0
movq %rcx, (%rax)
vmovups %xmm0, 0x8(%rax)
movq $0x0, 0x18(%rax)
popq %rcx
retq
|
/rvaser[P]spoa/build_O3/_deps/googletest-src/googletest/include/gtest/internal/gtest-port.h
|
cmCTestGlobalVC::DoModification(cmCTestVC::PathStatus, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
|
void cmCTestGlobalVC::DoModification(PathStatus status,
std::string const& path)
{
std::string dir = cmSystemTools::GetFilenamePath(path);
std::string name = cmSystemTools::GetFilenameName(path);
File& file = this->Dirs[dir][name];
file.Status = status;
// For local modifications the current rev is unknown and the
// prior rev is the latest from svn.
if (!file.Rev && !file.PriorRev) {
file.PriorRev = &this->PriorRev;
}
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rdx, %rsi
callq 0x4897be
movq %rsp, %rdi
movq %r14, %rsi
callq 0x48975c
leaq 0x188(%rbx), %rdi
leaq 0x20(%rsp), %rsi
callq 0xeb1f8
movq %rsp, %rsi
movq %rax, %rdi
callq 0xeb274
movl %ebp, (%rax)
cmpq $0x0, 0x8(%rax)
jne 0x117749
cmpq $0x0, 0x10(%rax)
jne 0x117749
addq $0x1f8, %rbx # imm = 0x1F8
movq %rbx, 0x10(%rax)
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x117764
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3f310
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x11777f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3f310
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
jmp 0x1177ab
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1177ab
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3f310
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1177c6
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x3f310
movq %rbx, %rdi
callq 0x40710
|
/JKorbelRA[P]CMake/Source/CTest/cmCTestGlobalVC.cxx
|
cmCTestGlobalVC::WriteXMLGlobal(cmXMLWriter&)
|
void cmCTestGlobalVC::WriteXMLGlobal(cmXMLWriter& xml)
{
if (!this->NewRevision.empty()) {
xml.Element("Revision", this->NewRevision);
}
if (!this->OldRevision.empty() && this->OldRevision != this->NewRevision) {
xml.Element("PriorRevision", this->OldRevision);
}
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x1d8(%rdi), %r14
cmpq $0x0, 0x1e0(%rdi)
je 0x117a83
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x52e2c7(%rip), %rsi # 0x645d02
leaq 0x52e2c8(%rip), %rdx # 0x645d0a
leaq 0x8(%rsp), %rdi
callq 0x5c768
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x20905c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x747e4
movq %rbx, %rdi
callq 0x209148
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x117a83
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3f310
movq 0x1c0(%r15), %rdx
testq %rdx, %rdx
je 0x117b07
leaq 0x1b8(%r15), %r12
cmpq 0x1e0(%r15), %rdx
jne 0x117aaf
movq (%r14), %rsi
movq (%r12), %rdi
callq 0x40880
testl %eax, %eax
je 0x117b07
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x52e23e(%rip), %rsi # 0x645cfd
leaq 0x52e244(%rip), %rdx # 0x645d0a
leaq 0x8(%rsp), %rdi
callq 0x5c768
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x20905c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x747e4
movq %rbx, %rdi
callq 0x209148
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x117b07
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3f310
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x117b15
movq %rax, %rbx
jmp 0x117b43
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
jne 0x117b36
jmp 0x117b43
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x117b43
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3f310
movq %rbx, %rdi
callq 0x40710
nop
|
/JKorbelRA[P]CMake/Source/CTest/cmCTestGlobalVC.cxx
|
cmCTestResourceGroups_yypop_buffer_state(void*)
|
void yypop_buffer_state (yyscan_t yyscanner)
{
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
if (!YY_CURRENT_BUFFER)
return;
yy_delete_buffer(YY_CURRENT_BUFFER , yyscanner);
YY_CURRENT_BUFFER_LVALUE = NULL;
if (yyg->yy_buffer_stack_top > 0)
--yyg->yy_buffer_stack_top;
if (YY_CURRENT_BUFFER) {
yy_load_buffer_state( yyscanner );
yyg->yy_did_buffer_switch_on_eof = 1;
}
}
|
movq 0x28(%rdi), %rax
testq %rax, %rax
je 0x118e2c
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rcx
movq (%rax,%rcx,8), %rdi
testq %rdi, %rdi
je 0x118e2b
movq %rbx, %rsi
callq 0x118c58
movq 0x18(%rbx), %rax
movq 0x28(%rbx), %rcx
movq $0x0, (%rcx,%rax,8)
testq %rax, %rax
je 0x118deb
decq %rax
movq %rax, 0x18(%rbx)
jmp 0x118ded
xorl %eax, %eax
movq 0x28(%rbx), %rcx
testq %rcx, %rcx
je 0x118e2b
movq (%rcx,%rax,8), %rdx
testq %rdx, %rdx
je 0x118e2b
movl 0x1c(%rdx), %esi
movl %esi, 0x34(%rbx)
movq 0x10(%rdx), %rdx
movq %rdx, 0x40(%rbx)
movq %rdx, 0x80(%rbx)
movq (%rcx,%rax,8), %rax
movq (%rax), %rax
movq %rax, 0x8(%rbx)
movb (%rdx), %al
movb %al, 0x30(%rbx)
movl $0x1, 0x50(%rbx)
popq %rbx
retq
|
/JKorbelRA[P]CMake/Source/LexerParser/cmCTestResourceGroupsLexer.cxx
|
cmCTestResourceGroups_yylex_destroy(void*)
|
int yylex_destroy (yyscan_t yyscanner)
{
struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
/* Pop the buffer stack, destroying each element. */
while(YY_CURRENT_BUFFER){
yy_delete_buffer( YY_CURRENT_BUFFER , yyscanner );
YY_CURRENT_BUFFER_LVALUE = NULL;
yypop_buffer_state(yyscanner);
}
/* Destroy the stack itself. */
yyfree(yyg->yy_buffer_stack , yyscanner);
yyg->yy_buffer_stack = NULL;
/* Destroy the start condition stack. */
yyfree( yyg->yy_start_stack , yyscanner );
yyg->yy_start_stack = NULL;
/* Reset the globals. This is important in a non-reentrant scanner so the next time
* yylex() is called, initialization will occur. */
yy_init_globals( yyscanner);
/* Destroy the main struct (reentrant only). */
yyfree ( yyscanner , yyscanner );
yyscanner = NULL;
return 0;
}
|
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x1190f0
movq 0x18(%rbx), %rax
movq (%rdi,%rax,8), %rax
testq %rax, %rax
je 0x1190f2
movq %rax, %rdi
movq %rbx, %rsi
callq 0x118c58
movq 0x18(%rbx), %rax
movq 0x28(%rbx), %rcx
movq $0x0, (%rcx,%rax,8)
movq %rbx, %rdi
callq 0x118dab
movq 0x28(%rbx), %rdi
jmp 0x1190b5
xorl %edi, %edi
callq 0x41e70
movq $0x0, 0x28(%rbx)
movq 0x60(%rbx), %rdi
callq 0x41e70
movq %rbx, %rdi
callq 0x41e70
xorl %eax, %eax
popq %rbx
retq
|
/JKorbelRA[P]CMake/Source/LexerParser/cmCTestResourceGroupsLexer.cxx
|
cmProcess::Buffer::GetLine(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
|
bool cmProcess::Buffer::GetLine(std::string& line)
{
// Scan for the next newline.
for (size_type sz = this->size(); this->Last != sz; ++this->Last) {
if ((*this)[this->Last] == '\n' || (*this)[this->Last] == '\0') {
// Extract the range first..last as a line.
const char* text = this->data() + this->First;
size_type length = this->Last - this->First;
while (length && text[length - 1] == '\r') {
length--;
}
line.assign(text, length);
// Start a new range for the next line.
++this->Last;
this->First = this->Last;
// Return the line extracted.
return true;
}
}
// Available data have been exhausted without a newline.
if (this->First != 0) {
// Move the partial line to the beginning of the buffer.
this->erase(this->begin(), this->begin() + this->First);
this->First = 0;
this->Last = this->size();
}
return false;
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movq 0x8(%rdi), %rax
movq %rax, %rcx
subq %r14, %rcx
movq 0x20(%rdi), %rdx
cmpq %rcx, %rdx
je 0x119cbc
movzbl (%r14,%rdx), %edi
cmpl $0xa, %edi
je 0x119d0a
testl %edi, %edi
je 0x119d0a
incq %rdx
movq %rdx, 0x20(%rbx)
cmpq %rdx, %rcx
jne 0x119ca2
movq 0x18(%rbx), %r15
testq %r15, %r15
je 0x119d06
addq %r14, %r15
movq %rax, %rdx
movq %r15, %rcx
subq %r15, %rdx
je 0x119ce5
movq %r14, %rdi
movq %r15, %rsi
callq 0x3f470
movq 0x8(%rbx), %rcx
movq %rcx, %rax
subq %r15, %rcx
addq %rcx, %r14
cmpq %r14, %rax
je 0x119cf7
movq %r14, 0x8(%rbx)
movq %r14, %rax
movq $0x0, 0x18(%rbx)
subq (%rbx), %rax
movq %rax, 0x20(%rbx)
xorl %eax, %eax
jmp 0x119d5b
movq 0x18(%rbx), %rax
leaq (%r14,%rax), %rcx
movq %rdx, %r8
subq %rax, %r8
je 0x119d2e
leaq (%r14,%rdx), %rax
decq %rax
cmpb $0xd, (%rax)
jne 0x119d3c
decq %rax
decq %r8
jne 0x119d21
movq 0x8(%rsi), %rdx
movq %rsi, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
jmp 0x119d45
movq 0x8(%rsi), %rdx
movq %rsi, %rdi
xorl %esi, %esi
callq 0x40110
movq 0x20(%rbx), %rax
incq %rax
movq %rax, 0x20(%rbx)
movq %rax, 0x18(%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
nop
|
/JKorbelRA[P]CMake/Source/CTest/cmProcess.cxx
|
bool (anonymous namespace)::AllocateCTestResources<(anonymous namespace)::RoundRobinAllocationStrategy>(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, cmCTestResourceAllocator::Resource, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, cmCTestResourceAllocator::Resource>>> const&, 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&, unsigned long, std::vector<cmCTestBinPackerAllocation*, std::allocator<cmCTestBinPackerAllocation*>>&)
|
bool AllocateCTestResources(
const std::map<std::string, cmCTestResourceAllocator::Resource>& resources,
const std::vector<std::string>& resourcesSorted, std::size_t currentIndex,
std::vector<cmCTestBinPackerAllocation*>& allocations)
{
// Iterate through all large enough resources until we find a solution
std::size_t resourceIndex = 0;
while (resourceIndex < resourcesSorted.size()) {
auto const& resource = resources.at(resourcesSorted[resourceIndex]);
if (resource.Free() >=
static_cast<unsigned int>(allocations[currentIndex]->SlotsNeeded)) {
// Preemptively allocate the resource
allocations[currentIndex]->Id = resourcesSorted[resourceIndex];
if (currentIndex + 1 >= allocations.size()) {
// We have a solution
return true;
}
// Move the resource up the list until it is sorted again
auto resources2 = resources;
auto resourcesSorted2 = resourcesSorted;
resources2[resourcesSorted2[resourceIndex]].Locked +=
allocations[currentIndex]->SlotsNeeded;
AllocationStrategy::IncrementalSort(resources2, resourcesSorted2,
resourceIndex);
// Recurse one level deeper
if (AllocateCTestResources<AllocationStrategy>(
resources2, resourcesSorted2, currentIndex + 1, allocations)) {
return true;
}
}
// No solution found here, deallocate the resource and try the next one
allocations[currentIndex]->Id.clear();
auto freeSlots = resources.at(resourcesSorted.at(resourceIndex)).Free();
do {
++resourceIndex;
} while (resourceIndex < resourcesSorted.size() &&
resources.at(resourcesSorted.at(resourceIndex)).Free() ==
freeSlots);
}
// No solution was found
return false;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r15
movq %rdi, 0x10(%rsp)
movq (%rsi), %rsi
cmpq %rsi, 0x8(%r15)
je 0x11af66
movq %rcx, %r14
movq %rdx, %rbp
leaq 0x1(%rdx), %rax
movq %rax, 0x18(%rsp)
xorl %r13d, %r13d
movq %rcx, 0x20(%rsp)
movq %rdx, 0x60(%rsp)
movq %r13, %rbx
shlq $0x5, %rbx
addq %rbx, %rsi
movq 0x10(%rsp), %rdi
callq 0x11f6b6
movl (%rax), %ecx
subl 0x4(%rax), %ecx
movq (%r14), %rax
movq (%rax,%rbp,8), %rdi
cmpl 0x8(%rdi), %ecx
jb 0x11aeca
movq (%r15), %rsi
addq %rbx, %rsi
addq $0x10, %rdi
callq 0x41a90
movq 0x8(%r14), %rax
subq (%r14), %rax
sarq $0x3, %rax
movb $0x1, %cl
movl %ecx, 0xc(%rsp)
cmpq %rax, 0x18(%rsp)
jae 0x11af6e
leaq 0x68(%rsp), %r12
movq %r12, %rdi
movq 0x10(%rsp), %rsi
callq 0x11fae4
leaq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x9c4c8
movq (%r14), %rax
movq (%rax,%rbp,8), %rax
movl 0x8(%rax), %ebp
movq 0x28(%rsp), %rsi
addq %rbx, %rsi
movq %r12, %rdi
callq 0xfdd28
leaq 0x50(%rsp), %rcx
addl %ebp, 0x4(%rax)
movq 0x28(%rsp), %rax
movq %rcx, 0x40(%rsp)
movq (%rax,%rbx), %rsi
movq 0x8(%rax,%rbx), %rdx
addq %rsi, %rdx
leaq 0x40(%rsp), %rdi
callq 0x777d0
leaq -0x1(%r13), %r14
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rax
subq %rdi, %rax
sarq $0x5, %rax
decq %rax
incq %r14
cmpq %rax, %r14
jae 0x11ae58
leaq (%rdi,%rbx), %rsi
addq $0x20, %rsi
leaq 0x68(%rsp), %rdi
callq 0x11f6b6
movl (%rax), %ebp
movl 0x4(%rax), %r12d
leaq 0x68(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x11f6b6
subl %r12d, %ebp
movl (%rax), %ecx
subl 0x4(%rax), %ecx
movq 0x28(%rsp), %rdi
cmpl %ecx, %ebp
jbe 0x11ae58
leaq 0x20(%rbx), %r12
leaq (%rdi,%rbx), %rax
leaq (%rdi,%rbx), %rsi
addq $0x20, %rsi
movq %rax, %rdi
callq 0x41a90
movq %r12, %rbx
jmp 0x11ade7
leaq 0x50(%rsp), %r12
leaq 0x68(%rsp), %rbp
addq %rbx, %rdi
leaq 0x40(%rsp), %rsi
callq 0x41a90
movq 0x20(%rsp), %r14
movq 0x40(%rsp), %rdi
cmpq %r12, %rdi
je 0x11ae8b
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x3f310
movq %rbp, %rdi
leaq 0x28(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %r14, %rcx
callq 0x11acec
movl %eax, %ebx
leaq 0x28(%rsp), %rdi
callq 0x5c554
leaq 0x68(%rsp), %rdi
callq 0xfde42
testb %bl, %bl
jne 0x11af6e
movq (%r14), %rax
movq 0x60(%rsp), %rbp
movq (%rax,%rbp,8), %rdi
movq $0x0, 0x18(%rdi)
movq 0x10(%rdi), %rax
movb $0x0, (%rax)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
subq %rsi, %rdx
sarq $0x5, %rdx
cmpq %r13, %rdx
jbe 0x11af84
movq %r13, %rbx
shlq $0x5, %rbx
addq %rbx, %rsi
movq 0x10(%rsp), %rdi
callq 0x11f6b6
movl (%rax), %r14d
subl 0x4(%rax), %r14d
incq %r13
addq $0x20, %rbx
movq %r13, %rax
movq %rax, %r13
movq (%r15), %rsi
movq 0x8(%r15), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %rax, %r13
jae 0x11af58
addq %rbx, %rsi
movq 0x10(%rsp), %rdi
callq 0x11f6b6
movl (%rax), %ecx
subl 0x4(%rax), %ecx
leaq 0x1(%r13), %rax
addq $0x20, %rbx
cmpl %r14d, %ecx
je 0x11af15
movq (%r15), %rsi
movq 0x8(%r15), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %rax, %r13
movq 0x20(%rsp), %r14
jb 0x11ad2e
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x52ee75(%rip), %rdi # 0x649e00
movq %r13, %rsi
xorl %eax, %eax
callq 0x3f0f0
jmp 0x11afa1
movq %rax, %rbx
jmp 0x11afca
movq %rax, %rbx
jmp 0x11afc0
movq %rax, %rbx
movq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rax
cmpq %rax, %rdi
je 0x11afc0
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x3f310
leaq 0x28(%rsp), %rdi
callq 0x5c554
leaq 0x68(%rsp), %rdi
callq 0xfde42
movq %rbx, %rdi
callq 0x40710
|
/JKorbelRA[P]CMake/Source/CTest/cmCTestBinPacker.cxx
|
cmAffinity::GetProcessorsAvailable()
|
std::set<size_t> GetProcessorsAvailable()
{
std::set<size_t> processorsAvailable;
#ifdef CM_HAVE_CPU_AFFINITY
int cpumask_size = uv_cpumask_size();
if (cpumask_size > 0) {
# ifdef _WIN32
DWORD_PTR procmask;
DWORD_PTR sysmask;
if (GetProcessAffinityMask(GetCurrentProcess(), &procmask, &sysmask) !=
0) {
for (int i = 0; i < cpumask_size; ++i) {
if (procmask & (((DWORD_PTR)1) << i)) {
processorsAvailable.insert(i);
}
}
}
# else
cm_cpuset_t cpuset;
CPU_ZERO(&cpuset); // NOLINT(clang-tidy)
if (pthread_getaffinity_np(pthread_self(), sizeof(cpuset), &cpuset) == 0) {
for (int i = 0; i < cpumask_size; ++i) {
if (CPU_ISSET(i, &cpuset)) {
processorsAvailable.insert(i);
}
}
}
# endif
}
#endif
return processorsAvailable;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
callq 0x62007e
movl %eax, %ebp
testl %eax, %eax
jle 0x11fdd0
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
movaps %xmm0, 0x70(%r14)
movaps %xmm0, 0x60(%r14)
movaps %xmm0, 0x50(%r14)
movaps %xmm0, 0x40(%r14)
movaps %xmm0, 0x30(%r14)
movaps %xmm0, 0x20(%r14)
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
callq 0x408d0
movl $0x80, %esi
movq %rax, %rdi
movq %r14, %rdx
callq 0x41ba0
testl %eax, %eax
jne 0x11fdd0
movl %ebp, %r15d
xorl %r12d, %r12d
leaq 0x8(%rsp), %r14
cmpq $0x3ff, %r12 # imm = 0x3FF
ja 0x11fdc8
movq %r12, %rax
shrq $0x6, %rax
movq 0x10(%rsp,%rax,8), %rax
btq %r12, %rax
jae 0x11fdc8
movq %r12, 0x8(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11fdf8
incq %r12
cmpq %r12, %r15
jne 0x11fd9d
movq %rbx, %rax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11fde5
movq %rax, %r14
movq %rbx, %rdi
callq 0x10af58
movq %r14, %rdi
callq 0x40710
|
/JKorbelRA[P]CMake/Source/cmAffinity.cxx
|
ArgumentParser::Instance::Bind(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
|
void Instance::Bind(std::string& val)
{
this->Bind(
[&val](cm::string_view arg) -> Continue {
val = std::string(arg);
return Continue::No;
},
ExpectAtLeast{ 1 });
}
|
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq $0x0, 0x8(%r14)
movq %rsi, (%r14)
leaq 0x5d7(%rip), %rax # 0x1207f4
movq %rax, 0x18(%r14)
leaq 0x626(%rip), %rax # 0x12084e
movq %rax, 0x10(%r14)
addq $0x40, %rdi
movq %r14, %rsi
callq 0x120a92
movq $0x1, 0x38(%rbx)
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x120258
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x5c5e1
|
/JKorbelRA[P]CMake/Source/cmArgumentParser.cxx
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.