name string | code string | asm string | file string |
|---|---|---|---|
llvm::SmallVectorTemplateBase<llvm::cl::Option*, true>::push_back(llvm::cl::Option*) | void push_back(ValueParamT Elt) {
const T *EltPtr = reserveForParamAndGetAddress(Elt);
memcpy(reinterpret_cast<void *>(this->end()), EltPtr, sizeof(T));
this->set_size(this->size() + 1);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %edx
cmpl 0xc(%rdi), %edx
jae 0x5f1e1
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
movq %r14, (%rax,%rcx,8)
incl 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
incq %rdx
leaq 0x10(%rbx), %rsi
movl $0x8, %ecx
movq %rbx, %rdi
callq 0x56f14
jmp... | /llvm/ADT/SmallVector.h |
llvm::ConvertUTF8toWide(unsigned int, llvm::StringRef, char*&, unsigned char const*&) | bool ConvertUTF8toWide(unsigned WideCharWidth, llvm::StringRef Source,
char *&ResultPtr, const UTF8 *&ErrorPtr) {
assert(WideCharWidth == 1 || WideCharWidth == 2 || WideCharWidth == 4);
ConversionResult result = conversionOK;
// Copy the character span over.
if (WideCharWidth == 1) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %r14
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r15
cmpl $0x4, %edi
je 0x5fb48
cmpl $0x2, %edi
je 0x5fb23
xorl %ebp, %ebp
cmpl $0x1, %edi
jne 0x5fb90
movq %rsp, %rdi
movq %r15, (%rdi)
leaq (%r15,%r12), %rsi
callq 0x75685
testb %al, %al
j... | /Support/ConvertUTFWrapper.cpp |
(anonymous namespace)::DebugCounterOwner::~DebugCounterOwner() | ~DebugCounterOwner() {
if (ShouldPrintCounter)
print(dbgs());
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x61(%rdi)
jne 0x60906
callq 0x5ff49
movq %rbx, %rdi
movq %rax, %rsi
callq 0x60bca
leaq 0x210(%rbx), %r14
leaq 0x4572cc(%rip), %r15 # 0x4b7be0
addq $0x10, %r15
movq %r15, 0x210(%rbx)
movq 0x2c0(%rbx), %rax
testq %rax, %rax
je 0x6093c
leaq 0x2b0(%rbx), %rdi
... | /Support/DebugCounter.cpp |
llvm::DebugCounter::getCounterInfo[abi:cxx11](unsigned int) const | std::pair<std::string, std::string> getCounterInfo(unsigned ID) const {
return std::make_pair(RegisteredCounters[ID], Counters.lookup(ID).Desc);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
leaq 0x4(%rsp), %rax
movl %edx, (%rax)
leal -0x1(%rdx), %r14d
shlq $0x5, %r14
addq 0x48(%rsi), %r14
leaq 0x8(%rsp), %rdi
movq %rax, %rdx
callq 0x61720
leaq 0x20(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x617f2
movq 0x20(%r15), %r... | /llvm/Support/DebugCounter.h |
llvm::DenseMapBase<llvm::DenseMap<unsigned int, llvm::DebugCounter::CounterInfo, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::DebugCounter::CounterInfo>>, unsigned int, llvm::DebugCounter::CounterInfo, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned ... | value_type& FindAndConstruct(const KeyT &Key) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return *TheBucket;
return *InsertIntoBucket(TheBucket, Key);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x6185c
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x61c7f
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x61c8a
movl (%rbx), %ecx
movl %ecx, (%rax)
leaq 0x30(%r... | /llvm/ADT/DenseMap.h |
llvm::ErrorList::log(llvm::raw_ostream&) const | void log(raw_ostream &OS) const override {
OS << "Multiple errors:\n";
for (const auto &ErrPayload : Payloads) {
ErrPayload->log(OS);
OS << "\n";
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2c1231(%rip), %rsi # 0x323820
movl $0x11, %edx
movq %rbx, %rdi
callq 0x577a6
movq 0x8(%r14), %r15
movq 0x10(%r14), %r12
cmpq %r12, %r15
je 0x62635
leaq 0x2ee940(%rip), %r14 # 0x350f50
movq (%r15), %rdi
movq (%rdi), %rax
... | /llvm/Support/Error.h |
llvm::ManagedStaticBase::RegisterManagedStatic(void* (*)(), void (*)(void*)) const | void ManagedStaticBase::RegisterManagedStatic(void *(*Creator)(),
void (*Deleter)(void*)) const {
assert(Creator);
if (llvm_is_multithreaded()) {
std::lock_guard<std::recursive_mutex> Lock(*getManagedStaticMutex());
if (!Ptr.load(std::memory_order_relaxed)) {
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x4781fb(%rip), %rdi # 0x4db360
callq 0x3c400
testl %eax, %eax
jne 0x631a3
movq (%rbx), %rax
testq %rax, %rax
jne 0x63192
callq *%r15
movq %rax, (%rbx)
movq %r14, 0x8(%rbx)
movq 0x4b3a01(%rip), %rax # 0x516b88
movq %rax, 0x10(%r... | /Support/ManagedStatic.cpp |
operator new(unsigned long, (anonymous namespace)::NamedBufferAlloc const&) | void *operator new(size_t N, const NamedBufferAlloc &Alloc) {
SmallString<256> NameBuf;
StringRef NameRef = Alloc.Name.toStringRef(NameBuf);
// We use malloc() and manually handle it returning null instead of calling
// operator new because we need all uses of NamedBufferAlloc to be
// deallocated with a cal... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x120, %rsp # imm = 0x120
movq %rdi, %r14
leaq 0x20(%rsp), %r13
movq %r13, -0x18(%r13)
movq $0x0, -0x10(%r13)
movq $0x100, -0x8(%r13) # imm = 0x100
movq (%rsi), %rdi
leaq 0x8(%rsp), %rsi
callq 0x57944
movq %rax, %r12
movq %rdx, %r15
leaq (%r14... | /Support/MemoryBuffer.cpp |
llvm::MD5::body(llvm::ArrayRef<unsigned char>) | const uint8_t *MD5::body(ArrayRef<uint8_t> Data) {
const uint8_t *ptr;
MD5_u32plus a, b, c, d;
MD5_u32plus saved_a, saved_b, saved_c, saved_d;
unsigned long Size = Data.size();
ptr = Data.data();
a = InternalState.a;
b = InternalState.b;
c = InternalState.c;
d = InternalState.d;
do {
saved_a ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rax
movl (%rdi), %r10d
movl 0x4(%rdi), %r9d
movl 0x8(%rdi), %r8d
movq %rdi, -0x60(%rsp)
movl 0xc(%rdi), %ecx
movq %rax, -0x18(%rsp)
movq %r9, -0x28(%rsp)
movq %rdx, (%rsp)
movl %r10d, -0x3c(%rsp)
movl %r8d, %esi
movl %ecx, %edx
mov... | /Support/MD5.cpp |
writeWithCommas(llvm::raw_ostream&, llvm::ArrayRef<char>) | static void writeWithCommas(raw_ostream &S, ArrayRef<char> Buffer) {
assert(!Buffer.empty());
ArrayRef<char> ThisGroup;
int InitialDigits = ((Buffer.size() - 1) % 3) + 1;
ThisGroup = Buffer.take_front(InitialDigits);
S.write(ThisGroup.data(), ThisGroup.size());
Buffer = Buffer.drop_front(InitialDigits);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x1(%rdx), %r12
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
movq %r12, %rax
mulq %r13
shrq %rdx
leaq (%rdx,%rdx,2), %rax
negq %rax
leaq (%r15,%rax), %rbp
decq %rbp
incq %r... | /Support/NativeFormatting.cpp |
llvm::StringSaver::save(llvm::StringRef) | StringRef StringSaver::save(StringRef S) {
char *P = Alloc.Allocate<char>(S.size() + 1);
if (!S.empty())
memcpy(P, S.data(), S.size());
P[S.size()] = '\0';
return StringRef(P, S.size());
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq (%rdi), %rdi
leaq 0x1(%rdx), %rsi
xorl %edx, %edx
callq 0x6515a
movq %rax, %r15
testq %rbx, %rbx
je 0x65149
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x3c370
movb $0x0, (%r15,%rbx)
movq %r15, %rax
movq %rbx, %rdx
popq %rbx
popq %r14
popq ... | /Support/StringSaver.cpp |
llvm::StringRef::find_first_of(llvm::StringRef, unsigned long) const | StringRef::size_type StringRef::find_first_of(StringRef Chars,
size_t From) const {
std::bitset<1 << CHAR_BIT> CharBits;
for (char C : Chars)
CharBits.set((unsigned char)C);
for (size_type i = std::min(From, Length), e = Length; i != e; ++i)
if (CharBits.test... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
testq %rdx, %rdx
je 0x656f5
xorl %eax, %eax
movzbl (%rsi,%rax), %ecx
movl $0x1, %edi
shlq %cl, %rdi
shrl $0x6, %ecx
orq %rdi, (%rsp,%rcx,8)
incq %rax
c... | /Support/StringRef.cpp |
llvm::StringRef::split(llvm::SmallVectorImpl<llvm::StringRef>&, char, int, bool) const | void StringRef::split(SmallVectorImpl<StringRef> &A, char Separator,
int MaxSplit, bool KeepEmpty) const {
StringRef S = *this;
// Count down from MaxSplit. When MaxSplit is -1, this will just split
// "forever". This doesn't support splitting more than 2^31 times
// intentionally; if we ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r12d
movl %edx, %r13d
movq %rsi, 0x10(%rsp)
movq (%rdi), %r15
movq 0x8(%rdi), %r14
incl %r12d
movl %r8d, 0xc(%rsp)
movl %r8d, %ebp
xorb $0x1, %bpl
decl %r12d
je 0x65aac
testq %r14, %r14
je 0x65a66
movq %r15, %rdi
movl %r13d, ... | /Support/StringRef.cpp |
llvm::APInt::operator<<=(unsigned int) | APInt &operator<<=(unsigned ShiftAmt) {
assert(ShiftAmt <= BitWidth && "Invalid shift amount");
if (isSingleWord()) {
if (ShiftAmt == BitWidth)
U.VAL = 0;
else
U.VAL <<= ShiftAmt;
return clearUnusedBits();
}
shlSlowCase(ShiftAmt);
return *this;
} | pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %eax
cmpl $0x40, %eax
ja 0x660aa
movq (%rbx), %rdx
movl %esi, %ecx
shlq %cl, %rdx
xorl %ecx, %ecx
cmpl %esi, %eax
cmovneq %rdx, %rcx
movq %rcx, (%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x661d4
movq %rbx, %rdi
callq 0x72674
movq %rbx, %rax
popq %rbx
retq
nop
| /llvm/ADT/APInt.h |
void llvm::SmallVectorImpl<unsigned int>::resizeImpl<false>(unsigned long) | size_t size() const { return Size; } | movl 0x8(%rdi), %eax
cmpq %rsi, %rax
je 0x664f7
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
ja 0x664ec
movl 0xc(%r14), %eax
cmpq %rbx, %rax
jae 0x664c7
leaq 0x10(%r14), %rsi
movl $0x4, %ecx
movq %r14, %rdi
movq %rbx, %rdx
callq 0x56f14
movl 0x8(%r14), %eax
cmpq %rbx, %rax
je 0x664ec
shlq $0x2, %rax... | /llvm/ADT/SmallVector.h |
llvm::TimerGroup::TimerGroup(llvm::StringRef, llvm::StringRef) | TimerGroup::TimerGroup(StringRef Name, StringRef Description)
: Name(Name.begin(), Name.end()),
Description(Description.begin(), Description.end()) {
// Add the group to TimerGroupList.
sys::SmartScopedLock<true> L(*TimerLock);
if (TimerGroupList)
TimerGroupList->Prev = &Next;
Next = TimerGroupList;
... | pushq %r15
pushq %r14
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %rbx
addq %rsi, %rdx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
callq 0x56cf6
leaq 0x20(%rbx), %rdi
addq %r15, %r14
leaq 0x30(%rbx), %rax
movq %rax, 0x20(%rbx)
movq %r15, %rsi
movq %r14, %rdx
callq 0x56cf6
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx... | /Support/Timer.cpp |
llvm::TimerGroup::PrintRecord::PrintRecord(llvm::TimeRecord const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | PrintRecord(const TimeRecord &Time, const std::string &Name,
const std::string &Description)
: Time(Time), Name(Name), Description(Description) {} | pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdi, %r14
movq 0x20(%rsi), %rax
movq %rax, 0x20(%rdi)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups %xmm1, 0x10(%rdi)
movups %xmm0, (%rdi)
addq $0x28, %rdi
leaq 0x38(%r14), %rax
movq %rax, 0x28(%r14)
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
addq %rsi, %rdx
cal... | /llvm/Support/Timer.h |
llvm::detail::IEEEFloat::assign(llvm::detail::IEEEFloat const&) | void IEEEFloat::assign(const IEEEFloat &rhs) {
assert(semantics == rhs.semantics);
sign = rhs.sign;
category = rhs.category;
exponent = rhs.exponent;
if (isFiniteNonZero() || category == fcNaN)
copySignificand(rhs);
} | movb 0x14(%rsi), %al
andb $0x8, %al
movb 0x14(%rdi), %cl
andb $-0x9, %cl
orb %al, %cl
movb %cl, 0x14(%rdi)
movb 0x14(%rsi), %al
movl %eax, %edx
andb $0x7, %dl
andb $-0x8, %cl
orb %dl, %cl
movb %cl, 0x14(%rdi)
movl 0x10(%rsi), %ecx
movl %ecx, 0x10(%rdi)
testb $0x6, %al
setne %al
cmpb $0x3, %dl
setne %cl
cmpb $0x1, %dl
j... | /Support/APFloat.cpp |
llvm::detail::IEEEFloat::operator=(llvm::detail::IEEEFloat&&) | IEEEFloat &IEEEFloat::operator=(IEEEFloat &&rhs) {
freeSignificand();
semantics = rhs.semantics;
significand = rhs.significand;
exponent = rhs.exponent;
category = rhs.category;
sign = rhs.sign;
rhs.semantics = &semBogus;
return *this;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
movl 0x8(%rax), %eax
addl $-0x40, %eax
cmpl $0xffffff7f, %eax # imm = 0xFFFFFF7F
ja 0x69c6c
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x69c6c
callq 0x3c180
movq (%r14), %rax
movq %rax, (%rbx)
movq 0x8(%r14), %rax
movq %rax, 0x8(%rbx... | /Support/APFloat.cpp |
llvm::detail::IEEEFloat::shiftSignificandRight(unsigned int) | lostFraction IEEEFloat::shiftSignificandRight(unsigned int bits) {
/* Our exponent should not overflow. */
assert((ExponentType) (exponent + bits) >= exponent);
exponent += bits;
return shiftRight(significandParts(), partCount(), bits);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
addl %esi, 0x10(%rdi)
movq (%rdi), %rax
movl 0x8(%rax), %r15d
leal -0x40(%r15), %eax
cmpl $-0x80, %eax
jae 0x6abbf
movq 0x8(%r14), %r14
jmp 0x6abc3
addq $0x8, %r14
addl $0x40, %r15d
shrl $0x6, %r15d
movq %r14, %rdi
movl %r15d, %esi
m... | /Support/APFloat.cpp |
llvm::detail::IEEEFloat::divideSpecials(llvm::detail::IEEEFloat const&) | IEEEFloat::opStatus IEEEFloat::divideSpecials(const IEEEFloat &rhs) {
switch (PackCategoriesIntoKey(category, rhs.category)) {
default:
llvm_unreachable(nullptr);
case PackCategoriesIntoKey(fcZero, fcNaN):
case PackCategoriesIntoKey(fcNormal, fcNaN):
case PackCategoriesIntoKey(fcInfinity, fcNaN):
ass... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x14(%rdi), %ecx
movl %ecx, %eax
andl $0x7, %eax
movzbl 0x14(%rsi), %edx
andl $0x7, %edx
leal (%rdx,%rax,4), %edx
xorl %eax, %eax
leaq 0x2b8eed(%rip), %rsi # 0x324384
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
movq %rbx, %rdi
movq %r14,... | /Support/APFloat.cpp |
llvm::detail::scalbn(llvm::detail::IEEEFloat, int, llvm::RoundingMode) | IEEEFloat scalbn(IEEEFloat X, int Exp, IEEEFloat::roundingMode RoundingMode) {
auto MaxExp = X.getSemantics().maxExponent;
auto MinExp = X.getSemantics().minExponent;
// If Exp is wildly out-of-scale, simply adding it to X.exponent will
// overflow; clamp it to a safe range before adding, but ensure that the r... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %rax
movl 0x4(%rax), %esi
notl %esi
addl (%rax), %esi
movl 0x8(%rax), %eax
leal (%rsi,%rax), %r8d
addl %esi, %eax
incl %eax
movl $0xfffffffe, %esi # imm = 0xFFFFFFFE
subl %r8d, %esi
cmpl %edx, %eax
cmovgel %edx, %eax
cmpl %edx, %esi
cmovgl %esi, %eax
m... | /Support/APFloat.cpp |
llvm::detail::IEEEFloat::convertToInteger(llvm::MutableArrayRef<unsigned long>, unsigned int, bool, llvm::RoundingMode, bool*) const | IEEEFloat::opStatus
IEEEFloat::convertToInteger(MutableArrayRef<integerPart> parts,
unsigned int width, bool isSigned,
roundingMode rounding_mode, bool *isExact) const {
opStatus fs;
fs = convertToSignExtendedInteger(parts, width, isSigned, rounding_mode,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movl %ecx, %ebx
movq %rsi, %r14
movq %rdi, %r12
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
callq 0x6ba42
movl %eax, %r15d
cmpl $0x1, %eax
jne 0x6bd37
leal 0x3f(%rbx), %r13d
shrl $0x6, %r13d
movb 0x14(%r12), %al
movl %eax, %ecx
and... | /Support/APFloat.cpp |
llvm::detail::IEEEFloat::convertFromUnsignedParts(unsigned long const*, unsigned int, llvm::RoundingMode) | IEEEFloat::opStatus IEEEFloat::convertFromUnsignedParts(
const integerPart *src, unsigned int srcCount, roundingMode rounding_mode) {
unsigned int omsb, precision, dstCount;
integerPart *dst;
lostFraction lost_fraction;
category = fcNormal;
omsb = APInt::tcMSB(src, srcCount) + 1;
dst = significandParts... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, 0xc(%rsp)
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
movb 0x14(%rdi), %al
andb $-0x8, %al
orb $0x2, %al
movb %al, 0x14(%rdi)
movq %rsi, %rdi
movl %edx, %esi
callq 0x750d4
leal 0x1(%rax), %ecx
movq (%r14), %rdx
movl 0x8(%r... | /Support/APFloat.cpp |
llvm::detail::IEEEFloat::convertFloat8E5M2APFloatToAPInt() const | APInt IEEEFloat::convertFloat8E5M2APFloatToAPInt() const {
assert(partCount() == 1);
return convertIEEEFloatToAPInt<semFloat8E5M2>();
} | pushq %rbx
movq %rdi, %rbx
movzbl 0x14(%rsi), %eax
testb $0x6, %al
sete %dl
movl %eax, %ecx
andl $0x7, %ecx
cmpl $0x3, %ecx
sete %dil
orb %dl, %dil
jne 0x6c4e2
movslq 0x10(%rsi), %rcx
addq $0xf, %rcx
movq (%rsi), %rdx
movl 0x8(%rdx), %edx
addl $-0x40, %edx
cmpl $-0x80, %edx
jae 0x6c4f4
movq 0x8(%rsi), %rsi
jmp 0x6c4f8
... | /Support/APFloat.cpp |
llvm::detail::IEEEFloat::initFromFloat6E2M3FNAPInt(llvm::APInt const&) | bool isSingleWord() const { return BitWidth <= APINT_BITS_PER_WORD; } | movl 0x8(%rsi), %ecx
cmpq $0x41, %rcx
jb 0x6d88c
movq (%rsi), %rsi
movq (%rsi), %rax
andl $0x7, %eax
addq $0x3f, %rcx
shrq $0x6, %rcx
decl %ecx
movq (%rsi,%rcx,8), %rdx
movl %edx, %ecx
shrl $0x3, %ecx
andl $0x3, %ecx
leaq 0x2b6c65(%rip), %rsi # 0x324514
movq %rsi, (%rdi)
movb 0x14(%rdi), %sil
shrb $0x2, %dl
andb $0x... | /llvm/ADT/APInt.h |
llvm::APFloat::makeSmallest(bool) | void makeSmallest(bool Neg) {
APFLOAT_DISPATCH_ON_SEMANTICS(makeSmallest(Neg));
} | pushq %rbx
movq %rdi, %rbx
leaq 0x2b47b7(%rip), %rax # 0x32443c
cmpq %rax, 0x8(%rdi)
je 0x6fc9c
addq $0x8, %rbx
movzbl %sil, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x6db14
movq 0x10(%rbx), %rdi
movzbl %sil, %esi
callq 0x6fc7a
movq 0x10(%rbx), %rdi
addq $0x20, %rdi
xorl %esi, %esi
popq %rbx
jmp 0x6ee40
nop
| /llvm/ADT/APFloat.h |
llvm::APInt::Profile(llvm::FoldingSetNodeID&) const | void APInt::Profile(FoldingSetNodeID& ID) const {
ID.AddInteger(BitWidth);
if (isSingleWord()) {
ID.AddInteger(U.VAL);
return;
}
unsigned NumWords = getNumWords();
for (unsigned i = 0; i < NumWords; ++i)
ID.AddInteger(U.pVal[i]);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %esi
movq %rbx, %rdi
callq 0x75350
movl 0x8(%r14), %r12d
cmpq $0x40, %r12
ja 0x70d92
movq (%r14), %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0x75350
shrq $0x20, %r14
movq %rbx, %rdi
movl %r14d, %esi
popq %rbx
popq %r... | /Support/APInt.cpp |
llvm::APInt::operator-=(unsigned long) | bool isSingleWord() const { return BitWidth <= APINT_BITS_PER_WORD; } | movl 0x8(%rdi), %eax
cmpq $0x40, %rax
ja 0x7108f
subq %rsi, (%rdi)
jmp 0x661d4
movq (%rdi), %rcx
addq $0x3f, %rax
shrq $0x6, %rax
decq %rax
xorl %edx, %edx
subq %rsi, (%rcx,%rdx,8)
jae 0x661d4
leaq 0x1(%rdx), %r8
movl $0x1, %esi
cmpq %rdx, %rax
movq %r8, %rdx
je 0x661d4
jmp 0x7109f
| /llvm/ADT/APInt.h |
llvm::APInt::tcMultiplyPart(unsigned long*, unsigned long const*, unsigned long, unsigned long, unsigned int, unsigned int, bool) | int APInt::tcMultiplyPart(WordType *dst, const WordType *src,
WordType multiplier, WordType carry,
unsigned srcParts, unsigned dstParts,
bool add) {
// Otherwise our writes of DST kill our later reads of SRC.
assert(dst <= src || dst >= s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpl %r9d, %r8d
movl %r9d, -0xc(%rsp)
movl %r9d, %ebx
movq %r8, -0x8(%rsp)
cmovbl %r8d, %ebx
testl %ebx, %ebx
je 0x71328
movb 0x38(%rsp), %r8b
movl %edx, %r10d
movq %rdx, %r11
shrq $0x20, %r11
movl %ebx, %ebx
xorl %r14d, %r14d
testq %rdx, %rdx
je 0x71303... | /Support/APInt.cpp |
llvm::APInt::zext(unsigned int) const | APInt APInt::zext(unsigned width) const {
assert(width >= BitWidth && "Invalid APInt ZeroExtend request");
if (width <= APINT_BITS_PER_WORD)
return APInt(width, U.VAL);
if (width == BitWidth)
return *this;
APInt Result(getMemory(getNumWords(width)), width);
// Copy words.
std::memcpy(Result.U.pV... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x40, %edx
ja 0x71589
movq (%r14), %rdx
movq %rbx, %rdi
movl %ebp, %esi
xorl %ecx, %ecx
callq 0x66024
jmp 0x715fe
movl 0x8(%r14), %r13d
cmpl %ebp, %r13d
jne 0x7159f
movq %rbx, %rdi
movq %r1... | /Support/APInt.cpp |
llvm::APInt::countLeadingOnesSlowCase() const | unsigned APInt::countLeadingOnesSlowCase() const {
unsigned highWordBits = BitWidth % APINT_BITS_PER_WORD;
unsigned shift;
if (!highWordBits) {
highWordBits = APINT_BITS_PER_WORD;
shift = 0;
} else {
shift = APINT_BITS_PER_WORD - highWordBits;
}
int i = getNumWords() - 1;
unsigned Count = llvm... | movl 0x8(%rdi), %r8d
movl %r8d, %r10d
andl $0x3f, %r10d
movb $0x40, %cl
subb %r10b, %cl
movq %r8, %rdx
addq $0x3f, %rdx
shrq $0x6, %rdx
testl %r10d, %r10d
movl $0x40, %r9d
cmovnel %r10d, %r9d
movq (%rdi), %rsi
movq -0x8(%rsi,%rdx,8), %rax
movzbl %cl, %ecx
cmovel %r10d, %ecx
shlq %cl, %rax
xorq $-0x1, %rax
je 0x71c04
bs... | /Support/APInt.cpp |
llvm::APInt::urem(unsigned long) const | uint64_t APInt::urem(uint64_t RHS) const {
assert(RHS != 0 && "Remainder by zero?");
if (isSingleWord())
return U.VAL % RHS;
// Get some facts about the LHS
unsigned lhsWords = getNumWords(getActiveBits());
// Check the degenerate cases
if (lhsWords == 0)
// 0 % Y ===> 0
return 0;
if (RHS =... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, 0x8(%rsp)
movl 0x8(%rdi), %ebp
cmpl $0x40, %ebp
ja 0x73450
movq (%r14), %rax
xorl %edx, %edx
divq %rbx
movq %rdx, %rax
jmp 0x7346e
movq %r14, %rdi
callq 0x71b6c
movl %ebp, %r15d
subl %eax, %r15d
sete %al
cmpq $0x1, %... | /Support/APInt.cpp |
llvm::APInt::setBits(unsigned int, unsigned int) | void setBits(unsigned loBit, unsigned hiBit) {
assert(hiBit <= BitWidth && "hiBit out of range");
assert(loBit <= BitWidth && "loBit out of range");
assert(loBit <= hiBit && "loBit greater than hiBit");
if (loBit == hiBit)
return;
if (loBit < APINT_BITS_PER_WORD && hiBit <= APINT_BITS_PER_WORD... | cmpl %edx, %esi
je 0x75326
cmpl $0x40, %esi
setae %al
cmpl $0x41, %edx
setae %cl
orb %al, %cl
jne 0x714d4
movl %esi, %ecx
orl $0x40, %ecx
subl %edx, %ecx
movq $-0x1, %rax
shrq %cl, %rax
movl %esi, %ecx
shlq %cl, %rax
cmpl $0x40, 0x8(%rdi)
ja 0x75320
orq %rax, (%rdi)
retq
movq (%rdi), %rcx
orq %rax, (%rcx)
retq
| /llvm/ADT/APInt.h |
llvm::StoreIntToMemory(llvm::APInt const&, unsigned char*, unsigned int) | void llvm::StoreIntToMemory(const APInt &IntVal, uint8_t *Dst,
unsigned StoreBytes) {
assert((IntVal.getBitWidth()+7)/8 >= StoreBytes && "Integer too small!");
const uint8_t *Src = (const uint8_t *)IntVal.getRawData();
if (sys::IsLittleEndianHost) {
// Little-endian host - the sou... | movq %rdi, %rax
cmpl $0x41, 0x8(%rdi)
jb 0x75333
movq (%rax), %rax
movl %edx, %edx
movq %rsi, %rdi
movq %rax, %rsi
jmp 0x3c370
| /Support/APInt.cpp |
llvm::APInt::abs() const | APInt abs() const {
if (isNegative())
return -(*this);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0x8(%rsi), %r14d
leal -0x1(%r14), %eax
movl %eax, %ecx
shrl $0x6, %ecx
cmpq $0x41, %r14
movq (%rsi), %r15
leaq (%r15,%rcx,8), %rcx
cmovbq %rsi, %rcx
movq (%rcx), %rcx
btq %rax, %rcx
jae 0x7541b
movl %r14d, 0x8(%rsp)
cmpl $0x40, %r14d
ja 0x75425
movq... | /llvm/ADT/APInt.h |
llvm::isLegalUTF8(unsigned char const*, int) | static Boolean isLegalUTF8(const UTF8 *source, int length) {
UTF8 a;
const UTF8 *srcptr = source+length;
switch (length) {
default: return false;
/* Everything else falls through when "true"... */
case 4: if ((a = (*--srcptr)) < 0x80 || a > 0xBF) return false;
case 3: if ((a = (*--srcptr... | leal -0x1(%rsi), %ecx
cmpl $0x3, %ecx
ja 0x75600
movslq %esi, %rax
addq %rdi, %rax
leaq 0x2af3ea(%rip), %rdx # 0x3249bc
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movb (%rdi), %al
cmpb $-0x3e, %al
jl 0x75600
cmpb $-0xb, %al
setb %al
retq
cmpb $-0x41, -0x1(%rax)
jg 0x75600
decq %rax
cmpb $-0x41, -0x1(%rax)... | /Support/ConvertUTF.cpp |
clang::AnalysisDeclContext::getUnoptimizedCFG() | CFG *AnalysisDeclContext::getUnoptimizedCFG() {
if (!builtCompleteCFG) {
SaveAndRestore NotPrune(cfgBuildOptions.PruneTriviallyFalseEdges, false);
completeCFG =
CFG::buildCFG(D, getBody(), &D->getASTContext(), cfgBuildOptions);
// Even when the cfg is not successfully built, we don't
// want t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x71(%rdi)
jne 0x760d9
leaq 0x28(%rbx), %r14
movb 0x58(%rbx), %bpl
movb $0x0, 0x58(%rbx)
movq 0x8(%rbx), %r15
leaq 0xf(%rsp), %rsi
movq %rbx, %rdi
callq 0x75de0
movq %rax, %r12
movq 0x8(%rbx), %rdi
callq 0xc0b9... | /Analysis/AnalysisDeclContext.cpp |
addParentsForSyntheticStmts(clang::CFG const*, clang::ParentMap&) | static void addParentsForSyntheticStmts(const CFG *TheCFG, ParentMap &PM) {
if (!TheCFG)
return;
for (CFG::synthetic_stmt_iterator I = TheCFG->synthetic_stmt_begin(),
E = TheCFG->synthetic_stmt_end();
I != E; ++I) {
PM.setParent(I->first, PM.getParent(I->second));... | testq %rdi, %rdi
je 0x7616c
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r12
callq 0x76360
movl 0x68(%r12), %r13d
shlq $0x4, %r13
addq 0x58(%r12), %r13
cmpq %r13, %rax
je 0x7615e
movq %rax, %r14
movq %rdx, %r15
movl $0x1000, %ebp # imm = 0x1000
movq ... | /Analysis/AnalysisDeclContext.cpp |
clang::AnalysisDeclContext::getParentMap() | ParentMap &AnalysisDeclContext::getParentMap() {
if (!PM) {
PM.reset(new ParentMap(getBody()));
if (const auto *C = dyn_cast<CXXConstructorDecl>(getDecl())) {
for (const auto *I : C->inits()) {
PM->addStmt(I->getInit());
}
}
if (builtCFG)
addParentsForSyntheticStmts(getCFG(),... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x78(%rdi), %rbx
cmpq $0x0, 0x78(%rdi)
jne 0x76244
movq %rdi, %r14
movl $0x8, %edi
callq 0x3c390
movq %rax, %r15
leaq 0x7(%rsp), %rsi
movq %r14, %rdi
callq 0x75de0
movq %r15, %rdi
movq %rax, %rsi
callq 0x201044
movq %rbx, %rdi
movq %r15, %rsi
callq 0x765b4
mov... | /Analysis/AnalysisDeclContext.cpp |
clang::StmtIteratorImpl<clang::StmtIterator, clang::Stmt*&>::operator++() | DERIVED& operator++() {
if (inStmt())
++stmt;
else if (getVAPtr())
NextVA();
else
NextDecl();
return static_cast<DERIVED&>(*this);
} | pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
testb $0x3, %al
je 0x763c7
movq %rbx, %rdi
cmpq $0x4, %rax
jae 0x763cd
movl $0x1, %esi
callq 0x21023a
jmp 0x763d2
addq $0x8, (%rbx)
jmp 0x763d2
callq 0x21016c
movq %rbx, %rax
popq %rbx
retq
nop
| /clang/AST/StmtIterator.h |
(anonymous namespace)::ASTMaker::findMemberField(clang::RecordDecl const*, llvm::StringRef) | ValueDecl *ASTMaker::findMemberField(const RecordDecl *RD, StringRef Name) {
CXXBasePaths Paths(
/* FindAmbiguities=*/false,
/* RecordPaths=*/false,
/* DetectVirtual=*/ false);
const IdentifierInfo &II = C.Idents.get(Name);
DeclarationName DeclName = C.DeclarationNames.getIdentifier(&II);
De... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x180, %rsp # imm = 0x180
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
leaq 0x8(%rsp), %rdi
xorl %ebx, %ebx
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x781e6
movq (%r13), %rax
movq 0x4380(%rax), %rdi
movq %r15, %rsi
m... | /Analysis/BodyFarm.cpp |
llvm::SmallVectorTemplateBase<clang::Expr*, true>::push_back(clang::Expr*) | void push_back(ValueParamT Elt) {
const T *EltPtr = reserveForParamAndGetAddress(Elt);
memcpy(reinterpret_cast<void *>(this->end()), EltPtr, sizeof(T));
this->set_size(this->size() + 1);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %edx
cmpl 0xc(%rdi), %edx
jae 0x77eef
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
movq %r14, (%rax,%rcx,8)
incl 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
incq %rdx
leaq 0x10(%rbx), %rsi
movl $0x8, %ecx
movq %rbx, %rdi
callq 0x56f14
jmp... | /llvm/ADT/SmallVector.h |
create_call_once_funcptr_call(clang::ASTContext&, (anonymous namespace)::ASTMaker, clang::ParmVarDecl const*, llvm::ArrayRef<clang::Expr*>) | static CallExpr *create_call_once_funcptr_call(ASTContext &C, ASTMaker M,
const ParmVarDecl *Callback,
ArrayRef<Expr *> CallArgs) {
QualType Ty = Callback->getType();
DeclRefExpr *Call = M.makeDeclRefExpr(Callback);
Exp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %r13
movq %rdi, %r15
movq %rsp, %rdi
movq %rsi, (%rdi)
movq 0x30(%rdx), %rbp
movq %rdx, %rsi
xorl %edx, %edx
callq 0x77c0a
movq %rax, %r12
movq %rbp, %rax
andq $-0x10, %rax
movq (%rax), %rdi
movq 0x8(%... | /Analysis/BodyFarm.cpp |
llvm::SmallDenseMap<clang::QualType, clang::CXXBasePaths::IsVirtBaseAndNumberNonVirtBases, 8u, llvm::DenseMapInfo<clang::QualType, void>, llvm::detail::DenseMapPair<clang::QualType, clang::CXXBasePaths::IsVirtBaseAndNumberNonVirtBases>>::init(unsigned int) | void init(unsigned InitBuckets) {
Small = true;
if (InitBuckets > InlineBuckets) {
Small = false;
new (getLargeRep()) LargeRep(allocateBuckets(InitBuckets));
}
this->BaseT::initEmpty();
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
movl %eax, %ecx
orl $0x1, %ecx
movl %ecx, (%rdi)
cmpl $0x9, %esi
jb 0x78378
movl %esi, %ebp
andl $-0x2, %eax
movl %eax, (%rbx)
movl %esi, %edi
shlq $0x4, %rdi
movl $0x8, %esi
callq 0x56dc3
movq %rax, 0x8(%rbx)
movl %ebp, 0x10(%rbx)
leaq 0x8(%rbx), %rax
... | /llvm/ADT/DenseMap.h |
clang::CFGBlock::addSuccessor(clang::CFGBlock::AdjacentBlock, clang::BumpVectorContext&) | void CFGBlock::addSuccessor(AdjacentBlock Succ,
BumpVectorContext &C) {
if (CFGBlock *B = Succ.getReachableBlock())
B->Preds.push_back(AdjacentBlock(this, Succ.isReachable()), C);
if (CFGBlock *UnreachableB = Succ.getPossiblyUnreachableBlock())
UnreachableB->Preds.push_back(Adja... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r12
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
testq %rsi, %rsi
je 0x79910
xorl %edx, %edx
testb $0x2, %bl
sete %dl
movq %rsp, %rdi
movq %r14, %rsi
callq 0x7985e
movq 0x40(%r15), %rax
cmpq 0x48(%r15), %rax
jb 0x79900
leaq 0x38(%r15... | /Analysis/CFG.cpp |
clang::BumpVector<clang::CFGBlock*>::grow(clang::BumpVectorContext&, unsigned long) | void BumpVector<T>::grow(BumpVectorContext &C, size_t MinSize) {
size_t CurCapacity = Capacity-Begin;
size_t CurSize = size();
size_t NewCapacity = 2*CurCapacity;
if (NewCapacity < MinSize)
NewCapacity = MinSize;
// Allocate the memory from the BumpPtrAllocator.
T *NewElts = C.getAllocator().template A... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %r12
movq (%rdi), %rax
movq 0x8(%rdi), %r14
subq %rax, %r12
subq %rax, %r14
sarq $0x2, %r12
cmpq %rdx, %r12
cmovbeq %rdx, %r12
movq (%rsi), %rdi
andq $-0x8, %rdi
leaq (,%r12,8), %rsi
movl $0x3, %edx
callq 0x6515a
movq %rax, %r15
mov... | /clang/Analysis/Support/BumpVector.h |
clang::CXXRecordDecl::bases() const | base_class_const_range bases() const {
return base_class_const_range(bases_begin(), bases_end());
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x79f9a
movq %rax, %r14
movq %rbx, %rdi
callq 0x79f9a
movq %rax, %r15
movq 0x68(%rbx), %rsi
leaq 0x60(%rsi), %rdi
callq 0x79ef0
movq 0x80(%rbx), %rax
movl 0x10(%rax), %eax
leaq (%rax,%rax,2), %rax
leaq (%r15,%rax,8), %rdx
movq %r14, %rax
popq %rbx
popq %r14
popq %r... | /clang/AST/DeclCXX.h |
(anonymous namespace)::CFGBuilder::VisitAttributedStmt(clang::AttributedStmt*, (anonymous namespace)::AddStmtChoice) | CFGBlock *CFGBuilder::VisitAttributedStmt(AttributedStmt *A,
AddStmtChoice asc) {
// AttributedStmts for [[likely]] can have arbitrary statements as children,
// and the current visitation order here would add the AttributedStmts
// for [[likely]] after the child nodes, w... | pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsi), %rax
movl (%rsi), %esi
movl %esi, %edx
shrl $0x8, %edx
leaq (%rbx,%rdx,8), %rcx
addq $0x10, %rcx
cmpl $0x100, %esi # imm = 0x100
jb 0x7aba2
shll $0x3, %edx
movq (%rax), %rsi
cmpw $0x26, 0x20(%rsi)
je 0x7aba2
add... | /Analysis/CFG.cpp |
(anonymous namespace)::CFGBuilder::VisitCXXBindTemporaryExpr(clang::CXXBindTemporaryExpr*, (anonymous namespace)::AddStmtChoice) | CFGBlock *CFGBuilder::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E,
AddStmtChoice asc) {
if (asc.alwaysAdd(*this, E)) {
autoCreateBlock();
appendStmt(Block, E);
findConstructionContexts(
ConstructionContextLayer::create(cfg->getBumpVectorContex... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
callq 0x7ec82
cmpl $0x1, %r15d
sete %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x7b803
cmpq $0x0, 0x10(%rbx)
jne 0x7b7c5
movq %rbx, %rdi
movl $0x1, %esi
callq 0x79d14
movq %rax, 0x10(%rbx)
movq 0x10(%rbx), %rsi
movq %rbx, %rdi
m... | /Analysis/CFG.cpp |
(anonymous namespace)::CFGBuilder::VisitCXXDeleteExpr(clang::CXXDeleteExpr*, (anonymous namespace)::AddStmtChoice) | CFGBlock *CFGBuilder::VisitCXXDeleteExpr(CXXDeleteExpr *DE,
AddStmtChoice asc) {
autoCreateBlock();
appendStmt(Block, DE);
QualType DTy = DE->getDestroyedType();
if (!DTy.isNull()) {
DTy = DTy.getNonReferenceType();
CXXRecordDecl *RD = Context->getBaseElementType... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x10(%rdi)
jne 0x7ba83
movq %r14, %rdi
movl $0x1, %esi
callq 0x79d14
movq %rax, 0x10(%r14)
movq 0x10(%r14), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x7ebf8
movq %rbx, %rdi
callq 0x12e5d6
cmpq $0x10, %rax
jb 0x7bb15
movq %rax, %r15
andq $-0x1... | /Analysis/CFG.cpp |
(anonymous namespace)::CFGBuilder::VisitDeclStmt(clang::DeclStmt*) | CFGBlock *CFGBuilder::VisitDeclStmt(DeclStmt *DS) {
// Check if the Decl is for an __label__. If so, elide it from the
// CFG entirely.
if (isa<LabelDecl>(*DS->decl_begin()))
return Block;
// This case also handles static_asserts.
if (DS->isSingleDecl())
return VisitDeclSubExpr(DS);
CFGBlock *B =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x8(%rsi), %rcx
movq %rsi, 0x8(%rsp)
movq 0x8(%rsi), %rax
testq %rax, %rax
cmoveq %rax, %rcx
movq %rax, %rdx
andq $-0x2, %rdx
movq %rdx, (%rsp)
addq $0x8, %rdx
testb $0x1, %al
cmoveq %rcx, %rdx
movq (%rdx), %rcx
movl... | /Analysis/CFG.cpp |
(anonymous namespace)::CFGBuilder::VisitDefaultStmt(clang::DefaultStmt*) | CFGBlock *CFGBuilder::VisitDefaultStmt(DefaultStmt *Terminator) {
if (Terminator->getSubStmt())
addStmt(Terminator->getSubStmt());
DefaultCaseBlock = Block;
if (!DefaultCaseBlock)
DefaultCaseBlock = createBlock();
// Default statements partition blocks, so this is the top of the basic block
// we w... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %rsi
testq %rsi, %rsi
je 0x7c3d0
movq %rbx, %rdi
movl $0x1, %edx
xorl %ecx, %ecx
callq 0x7a00a
movq 0x10(%rbx), %rax
movq %rax, 0x70(%rbx)
testq %rax, %rax
jne 0x7c3ee
movq %rbx, %rdi
movl $0x1, %esi
callq 0x79d14
movq %rax, 0x70(%rbx)
mo... | /Analysis/CFG.cpp |
(anonymous namespace)::CFGBuilder::VisitSwitchStmt(clang::SwitchStmt*) | CFGBlock *CFGBuilder::VisitSwitchStmt(SwitchStmt *Terminator) {
// "switch" is a control-flow statement. Thus we stop processing the current
// block.
CFGBlock *SwitchSuccessor = nullptr;
// Save local scope position because in case of condition variable ScopePos
// won't be restored when traversing AST.
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r15
movq %rdi, %rbx
testb $0x1, 0x1(%rsi)
jne 0x7e33d
xorl %esi, %esi
jmp 0x7e341
movq 0x18(%r15), %rsi
movq 0x80(%rbx), %r14
movl 0x88(%rbx), %ebp
testq %rsi, %rsi
je 0x7e35b
movq %rbx, %rdi
callq 0x7f060
movq %r15, %rdi
cal... | /Analysis/CFG.cpp |
(anonymous namespace)::CFGBuilder::addLocalScopeForDeclStmt(clang::DeclStmt*, (anonymous namespace)::LocalScope*) | LocalScope* CFGBuilder::addLocalScopeForDeclStmt(DeclStmt *DS,
LocalScope* Scope) {
if (!BuildOpts.AddImplicitDtors && !BuildOpts.AddLifetime &&
!BuildOpts.AddScopes)
return Scope;
for (auto *DI : DS->decls())
if (VarDecl *VD = dyn_cast<VarDecl>(DI))
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x148(%rdi), %rcx
cmpb $0x0, 0x33(%rcx)
jne 0x7f4f9
cmpb $0x0, 0x34(%rcx)
jne 0x7f4f9
cmpb $0x1, 0x37(%rcx)
jne 0x7f555
movq 0x8(%r14), %rcx
testb $0x1, %cl
jne 0x7f517
leaq 0x8(%r14), %r15
addq $0x10, %r14
testq %rcx, %rcx
cmoveq %rc... | /Analysis/CFG.cpp |
(anonymous namespace)::CFGBuilder::addLocalScopeForVarDecl(clang::VarDecl*, (anonymous namespace)::LocalScope*) | LocalScope* CFGBuilder::addLocalScopeForVarDecl(VarDecl *VD,
LocalScope* Scope) {
if (!BuildOpts.AddImplicitDtors && !BuildOpts.AddLifetime &&
!BuildOpts.AddScopes)
return Scope;
// Check if variable is local.
if (!VD->hasLocalStorage())
return Scope;... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x148(%rdi), %rax
cmpb $0x0, 0x33(%rax)
jne 0x7f58d
cmpb $0x0, 0x34(%rax)
jne 0x7f58d
cmpb $0x1, 0x37(%rax)
jne 0x7f695
movq %r15, %rdi
callq 0x763d8
testb %al, %al
je 0x7f695
movq 0x148(%r1... | /Analysis/CFG.cpp |
llvm::DenseMapBase<llvm::DenseMap<clang::LabelDecl*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<clang::LabelDecl*, void>, llvm::detail::DenseSetPair<clang::LabelDecl*>>, clang::LabelDecl*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<clang::LabelDecl*, void>, llvm::detail::DenseSetPair<clang::LabelDecl*>>::move... | 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
movq $0x0, 0x8(%rdi)
movl 0x10(%rdi), %ecx
testq %rcx, %rcx
je 0x807d9
movq (%r15), %rax
movabsq $0x1fffffffffffffff, %rdx # imm = 0x1FFFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x1, %ecx
ne... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::CFGBuilder::VisitLogicalOperator(clang::BinaryOperator*, clang::Stmt*, clang::CFGBlock*, clang::CFGBlock*) | std::pair<CFGBlock*, CFGBlock*>
CFGBuilder::VisitLogicalOperator(BinaryOperator *B,
Stmt *Term,
CFGBlock *TrueBlock,
CFGBlock *FalseBlock) {
// Introspect the RHS. If it is a nested logical operation, we recursively
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
movq 0x18(%rsi), %rdi
callq 0xd90f0
movq %rax, %rbp
movb (%rax), %cl
addb $-0x77, %cl
movb $0x1, %al
cmpb $-0x2, %cl
jae 0x80867
jmp 0x80898
movl (... | /Analysis/CFG.cpp |
(anonymous namespace)::CFGBuilder::tryEvaluateBool(clang::Expr*) | TryResult tryEvaluateBool(Expr *S) {
if (!BuildOpts.PruneTriviallyFalseEdges ||
S->isTypeDependent() || S->isValueDependent())
return {};
if (BinaryOperator *Bop = dyn_cast<BinaryOperator>(S)) {
if (Bop->isLogicalOp() || Bop->isEqualityOp()) {
// Check the cache first.
Cache... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rsi, 0x10(%rsp)
movq 0x148(%rdi), %rax
movl $0xffffffff, %ebp # imm = 0xFFFFFFFF
cmpb $0x1, 0x30(%rax)
jne 0x80ea2
movq %rsi, %r14
movzwl 0x1(%rsi), %eax
testl $0x180, %eax # imm = 0x180
jne 0x80ea2
movq %rdi, %rbx... | /Analysis/CFG.cpp |
tryNormalizeBinaryOperator(clang::BinaryOperator const*) | static std::tuple<const Expr *, BinaryOperatorKind, const Expr *>
tryNormalizeBinaryOperator(const BinaryOperator *B) {
BinaryOperatorKind Op = B->getOpcode();
const Expr *MaybeDecl = B->getLHS();
const Expr *Constant = tryTransformToIntOrEnumConstant(B->getRHS());
// Expr looked like `0 == Foo` instead of `Fo... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rsi), %r12d
shrl $0x12, %r12d
andl $0x3f, %r12d
movq 0x10(%rsi), %r15
movq 0x18(%rsi), %r14
movq %r14, %rdi
callq 0x820b8
testq %rax, %rax
je 0x81de4
movq %r15, %r14
jmp 0x81e03
leal -0xa(%r12), %eax
cmpl $0x3, %eax
ja 0x81dfb
movl %eax, %eax... | /Analysis/CFG.cpp |
bool clang::Decl::hasAttr<clang::NoThrowAttr>() const | bool hasAttrs() const { return HasAttrs; } | testb $0x1, 0x1d(%rdi)
jne 0x829d5
xorl %eax, %eax
retq
pushq %rax
callq 0xc136a
movq (%rax), %rcx
movl 0x8(%rax), %edx
leaq (%rcx,%rdx,8), %rax
testq %rdx, %rdx
je 0x82a03
shlq $0x3, %rdx
movq (%rcx), %rsi
cmpw $0x106, 0x20(%rsi) # imm = 0x106
je 0x82a03
addq $0x8, %rcx
addq $-0x8, %rdx
jne 0x829ee
cmpq %rax, %rc... | /clang/AST/DeclBase.h |
(anonymous namespace)::CFGBuilder::appendCall(clang::CFGBlock*, clang::CallExpr*) | void appendCall(CFGBlock *B, CallExpr *CE) {
if (alwaysAdd(CE) && cachedEntry)
cachedEntry->second = B;
if (const ConstructionContext *CC =
retrieveAndCleanupConstructionContext(CE)) {
B->appendCXXRecordTypedCall(CE, CC, cfg->getBumpVectorContext());
return;
}
// No valid... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rsi
callq 0x7ec82
testb %al, %al
je 0x82a38
movq 0x160(%r15), %rax
testq %rax, %rax
je 0x82a38
movq %r14, 0x8(%rax)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x8317e
movq 0x8(%r15), %rcx
addq $0x20, %rcx
movq %r14, %rdi
movq %rbx, ... | /Analysis/CFG.cpp |
(anonymous namespace)::CFGBuilder::findConstructionContexts(clang::ConstructionContextLayer const*, clang::Stmt*) | void CFGBuilder::findConstructionContexts(
const ConstructionContextLayer *Layer, Stmt *Child) {
if (!BuildOpts.AddRichCXXConstructors)
return;
if (!Child)
return;
auto withExtraLayer = [this, Layer](const ConstructionContextItem &Item) {
return ConstructionContextLayer::create(cfg->getBumpVecto... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
testq %r14, %r14
je 0x82c8f
movq 0x148(%rbx), %rcx
cmpb $0x0, 0x3c(%rcx)
je 0x82c8f
movzbl (%r14), %eax
cmpl $0x4d, %eax
jle 0x82ae5
cmpl $0x57, %eax
jg 0x82af9
cmpl $0x4e, %eax
je 0x82b39
cmpl $0x55, %eax
je 0x82b50
jmp 0... | /Analysis/CFG.cpp |
llvm::DenseMapBase<llvm::DenseMap<clang::Expr*, clang::ConstructionContextLayer const*, llvm::DenseMapInfo<clang::Expr*, void>, llvm::detail::DenseMapPair<clang::Expr*, clang::ConstructionContextLayer const*>>, clang::Expr*, clang::ConstructionContextLayer const*, llvm::DenseMapInfo<clang::Expr*, void>, llvm::detail::D... | value_type& FindAndConstruct(const KeyT &Key) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return *TheBucket;
return *InsertIntoBucket(TheBucket, Key);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x82dfc
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x82df2
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x82e8e
movq (%rbx), %rcx
movq %rcx, (%rax)
movq $0x0, 0... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::CFGBuilder::VisitForTemporaryDtors(clang::Stmt*, bool, (anonymous namespace)::CFGBuilder::TempDtorContext&) | CFGBlock *CFGBuilder::VisitForTemporaryDtors(Stmt *E, bool ExternallyDestructed,
TempDtorContext &Context) {
assert(BuildOpts.AddImplicitDtors && BuildOpts.AddTemporaryDtors);
tryAgain:
if (!E) {
badCFG = true;
return nullptr;
}
switch (E->getStmtClass()) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x8354d
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r14
leaq 0x18(%rsp), %r12
leaq 0x58(%rsp), %r13
movb (%r14), %cl
movzbl %cl, %eax
cmpl $0x54, %eax
jle 0x8341e
leal -0x6e(%rax), %edx
cmpl $0x7, %edx... | /Analysis/CFG.cpp |
(anonymous namespace)::CFGBuilder::InsertTempDtorDecisionBlock((anonymous namespace)::CFGBuilder::TempDtorContext const&, clang::CFGBlock*) | void CFGBuilder::InsertTempDtorDecisionBlock(const TempDtorContext &Context,
CFGBlock *FalseSucc) {
if (!Context.TerminatorExpr) {
// If no temporary was found, we do not need to insert a decision point.
return;
}
assert(Context.TerminatorExpr);
CFGBlock *Dec... | cmpq $0x0, 0x10(%rsi)
je 0x83b17
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x78c38
movq %rax, %r14
movq 0x10(%r12), %rax
andq $-0x7, %rax
orq $0x2, %rax
movq %rax, 0x20(%r14)
movq 0x10(%rbx), %rsi
xorl %edx, %edx
cm... | /Analysis/CFG.cpp |
llvm::DenseMapBase<llvm::DenseMap<clang::DeclStmt const*, clang::DeclStmt const*, llvm::DenseMapInfo<clang::DeclStmt const*, void>, llvm::detail::DenseMapPair<clang::DeclStmt const*, clang::DeclStmt const*>>, clang::DeclStmt const*, clang::DeclStmt const*, llvm::DenseMapInfo<clang::DeclStmt const*, void>, llvm::detail:... | value_type& FindAndConstruct(const KeyT &Key) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return *TheBucket;
return *InsertIntoBucket(TheBucket, Key);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdx
callq 0x8442e
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x84424
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x844c0
movq (%rbx), %rcx
movq %rcx, (%rax)
movq $0x0, 0... | /llvm/ADT/DenseMap.h |
clang::hash_value(clang::APValue::LValueBase const&) | llvm::hash_code hash_value(const APValue::LValueBase &Base) {
if (Base.is<TypeInfoLValue>() || Base.is<DynamicAllocLValue>())
return llvm::hash_value(Base.getOpaqueValue());
return llvm::hash_combine(Base.getOpaqueValue(), Base.getCallIndex(),
Base.getVersion());
} | movabsq $-0xae502812aa7333, %rax # imm = 0xFF51AFD7ED558CCD
movq (%rdi), %rsi
testb $0x2, %sil
jne 0x86294
subq $0x98, %rsp
movl 0x8(%rdi), %ecx
leaq 0xc(%rsp), %r8
movl %ecx, (%r8)
movl 0xc(%rdi), %ecx
leaq 0x8(%rsp), %r9
movl %ecx, (%r9)
leaq 0x50(%rsp), %rcx
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rcx)
movaps %xmm0,... | /AST/APValue.cpp |
clang::APValue::printPretty(llvm::raw_ostream&, clang::PrintingPolicy const&, clang::QualType, clang::ASTContext const*) const | void APValue::printPretty(raw_ostream &Out, const PrintingPolicy &Policy,
QualType Ty, const ASTContext *Ctx) const {
// There are no objects of type 'void', but values of this type can be
// returned from functions.
if (Ty->isVoidType()) {
Out << "void()";
return;
}
if (con... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %r8, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
movq %rcx, 0x20(%rsp)
andq $-0x10, %rcx
movq (%rcx), %rdi
movq 0x8(%rdi), %rax
andq $-0x10, %rax
movq (%rax), %rax
testq %rax, %rax
je 0x87814
cmpb $0xd, 0x10(%rax)
jne 0x878... | /AST/APValue.cpp |
clang::APValue::LV::resizePath(unsigned int) | void resizePath(unsigned Length) {
if (Length == PathLength)
return;
if (hasPathPtr())
delete [] PathPtr;
PathLength = Length;
if (hasPathPtr())
PathPtr = new LValuePathEntry[Length];
} | movl 0x18(%rdi), %eax
cmpl %esi, %eax
je 0x88e77
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
addl $-0x5, %eax
cmpl $-0x7, %eax
ja 0x88e37
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x88e37
callq 0x3c180
movl %r14d, 0x18(%rbx)
leal -0x5(%r14), %eax
cmpl $-0x7, %eax
ja 0x88e6c
m... | /AST/APValue.cpp |
clang::APValue::setVectorUninit(unsigned int) | MutableArrayRef<APValue> setVectorUninit(unsigned N) {
assert(isVector() && "Invalid accessor");
Vec *V = ((Vec *)(char *)&Data);
V->Elts = new APValue[N];
V->NumElts = N;
return {V->Elts, V->NumElts};
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %ebx
leaq (%rbx,%rbx,8), %r15
leaq 0x8(,%r15,8), %rdi
callq 0x3c450
movq %rax, %rcx
movq %rbx, (%rax)
addq $0x8, %rcx
testl %ebp, %ebp
je 0x89422
leaq -0x48(,%r15,8), %rax
movabsq $-0x1c71c71c71c71c71, %rdx # imm = 0xE38E3... | /clang/AST/APValue.h |
clang::TagType const* clang::Type::getAs<clang::TagType>() const | TypeClass getTypeClass() const { return static_cast<TypeClass>(TypeBits.TC); } | movb 0x10(%rdi), %cl
addb $-0x2f, %cl
xorl %eax, %eax
cmpb $-0x2, %cl
cmovaeq %rdi, %rax
jae 0x896b5
movq 0x8(%rdi), %rax
andq $-0x10, %rax
movq (%rax), %rax
movb 0x10(%rax), %al
addb $-0x2d, %al
cmpb $0x1, %al
jbe 0x22549c
xorl %eax, %eax
retq
| /clang/AST/Type.h |
llvm::SmallVectorTemplateBase<clang::NamedDecl*, true>::push_back(clang::NamedDecl*) | void push_back(ValueParamT Elt) {
const T *EltPtr = reserveForParamAndGetAddress(Elt);
memcpy(reinterpret_cast<void *>(this->end()), EltPtr, sizeof(T));
this->set_size(this->size() + 1);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %edx
cmpl 0xc(%rdi), %edx
jae 0x89f21
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
movq %r14, (%rax,%rcx,8)
incl 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
incq %rdx
leaq 0x10(%rbx), %rsi
movl $0x8, %ecx
movq %rbx, %rdi
callq 0x56f14
jmp... | /llvm/ADT/SmallVector.h |
llvm::SmallVectorTemplateBase<clang::TypeSourceInfo*, true>::push_back(clang::TypeSourceInfo*) | void push_back(ValueParamT Elt) {
const T *EltPtr = reserveForParamAndGetAddress(Elt);
memcpy(reinterpret_cast<void *>(this->end()), EltPtr, sizeof(T));
this->set_size(this->size() + 1);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %edx
cmpl 0xc(%rdi), %edx
jae 0x8a00b
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
movq %r14, (%rax,%rcx,8)
incl 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
incq %rdx
leaq 0x10(%rbx), %rsi
movl $0x8, %ecx
movq %rbx, %rdi
callq 0x56f14
jmp... | /llvm/ADT/SmallVector.h |
clang::ASTContext::getPreferredTypeAlign(clang::Type const*) const | unsigned ASTContext::getPreferredTypeAlign(const Type *T) const {
TypeInfo TI = getTypeInfo(T);
unsigned ABIAlign = TI.Align;
T = T->getBaseElementTypeUnsafe();
// The preferred alignment of member pointers is that of a pointer.
if (T->isMemberPointerType())
return getPreferredTypeAlign(getPointerDiffTy... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
xorl %r12d, %r12d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8bd06
movq %rdx, %r14
movzbl 0x10(%r15), %ecx
addl $-0x7, %ecx
movq %r15, %rax
cmpl $-0x5, %ecx
cmovbq %r12, %rax
jae 0x8b90e
movq 0x8(%r15), %rax
andq $-0x10, %rax
movq (%rax... | /AST/ASTContext.cpp |
bool clang::Decl::hasAttr<clang::AlignedAttr>() const | bool hasAttrs() const { return HasAttrs; } | testb $0x1, 0x1d(%rdi)
jne 0x8bf0f
xorl %eax, %eax
retq
pushq %rax
callq 0xc136a
movq (%rax), %rcx
movl 0x8(%rax), %edx
leaq (%rcx,%rdx,8), %rax
testq %rdx, %rdx
je 0x8bf3c
shlq $0x3, %rdx
movq (%rcx), %rsi
cmpw $0x6c, 0x20(%rsi)
je 0x8bf3c
addq $0x8, %rcx
addq $-0x8, %rdx
jne 0x8bf28
cmpq %rax, %rcx
setne %al
addq $0x... | /clang/AST/DeclBase.h |
clang::ASTContext::getPointerAuthVTablePointerDiscriminator(clang::CXXRecordDecl const*) | uint16_t
ASTContext::getPointerAuthVTablePointerDiscriminator(const CXXRecordDecl *RD) {
assert(RD->isPolymorphic() &&
"Attempted to get vtable pointer discriminator on a monomorphic type");
std::unique_ptr<MangleContext> MC(createMangleContext());
SmallString<256> Str;
llvm::raw_svector_ostream Out(St... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rsi, %r14
xorl %r13d, %r13d
xorl %esi, %esi
callq 0x8c8c4
movq %rax, %rbx
leaq 0x58(%rsp), %r12
movq %r12, -0x18(%r12)
movq %r13, -0x10(%r12)
movq $0x100, -0x8(%r12) # imm = 0x100
leaq 0x8(%rsp), %r15... | /AST/ASTContext.cpp |
clang::ASTContext::getArrayDecayedType(clang::QualType) const | QualType ASTContext::getArrayDecayedType(QualType Ty) const {
// Get the element type with 'getAsArrayType' so that we don't lose any
// typedefs in the element type of the array. This also handles propagation
// of type qualifiers from the array type into the element type if present
// (C99 6.7.3p8).
const ... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x8b6d6
movq %rax, %r15
movq 0x20(%rax), %rsi
movq %rbx, %rdi
callq 0x8a9e4
movl 0x10(%r15), %edx
shrl $0x13, %edx
andl $0x7, %edx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8a34c
movq %rax, %r15
andq $-0x10, %r14
movq (%r14), %rdi
callq 0x22aa98
btl $... | /AST/ASTContext.cpp |
clang::ASTContext::getAtomicType(clang::QualType) const | QualType ASTContext::getAtomicType(QualType T) const {
// Unique pointers, to guarantee there is only one pointer of a particular
// structure.
llvm::FoldingSetNodeID ID;
AtomicType::Profile(ID, T);
void *InsertPos = nullptr;
if (AtomicType *AT = AtomicTypes.FindNodeOrInsertPos(ID, InsertPos))
return Q... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movabsq $0x2000000000, %rax # imm = 0x2000000000
movq %rax, -0x8(%r13)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x75350
movq %r14, %rsi
shrq $0x20, %rsi
m... | /AST/ASTContext.cpp |
clang::ConstantArrayType::getSize() const | llvm::APInt getSize() const {
return ConstantArrayTypeBits.HasExternalSize
? SizePtr->Size
: llvm::APInt(ConstantArrayTypeBits.SizeWidth * 8, Size);
} | pushq %rbx
movq %rdi, %rbx
movl 0x10(%rsi), %eax
btl $0x19, %eax
jb 0x8e973
shrl $0x17, %eax
andl $0xf8, %eax
movq 0x28(%rsi), %rdx
movq %rbx, %rdi
movl %eax, %esi
xorl %ecx, %ecx
callq 0x66024
jmp 0x8e992
movq 0x28(%rsi), %rsi
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rbx)
cmpl $0x40, %eax
ja 0x8e98a
movq (%rsi), %rax
movq... | /clang/AST/Type.h |
clang::ASTContext::getExtVectorType(clang::QualType, unsigned int) const | QualType ASTContext::getExtVectorType(QualType vecType,
unsigned NumElts) const {
assert(vecType->isBuiltinType() || vecType->isDependentType() ||
(vecType->isBitIntType() &&
// Only support _BitInt elements with byte-sized power of 2 NumBits.
llvm::i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %r13
movq %r13, -0x10(%r13)
movabsq $0x2000000000, %rax # imm = 0x2000000000
movq %rax, -0x8(%r13)
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movl $0x38, %ecx
xorl %r8d, %r8... | /AST/ASTContext.cpp |
clang::ASTContext::getConstantMatrixType(clang::QualType, unsigned int, unsigned int) const | QualType ASTContext::getConstantMatrixType(QualType ElementTy, unsigned NumRows,
unsigned NumColumns) const {
llvm::FoldingSetNodeID ID;
ConstantMatrixType::Profile(ID, ElementTy, NumRows, NumColumns,
Type::ConstantMatrix);
assert(MatrixTyp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movabsq $0x2000000000, %rax # imm = 0x2000000000
movq %rax, -0x8(%rcx)
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movl %ebp, %ec... | /AST/ASTContext.cpp |
clang::ASTContext::getCanonicalFunctionResultType(clang::QualType) const | const ExtQualsTypeCommonBase *getCommonPtr() const {
assert(!isNull() && "Cannot retrieve a NULL type pointer");
auto CommonPtrVal = reinterpret_cast<uintptr_t>(Value.getOpaqueValue());
CommonPtrVal &= ~(uintptr_t)((1 << TypeAlignmentInBits) - 1);
return reinterpret_cast<ExtQualsTypeCommonBase*>(CommonP... | movq %rsi, %rax
andq $-0x10, %rax
movq 0x8(%rax), %rax
andl $0x7, %esi
movb $0x1, %cl
testb $0x8, %al
je 0x8f41c
movq %rax, %rcx
andq $-0x10, %rcx
movzwl 0x18(%rcx), %ecx
testl $0x1c0, %ecx # imm = 0x1C0
sete %cl
orq %rax, %rsi
testb %cl, %cl
je 0x8f427
movq %rsi, %rax
retq
andl $0x7, %esi
testb $0x8, %al
jn... | /clang/AST/Type.h |
clang::ObjCObjectType const* clang::Type::getAs<clang::ObjCObjectType>() const | TypeClass getTypeClass() const { return static_cast<TypeClass>(TypeBits.TC); } | movb 0x10(%rdi), %cl
addb $-0x23, %cl
xorl %eax, %eax
cmpb $-0x2, %cl
cmovaeq %rdi, %rax
jae 0x90efd
movq 0x8(%rdi), %rax
andq $-0x10, %rax
movq (%rax), %rax
movb 0x10(%rax), %al
addb $-0x21, %al
cmpb $0x1, %al
jbe 0x22549c
xorl %eax, %eax
retq
| /clang/AST/Type.h |
void llvm::SmallVectorImpl<clang::ObjCProtocolDecl*>::append<clang::ObjCProtocolDecl* const*, void>(clang::ObjCProtocolDecl* const*, clang::ObjCProtocolDecl* const*) | void append(ItTy in_start, ItTy in_end) {
this->assertSafeToAddRange(in_start, in_end);
size_type NumInputs = std::distance(in_start, in_end);
this->reserve(this->size() + NumInputs);
this->uninitialized_copy(in_start, in_end, this->end());
this->set_size(this->size() + NumInputs);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %r15
subq %rsi, %r15
movq %r15, %r13
sarq $0x3, %r13
movl 0x8(%rdi), %edx
movl 0xc(%rdi), %eax
addq %r13, %rdx
cmpq %rax, %rdx
jbe 0x90f3c
leaq 0x10(%rbx), %rsi
movl $0x8, %ecx
movq %rbx, %rdi
callq 0x56f14... | /llvm/ADT/SmallVector.h |
clang::ObjCObjectPointerType const* clang::Type::getAs<clang::ObjCObjectPointerType>() const | const T *Type::getAs() const {
static_assert(!TypeIsArrayType<T>::value,
"ArrayType cannot be used with getAs!");
// If this is directly a T type, return it.
if (const auto *Ty = dyn_cast<T>(this))
return Ty;
// If the canonical form of this type isn't the right kind, reject it.
if (!isa... | xorl %eax, %eax
cmpb $0x20, 0x10(%rdi)
cmoveq %rdi, %rax
je 0x9111f
movq 0x8(%rdi), %rax
andq $-0x10, %rax
movq (%rax), %rax
cmpb $0x20, 0x10(%rax)
je 0x22549c
xorl %eax, %eax
retq
| /clang/AST/Type.h |
clang::AutoType const* clang::Type::getAs<clang::AutoType>() const | const T *Type::getAs() const {
static_assert(!TypeIsArrayType<T>::value,
"ArrayType cannot be used with getAs!");
// If this is directly a T type, return it.
if (const auto *Ty = dyn_cast<T>(this))
return Ty;
// If the canonical form of this type isn't the right kind, reject it.
if (!isa... | xorl %eax, %eax
cmpb $0x10, 0x10(%rdi)
cmoveq %rdi, %rax
je 0x91507
movq 0x8(%rdi), %rax
andq $-0x10, %rax
movq (%rax), %rax
cmpb $0x10, 0x10(%rax)
je 0x22549c
xorl %eax, %eax
retq
| /clang/AST/Type.h |
clang::ASTContext::UnwrapSimilarTypes(clang::QualType&, clang::QualType&, bool) | bool ASTContext::UnwrapSimilarTypes(QualType &T1, QualType &T2,
bool AllowPiMismatch) {
UnwrapSimilarArrayTypes(T1, T2, AllowPiMismatch);
const auto *T1PtrType = T1->getAs<PointerType>();
const auto *T2PtrType = T2->getAs<PointerType>();
if (T1PtrType && T2PtrType) {
T1 ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
callq 0x9152c
movq (%r14), %rax
andq $-0x10, %rax
movq (%rax), %rdi
callq 0x77ce4
movq %rax, %r15
movq (%rbx), %rax
andq $-0x10, %rax
movq (%rax), %rdi
callq 0x77ce4
testq %r15, %r15
je 0x9172b
testq %rax, %rax
je 0x9... | /AST/ASTContext.cpp |
clang::NonTypeTemplateParmDecl::getDefaultArgument() const | const TemplateArgumentLoc &getDefaultArgument() const {
static const TemplateArgumentLoc NoneLoc;
return DefaultArgument.isSet() ? *DefaultArgument.get() : NoneLoc;
} | pushq %rbx
movq %rdi, %rbx
leaq 0x485287(%rip), %rax # 0x516c90
movb (%rax), %al
testb %al, %al
je 0x91a62
movq 0x48(%rbx), %rax
cmpq $0x8, %rax
jb 0x91a59
addq $0x48, %rbx
movl %eax, %ecx
andl $0x6, %ecx
andq $-0x8, %rax
xorl %edx, %edx
cmpl $0x2, %ecx
cmoveq %rax, %rdx
leaq 0x48(%rdx), %rax
testq %rdx, %rdx
cmoveq... | /clang/AST/DeclTemplate.h |
clang::ObjCObjectPointerType::isObjCIdType() const | bool isObjCIdType() const {
return getObjectType()->isObjCUnqualifiedId();
} | pushq %rax
movq 0x20(%rdi), %rax
andq $-0x10, %rax
movq (%rax), %rdi
movb 0x10(%rdi), %cl
addb $-0x23, %cl
xorl %eax, %eax
cmpb $-0x2, %cl
cmovaeq %rdi, %rax
jae 0x93742
callq 0x22549c
cmpl $0x3ffffff, 0x10(%rax) # imm = 0x3FFFFFF
ja 0x93780
movq 0x18(%rax), %rax
andq $-0x10, %rax
movq (%rax), %rax
movq 0x8(%rax), %ra... | /clang/AST/Type.h |
clang::ASTContext::getBuiltinVaListDecl() const | TypedefDecl *ASTContext::getBuiltinVaListDecl() const {
if (!BuiltinVaListDecl) {
BuiltinVaListDecl = CreateVaListDecl(this, Target->getBuiltinVaListKind());
assert(BuiltinVaListDecl->isImplicit());
}
return BuiltinVaListDecl;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x540(%rdi)
jne 0x94369
movq 0x4348(%rbx), %rdi
movq (%rdi), %rax
callq *0x120(%rax)
movl %eax, %eax
leaq 0x2929f7(%rip), %rcx # 0x32646c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x47f8(%rb... | /AST/ASTContext.cpp |
clang::ASTContext::getVTableContext() | VTableContextBase *ASTContext::getVTableContext() {
if (!VTContext.get()) {
auto ABI = Target->getCXXABI();
if (ABI.isMicrosoft())
VTContext.reset(new MicrosoftVTableContext(*this));
else {
auto ComponentLayout = getLangOpts().RelativeCXXABIVTables
? ItaniumVTa... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x59a8(%rdi)
jne 0x94a57
movq 0x4348(%rbx), %rax
cmpl $0xa, 0x154(%rax)
jne 0x94a11
movl $0x90, %edi
callq 0x3c390
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
xorl %ecx, %ecx
movl %ecx, 0x18(%rax)
movb $0x1, 0x20(%rax)
leaq 0x42548a(%rip), %rdx # 0x4b9e68
ad... | /AST/ASTContext.cpp |
llvm::MapVector<clang::NamedDecl const*, unsigned int, llvm::DenseMap<clang::NamedDecl const*, unsigned int, llvm::DenseMapInfo<clang::NamedDecl const*, void>, llvm::detail::DenseMapPair<clang::NamedDecl const*, unsigned int>>, llvm::SmallVector<std::pair<clang::NamedDecl const*, unsigned int>, 0u>>::find(clang::NamedD... | const_iterator find(const KeyT &Key) const {
typename MapType::const_iterator Pos = Map.find(Key);
return Pos == Map.end()? Vector.end() :
(Vector.begin() + Pos->second);
} | pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rsi
callq 0x99fc4
movl 0x10(%rbx), %ecx
shlq $0x4, %rcx
addq (%rbx), %rcx
leaq 0x8(%rax), %rdx
leaq 0x20(%rbx), %rsi
cmpq %rcx, %rax
cmoveq %rsi, %rdx
movl (%rdx), %eax
shlq $0x4, %rax
addq 0x18(%rbx), %rax
popq %rbx
retq
nop
| /llvm/ADT/MapVector.h |
clang::ASTContext::getTemplateParamObjectDecl(clang::QualType, clang::APValue const&) const | TemplateParamObjectDecl *
ASTContext::getTemplateParamObjectDecl(QualType T, const APValue &V) const {
assert(T->isRecordType() && "template param object of unexpected type");
// C++ [temp.param]p8:
// [...] a static storage duration object of type 'const T' [...]
T.addConst();
llvm::FoldingSetNodeID ID;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r13
orq $0x1, %r14
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movabsq $0x2000000000, %rax # imm = 0x2000000000
movq %rax, -0x8(%rbp)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
c... | /AST/ASTContext.cpp |
bool clang::Decl::hasAttr<clang::CUDAGlobalAttr>() const | bool hasAttrs() const { return HasAttrs; } | testb $0x1, 0x1d(%rdi)
jne 0x95439
xorl %eax, %eax
retq
pushq %rax
callq 0xc136a
movq (%rax), %rcx
movl 0x8(%rax), %edx
leaq (%rcx,%rdx,8), %rax
testq %rdx, %rdx
je 0x95467
shlq $0x3, %rdx
movq (%rcx), %rsi
cmpw $0x92, 0x20(%rsi)
je 0x95467
addq $0x8, %rcx
addq $-0x8, %rdx
jne 0x95452
cmpq %rax, %rcx
setne %al
addq $0x... | /clang/AST/DeclBase.h |
llvm::SmallVectorTemplateBase<clang::SourceLocation, true>::push_back(clang::SourceLocation) | void push_back(ValueParamT Elt) {
const T *EltPtr = reserveForParamAndGetAddress(Elt);
memcpy(reinterpret_cast<void *>(this->end()), EltPtr, sizeof(T));
this->set_size(this->size() + 1);
} | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movl 0x8(%rdi), %edx
cmpl 0xc(%rdi), %edx
jae 0x956a1
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
movl %ebp, (%rax,%rcx,4)
incl 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
incq %rdx
leaq 0x10(%rbx), %rsi
movl $0x4, %ecx
movq %rbx, %rdi
callq 0x56f14
jmp... | /llvm/ADT/SmallVector.h |
llvm::DenseMap<clang::CXXRecordDecl const*, clang::CharUnits, llvm::DenseMapInfo<clang::CXXRecordDecl const*, void>, llvm::detail::DenseMapPair<clang::CXXRecordDecl const*, clang::CharUnits>>::grow(unsigned int) | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBu... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl 0x10(%rdi), %ebx
movq (%rdi), %r14
leal -0x1(%rsi), %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x8, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x10,... | /llvm/ADT/DenseMap.h |
clang::NonTypeTemplateParmDecl::hasPlaceholderTypeConstraint() const | bool hasPlaceholderTypeConstraint() const {
auto *AT = getType()->getContainedAutoType();
return AT && AT->isConstrained();
} | pushq %rax
movq 0x30(%rdi), %rax
andq $-0x10, %rax
movq (%rax), %rdi
callq 0x226c7c
xorl %ecx, %ecx
testq %rax, %rax
je 0x9645a
cmpb $0x10, 0x10(%rax)
cmoveq %rax, %rcx
testq %rcx, %rcx
je 0x96469
cmpq $0x0, 0x28(%rcx)
setne %al
jmp 0x9646b
xorl %eax, %eax
popq %rcx
retq
nop
| /clang/AST/DeclTemplate.h |
clang::CXXRecordDecl::bases_begin() | base_class_iterator bases_begin() { return data().getBases(); } | pushq %rbx
movq %rdi, %rbx
movq 0x68(%rdi), %rsi
leaq 0x60(%rsi), %rdi
callq 0x79ef0
movq 0x80(%rbx), %rdi
movq 0x18(%rdi), %rax
testb $0x1, %al
jne 0x967a4
popq %rbx
retq
popq %rbx
jmp 0xc42c6
| /clang/AST/DeclCXX.h |
bool llvm::DenseMapBase<llvm::DenseMap<clang::CXXRecordDecl const*, clang::ASTRecordLayout::VBaseInfo, llvm::DenseMapInfo<clang::CXXRecordDecl const*, void>, llvm::detail::DenseMapPair<clang::CXXRecordDecl const*, clang::ASTRecordLayout::VBaseInfo>>, clang::CXXRecordDecl const*, clang::ASTRecordLayout::VBaseInfo, llvm:... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x9687c
pushq %rbx
movq (%rdi), %rdi
movl (%rsi), %r8d
movl %r8d, %eax
shrl $0x4, %eax
shrl $0x9, %r8d
xorl %eax, %r8d
decl %ecx
andl %ecx, %r8d
movl $0x1, %r10d
xorl %r9d, %r9d
movl %r8d, %r11d
leaq (%r11,%r11,2), %r11
leaq (%rdi,%r11,8), %r11
movq (%r11), %rbx
cmpq %rbx, (%rs... | /llvm/ADT/DenseMap.h |
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.