name string | code string | asm string | file string |
|---|---|---|---|
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), IsU... | 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 0x1f... | /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::DenseMap... | 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 $... | /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::Bloc... | 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... | /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<cl... | 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... | 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... | /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);
Stri... | 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
call... | /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... | 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
call... | /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] { writeSourceL... | 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(%... | /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
ca... | /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,
... | 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... | /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->s... | 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:
... | 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... | /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
mov... | /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 0x... | /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, AttrColo... | 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), %r... | /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>()) {
// Termin... | 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
c... | /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(BaseTy... | 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
mo... | /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 DEPE... | 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 0... | /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... | 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(%r... | /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
call... | /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;
AdvancePastEmptyBuc... | 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();
VTableIndice... | 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)
c... | /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::Bas... | 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 + ... | 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::C... | 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()
... | 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,... | /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... | 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
cm... | /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->moveFromOldBu... | 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... | /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::Func... | 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->moveFromOldBu... | 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... | /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()->getAsCXXRe... | 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
po... | /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:
... | 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 %rs... | /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,... | /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<... | 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, %r... | /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());... | 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
mo... | /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());... | 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
mo... | /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 blo... | 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... | /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(... | 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... | 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 $... | /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, R... | 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 0x10039... | /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::Modu... | 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::isEqu... | 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... | /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.g... | 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
mo... | /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(CurSubmo... | 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), %e... | /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"
}... | 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) .Ca... | 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, %rd... | /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 0x1070e... | /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 con... | 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... | 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::isEqu... | 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, ... | /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_... | 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 = PointerWi... | 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];
... | 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)
x... | /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 $-0x... | /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(%... | /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, 0... | /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, (%r... | /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(... | 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... | /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(%... | /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 w... | 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... | /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);
co... | 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,... | /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
mov... | /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 %r1... | /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, 0x6... | /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 o... | 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
ad... | /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(%ra... | /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 %... | /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<u... | 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
... | /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) {
ELFSeenGenericM... | 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),... | /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*... | 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 th... | 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 0... | /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 s... | 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)
cm... | /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 ... | /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) # im... | /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(%r... | /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::ValueE... | 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), %ra... | /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 case... | 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 0x1... | /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
... | 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... | 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
... | /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)
... | 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 0x32f45... | /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 (StoredHo... | 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 0x117c... | /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) {
... | 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,... | /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,... | /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"
"GGGGCAATTCA... | 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
p... | /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"
"CAGGGGC... | 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
p... | /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 remin... | 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, 0... | /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_... | 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), ... | /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, -0... | /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
lea... | /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 modifi... | 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)... | /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(... | /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... | 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 0... | /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... | 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), %r... | /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-... | 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 0x... | /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>>>, ... | 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
st... | 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, ... | /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) !=
... | 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 0... | /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(%... | /JKorbelRA[P]CMake/Source/cmArgumentParser.cxx |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.