name string | code string | asm string | file string |
|---|---|---|---|
testing::internal::ExecDeathTest::ExecDeathTest(char const*, testing::Matcher<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>, char const*, int) | ExecDeathTest(const char* a_statement, Matcher<const std::string&> matcher,
const char* file, int line)
: ForkingDeathTest(a_statement, std::move(matcher)),
file_(file),
line_(line) {} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %r8d, %ebx
movq %rcx, %r14
movups 0x8(%rdx), %xmm0
andq $0x0, 0x10(%rdx)
leaq 0x8(%rsp), %rax
movups %xmm0, 0x8(%rax)
andq $0x0, 0x8(%rdx)
movq %rdi, %r15
leaq 0x21a5a(%rip), %rcx # 0x4bb08
movq %rcx, (%rax)
movq %rax, %rdx
callq 0x22e42
leaq 0x8(%rsp), %rdi
ca... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-death-test.cc |
testing::internal::StreamingListener::SocketWriter::Send(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void Send(const std::string& message) override {
GTEST_CHECK_(sockfd_ != -1)
<< "Send() can be called only when there is a connection.";
const auto len = static_cast<size_t>(message.length());
if (write(sockfd_, message.c_str(), len) != static_cast<ssize_t>(len)) {
GTEST_LOG_(WARNIN... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %edi
cmpl $-0x1, %edi
jne 0x2bf24
leaq 0x8d30(%rip), %rdx # 0x34c13
leaq 0x4(%rsp), %rdi
pushq $0x3
popq %rsi
movl $0x44f, %ecx # imm = 0x44F
callq 0x256d2
movq 0x200ec(%rip), %rdi # 0x4bfe8
leaq 0x8ec4(%rip), %rsi ... | /walterzhaoJR[P]leveldb/third_party/googletest/googletest/src/gtest-internal-inl.h |
std::enable_if<has_SequenceTraits<std::vector<llvm::DWARFYAML::PubEntry, std::allocator<llvm::DWARFYAML::PubEntry>>>::value, void>::type llvm::yaml::yamlize<std::vector<llvm::DWARFYAML::PubEntry, std::allocator<llvm::DWARFYAML::PubEntry>>, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::vector<llvm::DWARFYAML::PubEntry... | std::enable_if_t<has_SequenceTraits<T>::value, void>
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
if ( has_FlowTraits< SequenceTraits<T>>::value ) {
unsigned incnt = io.beginFlowSequence();
unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
for(unsigned i=0; i < count; ++i) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %r12d
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
testb %al, %al
je 0x1a3017
movq 0x8(%r15), %rax
subq (%r15), %rax
pushq $0x18
popq %rcx
cq... | /llvm/Support/YAMLTraits.h |
std::enable_if<has_ScalarTraits<long>::value, void>::type llvm::yaml::yamlize<long>(llvm::yaml::IO&, long&, bool, llvm::yaml::EmptyContext&) | std::enable_if_t<has_ScalarTraits<T>::value, void> yamlize(IO &io, T &Val, bool,
EmptyContext &Ctx) {
if ( io.outputting() ) {
SmallString<128> Storage;
raw_svector_ostream Buffer(Storage);
ScalarTraits<T>::output(Val, io.getContext(), Buffer);
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x10(%rax)
testb %al, %al
je 0x1a42fe
leaq 0x68(%rsp), %rax
movq %rax, -0x18(%rax)
andq $0x0, -0x10(%rax)
movq $0x80, -0x8(%rax)
leaq 0x10(%rsp), %r12
leaq 0x50(%rsp), %r15
movq %r12, %rdi
movq %r15, %r... | /llvm/Support/YAMLTraits.h |
std::enable_if<has_SequenceTraits<std::vector<llvm::WasmYAML::Signature, std::allocator<llvm::WasmYAML::Signature>>>::value, void>::type llvm::yaml::yamlize<std::vector<llvm::WasmYAML::Signature, std::allocator<llvm::WasmYAML::Signature>>, llvm::yaml::EmptyContext>(llvm::yaml::IO&, std::vector<llvm::WasmYAML::Signature... | std::enable_if_t<has_SequenceTraits<T>::value, void>
yamlize(IO &io, T &Seq, bool, Context &Ctx) {
if ( has_FlowTraits< SequenceTraits<T>>::value ) {
unsigned incnt = io.beginFlowSequence();
unsigned count = io.outputting() ? SequenceTraits<T>::size(io, Seq) : incnt;
for(unsigned i=0; i < count; ++i) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %r12d
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
testb %al, %al
je 0x1d6579
movq 0x8(%r15), %rax
subq (%r15), %rax
pushq $0x38
popq %rcx
cq... | /llvm/Support/YAMLTraits.h |
printWithoutType(llvm::Value const&, llvm::raw_ostream&, llvm::SlotTracker*, llvm::Module const*) | static bool printWithoutType(const Value &V, raw_ostream &O,
SlotTracker *Machine, const Module *M) {
if (V.hasName() || isa<GlobalValue>(V) ||
(!isa<Constant>(V) && !isa<MetadataAsValue>(V))) {
AsmWriterContext WriterCtx(nullptr, Machine, M);
WriteAsOperandInternal(O, &V, W... | movq %rdi, %rax
testb $0x10, 0x7(%rdi)
jne 0x24604f
movb (%rax), %dil
cmpb $0x4, %dil
jb 0x24604f
cmpb $0x16, %dil
setb %r8b
cmpb $0x18, %dil
sete %dil
orb %r8b, %dil
je 0x24604f
xorl %eax, %eax
retq
subq $0x28, %rsp
leaq 0x3263a6(%rip), %rdi # 0x56c400
leaq 0x8(%rsp), %r8
movq %rdi, (%r8)
andq $0x0, 0x8(%r8)
movq %... | /IR/AsmWriter.cpp |
llvm::DenseMap<llvm::Comdat const*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::Comdat const*, void>, llvm::detail::DenseSetPair<llvm::Comdat const*>>::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 0x24645b
movl %ebp, %edi
shlq $0x3, %rdi
pushq $0x8
popq %rsi
callq 0x1f2dd6
jmp 0x24645d
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 |
llvm::DenseMap<llvm::Comdat const*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::Comdat const*, void>, llvm::detail::DenseSetPair<llvm::Comdat const*>>::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 0x8ccd8
cmpl $0x41, %eax
pushq $0x40
popq %rsi
cmovael %eax, %esi
movq %r15, %rdi
callq 0x24643c
testq %r14, %r14
je 0x2468c8
leaq (%r14,%rbx,8), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x2468d6
shlq ... | /llvm/ADT/DenseMap.h |
maybePrintComdat(llvm::formatted_raw_ostream&, llvm::GlobalObject const&) | static OrderMap orderModule(const Module *M) {
OrderMap OM;
for (const GlobalVariable &G : M->globals()) {
if (G.hasInitializer())
if (!isa<GlobalValue>(G.getInitializer()))
orderValue(G.getInitializer(), OM);
orderValue(&G, OM);
}
for (const GlobalAlias &A : M->aliases()) {
if (!isa<... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x30(%rsi), %r14
testq %r14, %r14
je 0x247200
movq %rsi, %r15
movq %rdi, %rbx
cmpb $0x3, (%rsi)
jne 0x2471c6
pushq $0x2c
popq %rsi
movq %rbx, %rdi
callq 0x8e162
leaq 0x139a5c(%rip), %rsi # 0x380c29
movq %rbx, %rdi
callq 0x8d86a
movq %r15, %rdi
callq 0x2ad38... | /IR/AsmWriter.cpp |
llvm::DenseMap<llvm::Value const*, unsigned int, llvm::DenseMapInfo<llvm::Value const*, void>, llvm::detail::DenseMapPair<llvm::Value const*, unsigned int>>::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 0x8ccd8
cmpl $0x41, %eax
pushq $0x40
popq %rsi
cmovael %eax, %esi
movq %r15, %rdi
callq 0x2481f0
testq %r14, %r14
je 0x2481e2
shlq $0x4, %rbx
leaq (%r14,%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq ... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::Value const*, unsigned int, llvm::DenseMapInfo<llvm::Value const*, void>, llvm::detail::DenseMapPair<llvm::Value const*, unsigned int>>, llvm::Value const*, unsigned int, llvm::DenseMapInfo<llvm::Value const*, void>, llvm::detail::DenseMapPair<llvm::Value const*, unsigned int>>::... | 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 0x248222
movl $0x1000, %r13d # imm = 0x1000
leaq 0x8(%rsp), %r12
cmpq %rbx, %r14
je 0x2482b0
movq (%r14), %rax
orq %r13, %rax
cmpq $-0x1000, %rax # imm = 0xF000
je 0x2482aa
mov... | /llvm/ADT/DenseMap.h |
void (anonymous namespace)::MDFieldPrinter::printDwarfEnum<unsigned int, llvm::StringRef (*)(unsigned int)>(llvm::StringRef, unsigned int, llvm::StringRef (*)(unsigned int), bool) | void MDFieldPrinter::printDwarfEnum(StringRef Name, IntTy Value,
Stringifier toString, bool ShouldSkipZero) {
if (!Value)
return;
Out << FS << Name << ": ";
auto S = toString(Value);
if (!S.empty())
Out << S;
else
Out << Value;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testl %ecx, %ecx
je 0x24aca6
movq %r8, %r15
movl %ecx, %ebx
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movq (%rdi), %rdi
leaq 0x8(%r14), %rsi
callq 0x247a12
movq %rax, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x8d898
leaq 0x128bb6(%rip), %rsi # 0x373836
m... | /IR/AsmWriter.cpp |
llvm::DIFile::getChecksum() const | std::optional<ChecksumInfo<StringRef>> getChecksum() const {
std::optional<ChecksumInfo<StringRef>> StringRefChecksum;
if (Checksum)
StringRefChecksum.emplace(Checksum->Kind, Checksum->Value->getString());
return StringRefChecksum;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x0, 0x18(%rdi)
cmpb $0x1, 0x20(%rsi)
jne 0x24af5f
movq %rsi, %r14
movq 0x18(%rsi), %rdi
callq 0x29f646
movl 0x10(%r14), %ecx
movl %ecx, (%rbx)
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
movb $0x1, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq... | /llvm/IR/DebugInfoMetadata.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::AttributeList, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::AttributeList, void>, llvm::detail::DenseSetPair<llvm::AttributeList>>, llvm::AttributeList, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::AttributeList, void>, llvm::detail::DenseSetPair<llvm::Attribute... | 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 0x24b628
pushq %rax
shll $0x2, %esi
pushq $0x3
popq %rcx
movl %esi, %eax
xorl %edx, %edx
divl %ecx
leal 0x1(%rax), %edi
callq 0x8ccd8
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
nop
| /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::AttributeList, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::AttributeList, void>, llvm::detail::DenseSetPair<llvm::AttributeList>>::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 0x24b64b
movl %ebp, %edi
shlq $0x3, %rdi
pushq $0x8
popq %rsi
callq 0x1f2dd6
jmp 0x24b64d
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 |
llvm::DenseMap<llvm::Type*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::Type*, void>, llvm::detail::DenseSetPair<llvm::Type*>>::init(unsigned int) | void init(unsigned InitNumEntries) {
auto InitBuckets = BaseT::getMinBucketToReserveForEntries(InitNumEntries);
if (allocateBuckets(InitBuckets)) {
this->BaseT::initEmpty();
} else {
NumEntries = 0;
NumTombstones = 0;
}
} | pushq %rbx
movq %rdi, %rbx
callq 0x24b6ac
movq %rbx, %rdi
movl %eax, %esi
callq 0x24b6ce
testb %al, %al
je 0x24b6a4
movq %rbx, %rdi
popq %rbx
jmp 0x24b700
andq $0x0, 0x8(%rbx)
popq %rbx
retq
nop
| /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::Type*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::Type*, void>, llvm::detail::DenseSetPair<llvm::Type*>>, llvm::Type*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::Type*, void>, llvm::detail::DenseSetPair<llvm::Type*>>::getMinBucketToReserveForEntries(unsigned... | 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 0x24b6ca
pushq %rax
shll $0x2, %esi
pushq $0x3
popq %rcx
movl %esi, %eax
xorl %edx, %edx
divl %ecx
leal 0x1(%rax), %edi
callq 0x8ccd8
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
nop
| /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::Type*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::Type*, void>, llvm::detail::DenseSetPair<llvm::Type*>>::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 0x24b6ed
movl %ebp, %edi
shlq $0x3, %rdi
pushq $0x8
popq %rsi
callq 0x1f2dd6
jmp 0x24b6ef
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 |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::StructType*, unsigned int, llvm::DenseMapInfo<llvm::StructType*, void>, llvm::detail::DenseMapPair<llvm::StructType*, unsigned int>>, llvm::StructType*, unsigned int, llvm::DenseMapInfo<llvm::StructType*, void>, llvm::detail::DenseMapPair<llvm::StructType*, unsigned int>>::L... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x24b832
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 |
(anonymous namespace)::AssemblyWriter::writeParamOperand(llvm::Value const*, llvm::AttributeSet) | void AssemblyWriter::writeParamOperand(const Value *Operand,
AttributeSet Attrs) {
if (!Operand) {
Out << "<null operand!>";
return;
}
// Print the type
TypePrinter.print(Operand->getType(), Out);
// Print parameter attributes list
if (Attrs.hasAttributes()) {... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq %rdx, (%rsp)
testq %rsi, %rsi
je 0x24bc2c
movq %rdx, %r12
movq %rsi, %rbx
leaq 0x28(%r14), %r15
movq 0x8(%rsi), %rsi
movq (%r14), %rdx
movq %r15, %rdi
callq 0x242964
testq %r12, %r12
je 0x24bbe7
movq (%r14), %rdi
pushq $0x20
popq %rsi
cal... | /IR/AsmWriter.cpp |
llvm::SmallVectorTemplateBase<std::pair<unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, false>::moveElementsForGrow(std::pair<unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*) | 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 $0x28, %rax, %rsi
addq %rdi, %rsi
callq 0x24c7b6
movq (%rbx), %rdi
movl 0x8(%rbx), %eax
imulq $0x28, %rax, %rsi
addq %rdi, %rsi
popq %rbx
jmp 0x24c790
| /llvm/ADT/SmallVector.h |
llvm::DenseMap<llvm::AttributeSet, unsigned int, llvm::DenseMapInfo<llvm::AttributeSet, void>, llvm::detail::DenseMapPair<llvm::AttributeSet, unsigned int>>::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 0x24c939
movl %ebp, %edi
shlq $0x4, %rdi
pushq $0x8
popq %rsi
callq 0x1f2dd6
jmp 0x24c93b
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 |
llvm::DenseMap<llvm::AttributeSet, unsigned int, llvm::DenseMapInfo<llvm::AttributeSet, void>, llvm::detail::DenseMapPair<llvm::AttributeSet, unsigned int>>::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 0x8ccd8
cmpl $0x41, %eax
pushq $0x40
popq %rsi
cmovael %eax, %esi
movq %r15, %rdi
callq 0x24c91a
testq %r14, %r14
je 0x24ceb4
shlq $0x4, %rbx
leaq (%r14,%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq ... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::AttributeSet, unsigned int, llvm::DenseMapInfo<llvm::AttributeSet, void>, llvm::detail::DenseMapPair<llvm::AttributeSet, unsigned int>>, llvm::AttributeSet, unsigned int, llvm::DenseMapInfo<llvm::AttributeSet, void>, llvm::detail::DenseMapPair<llvm::AttributeSet, unsigned int>>::... | 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 0x24c94c
movq %rsp, %r12
cmpq %rbx, %r14
je 0x24cf1a
movq (%r14), %rax
orq $0x4, %rax
cmpq $-0x4, %rax
je 0x24cf14
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x24ca82
movq (%rsp), %rax
movq (%r14), %r... | /llvm/ADT/DenseMap.h |
llvm::Attribute::get(llvm::LLVMContext&, llvm::StringRef, llvm::StringRef) | Attribute Attribute::get(LLVMContext &Context, StringRef Kind, StringRef Val) {
LLVMContextImpl *pImpl = Context.pImpl;
FoldingSetNodeID ID;
ID.AddString(Kind);
if (!Val.empty()) ID.AddString(Val);
void *InsertPoint;
AttributeImpl *PA = pImpl->AttrsSet.FindNodeOrInsertPos(ID, InsertPoint);
if (!PA) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq (%rdi), %r13
leaq 0x28(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x2000000000, %rcx # imm = 0x2000000000
movq %rcx, -0x8(%rax)
leaq 0x18(%rsp), %rdi
callq 0x336126... | /IR/Attributes.cpp |
llvm::Attribute::get(llvm::LLVMContext&, llvm::Attribute::AttrKind, llvm::ConstantRange const&) | Attribute Attribute::get(LLVMContext &Context, Attribute::AttrKind Kind,
const ConstantRange &CR) {
assert(Attribute::isConstantRangeAttrKind(Kind) &&
"Not a ConstantRange attribute");
LLVMContextImpl *pImpl = Context.pImpl;
FoldingSetNodeID ID;
ID.AddInteger(Kind);
CR.getLow... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq (%rdi), %r14
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x2000000000, %rcx # imm = 0x2000000000
movq %rcx, -0x8(%rax)
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0x109dae
movq %rbx, %rdi
movq %r12... | /IR/Attributes.cpp |
llvm::Attribute::getAttrKindFromName(llvm::StringRef) | Attribute::AttrKind Attribute::getAttrKindFromName(StringRef AttrName) {
return StringSwitch<Attribute::AttrKind>(AttrName)
#define GET_ATTR_NAMES
#define ATTRIBUTE_ENUM(ENUM_NAME, DISPLAY_NAME) \
.Case(#DISPLAY_NAME, Attribute::ENUM_NAME)
#include "llvm/IR/Attributes.inc"
.Defa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsp, %rax
movq %rdi, (%rax)
movq %rsi, 0x8(%rax)
movb $0x0, 0x14(%rax)
leaq 0x1343b5(%rip), %rsi # 0x381850
pushq $0xa
popq %r14
pushq $0x1
popq %rcx
movq %rax, %rdi
movq %r14, %rdx
callq 0x24dc7c
leaq 0x1343a7(%rip), %rsi # ... | /IR/Attributes.cpp |
llvm::Attribute::getAllocSizeArgs() const | std::pair<unsigned, std::optional<unsigned>>
Attribute::getAllocSizeArgs() const {
assert(hasAttribute(Attribute::AllocSize) &&
"Trying to get allocsize args from non-allocsize attribute");
return unpackAllocSizeArgs(pImpl->getValueAsInt());
} | movq (%rdi), %rax
movq 0x10(%rax), %rax
movl %eax, %ecx
movq %rcx, %rsi
btsq $0x20, %rsi
xorl %edx, %edx
movl $0xffffffff, %edi # imm = 0xFFFFFFFF
cmpq %rdi, %rcx
cmovneq %rsi, %rdx
shrq $0x20, %rax
movl %eax, -0x10(%rsp)
movq %rdx, -0xc(%rsp)
movq -0x10(%rsp), %rax
shrq $0x20, %rdx
retq
| /IR/Attributes.cpp |
llvm::AttrBuilder::merge(llvm::AttrBuilder const&) | AttrBuilder &AttrBuilder::merge(const AttrBuilder &B) {
// TODO: Could make this O(n) as we're merging two sorted lists.
for (const auto &I : B.attrs())
addAttribute(I);
return *this;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rsi), %r14
movl 0x10(%rsi), %r15d
shlq $0x3, %r15
xorl %r12d, %r12d
cmpq %r12, %r15
je 0x24f4c5
movq (%r14,%r12), %rsi
movq %rbx, %rdi
callq 0x2507f6
addq $0x8, %r12
jmp 0x24f4ae
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r1... | /IR/Attributes.cpp |
llvm::AttributeList::get(llvm::LLVMContext&, unsigned int, llvm::AttributeSet) | AttributeList AttributeList::get(LLVMContext &C, unsigned Index,
AttributeSet Attrs) {
if (!Attrs.hasAttributes())
return {};
Index = attrIdxToArrayIdx(Index);
SmallVector<AttributeSet, 8> AttrSets(Index + 1);
AttrSets[Index] = Attrs;
return getImpl(C, AttrSets);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
testq %rdx, %rdx
je 0x2504c5
movq %rdx, %r14
movq %rdi, %rbx
leal 0x1(%rsi), %r12d
addl $0x2, %esi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x2504d6
movq (%r15), %rax
movq %r14, (%rax,%r12,8)
movq (%r15), %rsi
movl 0x8(%r15), %edx
movq %rbx, %rdi
callq 0x25... | /IR/Attributes.cpp |
llvm::AttributeList::addParamAttribute(llvm::LLVMContext&, llvm::ArrayRef<unsigned int>, llvm::Attribute) const | AttributeList AttributeList::addParamAttribute(LLVMContext &C,
ArrayRef<unsigned> ArgNos,
Attribute A) const {
assert(llvm::is_sorted(ArgNos));
SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end());
unsigned... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq (%rdi), %rcx
leaq 0x28(%rcx), %rax
movq %rax, %rsi
testq %rcx, %rcx
cmoveq %rcx, %rsi
je 0x2508af
movl 0x8(%rcx), %ecx
leaq (%rax,%rcx,8), %rdx
jmp 0x2508b1
xorl %e... | /IR/Attributes.cpp |
upgradeMaskedStore(llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>&, llvm::Value*, llvm::Value*, llvm::Value*, bool) | static Value *upgradeMaskedStore(IRBuilder<> &Builder, Value *Ptr, Value *Data,
Value *Mask, bool Aligned) {
// Cast the pointer to the right type.
Ptr = Builder.CreateBitCast(Ptr,
llvm::PointerType::getUnqual(Data->getType()));
const Align Alignment ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %r8d, %ebp
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq 0x8(%rdx), %rdi
callq 0x240300
leaq 0x8(%rsp), %rcx
movw $0x101, 0x20(%rcx) # imm = 0x101
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x258498
movq ... | /IR/AutoUpgrade.cpp |
llvm::IRBuilderBase::CreateZExt(llvm::Value*, llvm::Type*, llvm::Twine const&, bool) | Value *CreateZExt(Value *V, Type *DestTy, const Twine &Name = "",
bool IsNonNeg = false) {
if (V->getType() == DestTy)
return V;
if (Value *Folded = Folder.FoldCast(Instruction::ZExt, V, DestTy))
return Folded;
Instruction *I = Insert(new ZExtInst(V, DestTy), Name);
if (I... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r13
cmpq %rdx, 0x8(%rsi)
je 0x2654ec
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r12
movq %rdi, %r15
movq 0x50(%rdi), %rdi
movq (%rdi), %rax
pushq $0x27
popq %rsi
movq %r13, %rdx
movq %r12, %rcx
callq *0x78(%rax)
movq %rax, %... | /llvm/IR/IRBuilder.h |
emitX86Select(llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>&, llvm::Value*, llvm::Value*, llvm::Value*) | static Value *emitX86Select(IRBuilder<> &Builder, Value *Mask, Value *Op0,
Value *Op1) {
// If the mask is all ones just emit the first operation.
if (const auto *C = dyn_cast<Constant>(Mask))
if (C->isAllOnesValue())
return Op0;
Mask = getX86MaskVec(Builder, Mask,
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
cmpb $0x15, (%rsi)
ja 0x265565
movq %r12, %rdi
callq 0x269b0c
testb %al, %al
jne 0x265598
movq 0x8(%rbx), %rax
movl 0x20(%rax), %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x260437
movq %rsp, %r8
... | /IR/AutoUpgrade.cpp |
llvm::IRBuilderBase::CreateFSub(llvm::Value*, llvm::Value*, llvm::Twine const&, llvm::MDNode*) | Value *CreateFSub(Value *L, Value *R, const Twine &Name = "",
MDNode *FPMD = nullptr) {
if (IsFPConstrained)
return CreateConstrainedFPBinOp(Intrinsic::experimental_constrained_fsub,
L, R, nullptr, Name, FPMD);
if (Value *V = Folder.FoldBinOpFMF(I... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r8, %r15
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
cmpb $0x1, 0x6c(%rdi)
jne 0x26587b
andl $0x0, 0x10(%rsp)
andl $0x0, 0x8(%rsp)
movq %r15, (%rsp)
pushq $0x70
popq %rsi
movq %r14, %rdi
movq %r13, %rdx
movq %r12, %rcx
xor... | /llvm/IR/IRBuilder.h |
upgradeMaskedCompare(llvm::IRBuilder<llvm::ConstantFolder, llvm::IRBuilderDefaultInserter>&, llvm::CallBase&, unsigned int, bool) | static Value *upgradeMaskedCompare(IRBuilder<> &Builder, CallBase &CI,
unsigned CC, bool Signed) {
Value *Op0 = CI.getArgOperand(0);
unsigned NumElts = cast<FixedVectorType>(Op0->getType())->getNumElements();
Value *Cmp;
if (CC == 3) {
Cmp = Constant::getNullValue(
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %eax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x4(%rsi), %edx
shll $0x5, %edx
movq %rsi, %rdi
subq %rdx, %rdi
movq (%rdi), %rdx
movq 0x8(%rdx), %rsi
movl 0x20(%rsi), %ebp
movl %eax, %eax
leaq 0x11c9b5(%rip), %rsi # 0x38247c
movslq (%rsi,%rax,4), %ra... | /IR/AutoUpgrade.cpp |
llvm::cl::opt<bool, true, llvm::cl::parser<bool>>::opt<char [50], llvm::cl::OptionHidden, llvm::cl::LocationClass<bool>, llvm::cl::initializer<bool>>(char const (&) [50], llvm::cl::OptionHidden const&, llvm::cl::LocationClass<bool> 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 0x8e812
andq $0x0, 0x80(%r14)
movb $0x0, 0x91(%r14)
leaq 0x2ff4e6(%rip), %rax # 0x566cb8
addq $0x10, %rax
movq %rax, 0x88(%r14)
leaq 0x303874(%ri... | /llvm/Support/CommandLine.h |
llvm::BasicBlock::~BasicBlock() | BasicBlock::~BasicBlock() {
validateInstrOrdering();
// If the address of the block is taken and it is being deleted (e.g. because
// it is dead), this means that there is either a dangling constant expr
// hanging off the block, or an undefined use of the block (source code
// expecting the address of a lab... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movzwl 0x2(%rdi), %eax
testw $0x7fff, %ax # imm = 0x7FFF
je 0x267d6a
movq 0x8(%rbx), %rax
movq (%rax), %rdi
callq 0x2a92d4
pushq $0x1
popq %rsi
movq %rax, %rdi
xorl %edx, %edx
callq 0x26ac44
movq %rax, %r14
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x267d6a
mo... | /IR/BasicBlock.cpp |
llvm::BasicBlock::dropAllReferences() | void BasicBlock::dropAllReferences() {
for (Instruction &I : *this)
I.dropAllReferences();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x38(%rdi), %r14
addq $0x30, %rbx
movq (%r14), %r14
cmpq %rbx, %r14
je 0x267deb
leaq -0x18(%r14), %rdi
testq %r14, %r14
cmoveq %r14, %rdi
callq 0x267f9e
addq $0x8, %r14
jmp 0x267dcd
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /IR/BasicBlock.cpp |
llvm::BasicBlock::phis() | inline bool empty() const { return InstList.empty(); } | leaq 0x30(%rdi), %rax
cmpq %rax, 0x30(%rdi)
je 0x2680d8
movq 0x38(%rdi), %rax
leaq -0x18(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
xorl %eax, %eax
cmpb $0x54, (%rcx)
cmoveq %rcx, %rax
jmp 0x2680da
xorl %eax, %eax
xorl %edx, %edx
retq
nop
| /llvm/IR/BasicBlock.h |
llvm::PredIterator<llvm::BasicBlock, llvm::Value::user_iterator_impl<llvm::User>>::operator++() | inline Self& operator++() { // Preincrement
assert(!It.atEnd() && "pred_iterator out of range!");
++It; advancePastNonTerminators();
return *this;
} | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rax), %rax
movq %rax, (%rdi)
callq 0x2684fe
movq %rbx, %rax
popq %rbx
retq
| /llvm/IR/CFG.h |
llvm::BasicBlock::flushTerminatorDbgRecords() | void BasicBlock::flushTerminatorDbgRecords() {
// If we erase the terminator in a block, any DbgRecords will sink and "fall
// off the end", existing after any terminator that gets inserted. With
// dbg.value intrinsics we would just insert the terminator at end() and
// the dbg.values would come before the ter... | pushq %r15
pushq %r14
pushq %rbx
cmpb $0x1, 0x28(%rdi)
jne 0x2682b0
movq %rdi, %rbx
leaq 0x30(%rdi), %rax
movq 0x30(%rdi), %r15
cmpq %rax, %r15
je 0x2682b0
movzbl -0x18(%r15), %eax
addl $-0x1e, %eax
cmpl $0xa, %eax
ja 0x2682b0
movq %rbx, %rdi
callq 0x2678d8
testq %rax, %rax
je 0x2682b0
movq %rax, %r14
leaq -0x18(%r15),... | /IR/BasicBlock.cpp |
containsUndefinedElement(llvm::Constant const*, llvm::function_ref<bool (llvm::Constant const*)>) | bool Constant::hasExactInverseFP() const {
if (auto *CFP = dyn_cast<ConstantFP>(this))
return CFP->getValueAPF().getExactInverse(nullptr);
if (auto *VTy = dyn_cast<FixedVectorType>(getType())) {
for (unsigned I = 0, E = VTy->getNumElements(); I != E; ++I) {
auto *CFP = dyn_cast_or_null<ConstantFP>(ge... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rdi), %r13
xorl %ebp, %ebp
testq %r13, %r13
je 0x269cdb
movl $0xfe, %eax
andl 0x8(%r13), %eax
cmpl $0x12, %eax
jne 0x269cdb
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, %rdi
movq %r15, %rsi
callq *%r14
movb $0x1, %bpl
t... | /IR/Constants.cpp |
llvm::Constant::getNullValue(llvm::Type*) | TypeID getTypeID() const { return ID; } | movzbl 0x8(%rdi), %eax
leaq 0x11ad0b(%rip), %rcx # 0x384a94
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rbx
callq 0x2a8f48
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x269eb4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x269e46
... | /llvm/IR/Type.h |
llvm::ConstantInt::getTrue(llvm::Type*) | Constant *ConstantInt::getTrue(Type *Ty) {
assert(Ty->isIntOrIntVectorTy(1) && "Type not i1 or vector of i1.");
ConstantInt *TrueC = ConstantInt::getTrue(Ty->getContext());
if (auto *VTy = dyn_cast<VectorType>(Ty))
return ConstantVector::getSplat(VTy->getElementCount(), TrueC);
return TrueC;
} | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x26ac18
movl 0x8(%rbx), %ecx
movl %ecx, %edx
andl $0xfe, %edx
cmpl $0x12, %edx
jne 0x26acec
movl 0x20(%rbx), %edx
notl %ecx
xorl %edi, %edi
testb $0x13, %cl
sete %dil
shlq $0x20, %rdi
orq %rdx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x26a0f6
popq %rbx
retq
| /IR/Constants.cpp |
llvm::ConstantInt::getFalse(llvm::Type*) | Constant *ConstantInt::getFalse(Type *Ty) {
assert(Ty->isIntOrIntVectorTy(1) && "Type not i1 or vector of i1.");
ConstantInt *FalseC = ConstantInt::getFalse(Ty->getContext());
if (auto *VTy = dyn_cast<VectorType>(Ty))
return ConstantVector::getSplat(VTy->getElementCount(), FalseC);
return FalseC;
} | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x26ac88
movl 0x8(%rbx), %ecx
movl %ecx, %edx
andl $0xfe, %edx
cmpl $0x12, %edx
jne 0x26ad28
movl 0x20(%rbx), %edx
notl %ecx
xorl %edi, %edi
testb $0x13, %cl
sete %dil
shlq $0x20, %rdi
orq %rdx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x26a0f6
popq %rbx
retq
| /IR/Constants.cpp |
llvm::ConstantInt::get(llvm::Type*, llvm::APInt const&) | Constant *ConstantInt::get(Type *Ty, const APInt& V) {
ConstantInt *C = get(Ty->getContext(), V);
assert(C->getType() == Ty->getScalarType() &&
"ConstantInt type doesn't match the type implied by its value!");
// For vectors, broadcast the value.
if (VectorType *VTy = dyn_cast<VectorType>(Ty))
ret... | pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x26a02a
movl 0x8(%rbx), %ecx
movl %ecx, %edx
andl $0xfe, %edx
cmpl $0x12, %edx
jne 0x26ae12
movl 0x20(%rbx), %edx
notl %ecx
xorl %edi, %edi
testb $0x13, %cl
sete %dil
shlq $0x20, %rdi
orq %rdx, %rdi
movq %rax, %rsi
popq %rbx
jmp 0x26a0f6
popq %rbx
retq
| /IR/Constants.cpp |
llvm::PoisonValue::get(llvm::Type*) | PoisonValue *PoisonValue::get(Type *Ty) {
std::unique_ptr<PoisonValue> &Entry = Ty->getContext().pImpl->PVConstants[Ty];
if (!Entry)
Entry.reset(new PoisonValue(Ty));
return Entry.get();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsp, %rsi
movq %rdi, (%rsi)
movq (%rdi), %rax
movl $0x5f0, %edi # imm = 0x5F0
addq (%rax), %rdi
callq 0x273008
movq %rax, %rbx
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x26b245
addq $0x8, %rbx
pushq $0x18
popq %rdi
callq 0x26ad2a
movq %rax, %r14
movq (%rsp), %rsi
movq ... | /IR/Constants.cpp |
llvm::ConstantUniqueMap<llvm::ConstantStruct>::getOrCreate(llvm::StructType*, llvm::ConstantAggrKeyType<llvm::ConstantStruct>) | ConstantClass *getOrCreate(TypeClass *Ty, ValType V) {
LookupKey Key(Ty, V);
/// Hash once, and reuse it for the lookup and the insertion if needed.
LookupKeyHashed Lookup(MapInfo::getHashValue(Key), Key);
ConstantClass *Result = nullptr;
auto I = Map.find_as(Lookup);
if (I == Map.end())
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x28(%rsp), %r13
movq %rsi, (%r13)
movq %rdx, 0x8(%r13)
movq %rcx, 0x10(%r13)
movq %r13, %rdi
callq 0x2710d4
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
movups (%r13), %xmm0
movups %xm... | /IR/ConstantsContext.h |
llvm::ConstantDataVector::getSplat(unsigned int, llvm::Constant*) | Constant *ConstantDataVector::getSplat(unsigned NumElts, Constant *V) {
assert(isElementTypeCompatible(V->getType()) &&
"Element type not compatible with ConstantData");
if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
if (CI->getType()->isIntegerTy(8)) {
SmallVector<uint8_t, 16> Elts(NumElts, C... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rsi, %rbx
movl %edi, %ebp
movzbl (%rsi), %eax
cmpl $0x12, %eax
je 0x26c18a
cmpl $0x11, %eax
jne 0x26c201
movq 0x8(%rbx), %rdi
pushq $0x8
popq %rsi
callq 0x2a8df8
testb %al, %al
je 0x26c21a
movl %ebp, %esi
cmpl $0x41, 0x20(%rbx)
jb 0x26c27e
mo... | /IR/Constants.cpp |
llvm::ConstantExpr::getExtractElement(llvm::Constant*, llvm::Constant*, llvm::Type*) | Constant *ConstantExpr::getExtractElement(Constant *Val, Constant *Idx,
Type *OnlyIfReducedTy) {
assert(Val->getType()->isVectorTy() &&
"Tried to create extractelement operation on non-vector type!");
assert(Idx->getType()->isIntegerTy() &&
"Extractelement... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
callq 0x2cd92a
movq %rax, %r14
testq %rax, %rax
jne 0x26c941
movq 0x8(%r15), %rax
movq 0x18(%rax), %r14
cmpq %r12, %r14
je 0x26c93e
movq %rsp, %rax
movq %r15, (%rax)
movq %rbx, 0x8(%rax)
xorps %xmm0, %xmm0
leaq ... | /IR/Constants.cpp |
llvm::BlockAddress::lookup(llvm::BasicBlock const*) | unsigned short getSubclassDataFromValue() const { return SubclassData; } | movzwl 0x2(%rdi), %eax
testw $0x7fff, %ax # imm = 0x7FFF
je 0x26ce4d
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x48(%rdi), %r14
movq %r14, %rdi
callq 0x28ba62
movl $0x620, %edi # imm = 0x620
addq (%rax), %rdi
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
movq %rbx, 0x8(%rsi)
callq 0x26c... | /llvm/IR/Value.h |
llvm::ConstantExpr::getPtrToInt(llvm::Constant*, llvm::Type*, bool) | Constant *ConstantExpr::getPtrToInt(Constant *C, Type *DstTy,
bool OnlyIfReduced) {
assert(C->getType()->isPtrOrPtrVectorTy() &&
"PtrToInt source must be pointer or pointer vector");
assert(DstTy->isIntOrIntVectorTy() &&
"PtrToInt destination must be integer or ... | movl %edx, %ecx
movq %rsi, %rdx
movq %rdi, %rsi
pushq $0x2f
popq %rdi
jmp 0x26d6f7
| /IR/Constants.cpp |
char* llvm::hashing::detail::hash_combine_recursive_helper::combine_data<llvm::VectorType*>(unsigned long&, char*, char*, llvm::VectorType*) | char *combine_data(size_t &length, char *buffer_ptr, char *buffer_end, T data) {
if (!store_and_advance(buffer_ptr, buffer_end, data)) {
// Check for skew which prevents the buffer from being packed, and do
// a partial store into the buffer to fill it. This is only a concern
// with the variadic ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r8, (%rsp)
leaq 0x8(%rdx), %r13
cmpq %rcx, %r13
jbe 0x27198c
movq %rcx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq %rcx, %r15
subq %rdx, %r15
movq %rsp, %rsi
movq %rdx, %rdi
movq %r15, %rdx
callq 0x890a0
cmpq $0x0, (%r12)
je 0x271991
leaq 0x40... | /llvm/ADT/Hashing.h |
llvm::detail::DenseSetPair<llvm::ConstantVector*>* llvm::DenseMapBase<llvm::DenseMap<llvm::ConstantVector*, llvm::detail::DenseSetEmpty, llvm::ConstantUniqueMap<llvm::ConstantVector>::MapInfo, llvm::detail::DenseSetPair<llvm::ConstantVector*>>, llvm::ConstantVector*, llvm::detail::DenseSetEmpty, llvm::ConstantUniqueMap... | 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 0x271cbb
notl %eax
addl %esi, %eax
subl 0xc(%rbx), %eax
movl %esi, %ecx
shrl $0x3, %ecx
cmpl %ecx, %eax
jbe 0x271cbd
incl 0x8... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<std::pair<llvm::Function const*, llvm::BasicBlock const*>, llvm::BlockAddress*, llvm::DenseMapInfo<std::pair<llvm::Function const*, llvm::BasicBlock const*>, void>, llvm::detail::DenseMapPair<std::pair<llvm::Function const*, llvm::BasicBlock const*>, llvm::BlockAddress*>>, std::pair<ll... | 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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x273478
movq $-0x1000, %r13 # imm = 0xF000
movq $-0x2000, %rbp # imm = 0xE000
movq %rsp, %r12
cmpq %rbx, %r14
je 0x27352e
movq (%r14), %rax
movq 0x8(%r14), %rcx
movq %rax... | /llvm/ADT/DenseMap.h |
llvm::DenseMapIterator<llvm::ConstantPtrAuth*, llvm::detail::DenseSetEmpty, llvm::ConstantUniqueMap<llvm::ConstantPtrAuth>::MapInfo, llvm::detail::DenseSetPair<llvm::ConstantPtrAuth*>, false> llvm::DenseMapBase<llvm::DenseMap<llvm::ConstantPtrAuth*, llvm::detail::DenseSetEmpty, llvm::ConstantUniqueMap<llvm::ConstantPtr... | iterator find_as(const LookupKeyT &Val) {
BucketT *TheBucket;
if (LookupBucketFor(Val, TheBucket))
return makeIterator(TheBucket,
shouldReverseIterate<KeyT>() ? getBuckets()
: getBucketsEnd(),
*this,... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
callq 0x273cc6
testb %al, %al
je 0x273cb3
movq 0x8(%rsp), %rax
movl 0x10(%rbx), %edx
shlq $0x3, %rdx
addq (%rbx), %rdx
jmp 0x273cc0
movl 0x10(%rbx), %eax
shlq $0x3, %rax
addq (%rbx), %rax
movq %rax, %rdx
addq $0x10, %rsp
popq %rbx
retq
| /llvm/ADT/DenseMap.h |
std::pair<llvm::DenseMapIterator<llvm::ConstantPtrAuth*, llvm::detail::DenseSetEmpty, llvm::ConstantUniqueMap<llvm::ConstantPtrAuth>::MapInfo, llvm::detail::DenseSetPair<llvm::ConstantPtrAuth*>, false>, bool> llvm::DenseMapBase<llvm::DenseMap<llvm::ConstantPtrAuth*, llvm::detail::DenseSetEmpty, llvm::ConstantUniqueMap<... | std::pair<iterator, bool> insert_as(std::pair<KeyT, ValueT> &&KV,
const LookupKeyT &Val) {
BucketT *TheBucket;
if (LookupBucketFor(Val, TheBucket))
return std::make_pair(makeIterator(TheBucket,
shouldReverseIterate<KeyT>()
... | 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 %rcx, %rsi
movq %r13, %rdx
callq 0x273cc6
movl %eax, %ecx
movq (%r13), %rax
testb %cl, %cl
je 0x273e94
xorl %ecx, %ecx
jmp 0x273eac
leaq 0x8(%... | /llvm/ADT/DenseMap.h |
std::enable_if<is_hashable_data<int const>::value, llvm::hash_code>::type llvm::hashing::detail::hash_combine_range_impl<int const>(int const*, int const*) | std::enable_if_t<is_hashable_data<ValueT>::value, hash_code>
hash_combine_range_impl(ValueT *first, ValueT *last) {
const uint64_t seed = get_execution_seed();
const char *s_begin = reinterpret_cast<const char *>(first);
const char *s_end = reinterpret_cast<const char *>(last);
const size_t length = std::distan... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r15
movabsq $-0xae502812aa7333, %rdx # imm = 0xFF51AFD7ED558CCD
movq %rsi, %rbx
subq %rdi, %rbx
cmpq $0x40, %rbx
ja 0x2745af
movq %r15, %rdi
movq %rbx, %rsi
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1dfcc4... | /llvm/ADT/Hashing.h |
llvm::DenseMapIterator<llvm::ConstantExpr*, llvm::detail::DenseSetEmpty, llvm::ConstantUniqueMap<llvm::ConstantExpr>::MapInfo, llvm::detail::DenseSetPair<llvm::ConstantExpr*>, false> llvm::DenseMapBase<llvm::DenseMap<llvm::ConstantExpr*, llvm::detail::DenseSetEmpty, llvm::ConstantUniqueMap<llvm::ConstantExpr>::MapInfo,... | iterator find_as(const LookupKeyT &Val) {
BucketT *TheBucket;
if (LookupBucketFor(Val, TheBucket))
return makeIterator(TheBucket,
shouldReverseIterate<KeyT>() ? getBuckets()
: getBucketsEnd(),
*this,... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
callq 0x274662
testb %al, %al
je 0x27464f
movq 0x8(%rsp), %rax
movl 0x10(%rbx), %edx
shlq $0x3, %rdx
addq (%rbx), %rdx
jmp 0x27465c
movl 0x10(%rbx), %eax
shlq $0x3, %rax
addq (%rbx), %rax
movq %rax, %rdx
addq $0x10, %rsp
popq %rbx
retq
| /llvm/ADT/DenseMap.h |
llvm::ConstantExprKeyType::create(llvm::Type*) const | ConstantExpr *create(TypeClass *Ty) const {
switch (Opcode) {
default:
if (Instruction::isCast(Opcode))
return new CastConstantExpr(Opcode, Ops[0], Ty);
if ((Opcode >= Instruction::BinaryOpsBegin &&
Opcode < Instruction::BinaryOpsEnd))
return new BinaryConstantExpr(Opcode,... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movzbl (%rdi), %eax
cmpl $0x22, %eax
je 0x2749d4
cmpl $0x3d, %eax
je 0x27498a
cmpl $0x3e, %eax
je 0x2749ad
cmpl $0x3f, %eax
jne 0x274a35
pushq $0x40
popq %rdi
callq 0x274c26
movq %rax, %r14
movq 0x8(%rbx),... | /IR/ConstantsContext.h |
llvm::DenseMap<llvm::ConstantExpr*, llvm::detail::DenseSetEmpty, llvm::ConstantUniqueMap<llvm::ConstantExpr>::MapInfo, llvm::detail::DenseSetPair<llvm::ConstantExpr*>>::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 0x274f3f
movl %ebp, %edi
shlq $0x3, %rdi
pushq $0x8
popq %rsi
callq 0x1f2dd6
jmp 0x274f41
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 |
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 0xd4498
movups (%r15), %xmm0
movups %xmm0, (%r14)
movups 0x10(%r15), %xmm0
movups %xmm0, 0x10(%r14)
cmp... | /IR/DataLayout.cpp |
llvm::DataLayout::getIntPtrType(llvm::Type*) const | Type *DataLayout::getIntPtrType(Type *Ty) const {
assert(Ty->isPtrOrPtrVectorTy() &&
"Expected a pointer or pointer vector type.");
unsigned NumBits = getPointerTypeSizeInBits(Ty);
IntegerType *IntTy = IntegerType::get(Ty->getContext(), NumBits);
if (VectorType *VecTy = dyn_cast<VectorType>(Ty))
re... | pushq %rbx
movq %rsi, %rbx
callq 0x276ee2
movq (%rbx), %rdi
movl %eax, %esi
callq 0x2a92ee
movl $0xfe, %ecx
andl 0x8(%rbx), %ecx
cmpl $0x12, %ecx
jne 0x277112
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x277114
popq %rbx
retq
| /IR/DataLayout.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::DIAssignID*, llvm::SmallVector<llvm::Instruction*, 1u>, llvm::DenseMapInfo<llvm::DIAssignID*, void>, llvm::detail::DenseMapPair<llvm::DIAssignID*, llvm::SmallVector<llvm::Instruction*, 1u>>>, llvm::DIAssignID*, llvm::SmallVector<llvm::Instruction*, 1u>, llvm::DenseMapInfo<llvm::D... | iterator find(const_arg_type_t<KeyT> Val) {
BucketT *TheBucket;
if (LookupBucketFor(Val, TheBucket))
return makeIterator(TheBucket,
shouldReverseIterate<KeyT>() ? getBuckets()
: getBucketsEnd(),
*thi... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movq %rsp, %rdx
movq %rax, %rsi
callq 0x2789e4
testb %al, %al
je 0x278185
movq (%rsp), %rax
movl 0x10(%rbx), %edx
shlq $0x5, %rdx
addq (%rbx), %rdx
jmp 0x278192
movl 0x10(%rbx), %eax
shlq $0x5, %rax
addq (%rbx), %rax
movq %rax, %rdx
addq... | /llvm/ADT/DenseMap.h |
llvm::DICompileUnit::DICompileUnit(llvm::LLVMContext&, llvm::Metadata::StorageType, unsigned int, bool, unsigned int, unsigned int, unsigned long, bool, bool, unsigned int, bool, llvm::ArrayRef<llvm::Metadata*>) | DICompileUnit::DICompileUnit(LLVMContext &C, StorageType Storage,
unsigned SourceLanguage, bool IsOptimized,
unsigned RuntimeVersion, unsigned EmissionKind,
uint64_t DWOId, bool SplitDebugInlining,
bool D... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movl %edx, %ecx
movq %rdi, %r15
movl 0x50(%rsp), %r12d
movq 0x58(%rsp), %r13
movaps 0x80(%rsp), %xmm0
movups %xmm0, (%rsp)
pushq $0x11
popq %rdx
movl %edx, %r8d
callq 0x27a8fa
movl %r14d, ... | /IR/DebugInfoMetadata.cpp |
llvm::DICompileUnit::getImpl(llvm::LLVMContext&, unsigned int, llvm::Metadata*, llvm::MDString*, bool, llvm::MDString*, unsigned int, llvm::MDString*, unsigned int, llvm::Metadata*, llvm::Metadata*, llvm::Metadata*, llvm::Metadata*, llvm::Metadata*, unsigned long, bool, bool, unsigned int, bool, llvm::MDString*, llvm::... | DICompileUnit *DICompileUnit::getImpl(
LLVMContext &Context, unsigned SourceLanguage, Metadata *File,
MDString *Producer, bool IsOptimized, MDString *Flags,
unsigned RuntimeVersion, MDString *SplitDebugFilename,
unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes,
Metadata *GlobalVar... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %r8d, %ebx
movl %esi, %ebp
movq %rdi, %r15
leaq 0x50(%rsp), %r14
movq %rdx, (%r14)
movq %rcx, 0x8(%r14)
movq %r9, 0x10(%r14)
movq 0xe8(%rsp), %rax
movq %rax, 0x18(%r14)
movq 0x118(%rsp), %rax
movups 0x108(%rsp), %xmm0
movups 0xf8(%r... | /IR/DebugInfoMetadata.cpp |
llvm::DISubprogram::toSPFlags(bool, bool, bool, unsigned int, bool) | DISubprogram::DISPFlags
DISubprogram::toSPFlags(bool IsLocalToUnit, bool IsDefinition, bool IsOptimized,
unsigned Virtuality, bool IsMainSubprogram) {
// We're assuming virtuality is the low-order field.
static_assert(int(SPFlagVirtual) == int(dwarf::DW_VIRTUALITY_virtual) &&
... | andl $0x3, %ecx
shll $0x2, %edi
shll $0x4, %edx
shll $0x8, %r8d
leal (%rdi,%rsi,8), %eax
orl %edx, %eax
orl %ecx, %eax
orl %r8d, %eax
retq
| /IR/DebugInfoMetadata.cpp |
llvm::DICommonBlock::getImpl(llvm::LLVMContext&, llvm::Metadata*, llvm::Metadata*, llvm::MDString*, llvm::Metadata*, unsigned int, llvm::Metadata::StorageType, bool) | DICommonBlock *DICommonBlock::getImpl(LLVMContext &Context, Metadata *Scope,
Metadata *Decl, MDString *Name,
Metadata *File, unsigned LineNo,
StorageType Storage, bool ShouldCreate) {
assert(isCanonical(N... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r14
movl 0x70(%rsp), %ecx
testl %ecx, %ecx
jne 0x27b751
movb 0x78(%rsp), %bpl
movq (%r14), %r15
leaq 0x4b0(%r15), %rdi
leaq 0x10(%rsp), %rsi
movq %rbx, (%rsi)
movq %r13, 0x8(%rs... | /IR/DebugInfoMetadata.cpp |
llvm::DILabel* llvm::MDNode::storeImpl<llvm::DILabel, llvm::DenseSet<llvm::DILabel*, llvm::MDNodeInfo<llvm::DILabel>>>(llvm::DILabel*, llvm::Metadata::StorageType, llvm::DenseSet<llvm::DILabel*, llvm::MDNodeInfo<llvm::DILabel>>&) | T *MDNode::storeImpl(T *N, StorageType Storage, StoreT &Store) {
switch (Storage) {
case Uniqued:
Store.insert(N);
break;
case Distinct:
N->storeDistinctInContext();
break;
case Temporary:
break;
}
return N;
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %rdi, (%rsp)
cmpl $0x1, %esi
je 0x27c24d
testl %esi, %esi
jne 0x27c255
leaq 0x8(%rsp), %rdi
movq %rsp, %rbx
movq %rdx, %rsi
movq %rbx, %rdx
callq 0x287222
movq (%rbx), %rbx
jmp 0x27c255
movq %rbx, %rdi
callq 0x29f992
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq
| /IR/MetadataImpl.h |
llvm::DIAssignID* llvm::MDNode::storeImpl<llvm::DIAssignID>(llvm::DIAssignID*, llvm::Metadata::StorageType) | T *MDNode::storeImpl(T *N, StorageType Storage) {
switch (Storage) {
case Uniqued:
llvm_unreachable("Cannot unique without a uniquing-store");
case Distinct:
N->storeDistinctInContext();
break;
case Temporary:
break;
}
return N;
} | pushq %rbx
movq %rdi, %rbx
cmpl $0x1, %esi
jne 0x27c4b9
movq %rbx, %rdi
callq 0x29f992
movq %rbx, %rax
popq %rbx
retq
| /IR/MetadataImpl.h |
llvm::DIArgList::track() | void DIArgList::track() {
for (ValueAsMetadata *&VAM : Args)
if (VAM)
MetadataTracking::track(&VAM, *VAM, *this);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x80(%rdi), %r14
movl 0x88(%rdi), %r15d
shlq $0x3, %r15
testq %r15, %r15
je 0x27d3d8
movq (%r14), %rsi
testq %rsi, %rsi
je 0x27d3ce
movq %r14, %rdi
movq %rbx, %rdx
callq 0x27d3de
addq $0x8, %r14
addq $-0x8, %r15
jmp 0x27d3b6
popq %rbx
popq %r14
popq %r15
retq
| /IR/DebugInfoMetadata.cpp |
void llvm::SmallVectorImpl<llvm::ValueAsMetadata*>::append<llvm::ValueAsMetadata* const*, void>(llvm::ValueAsMetadata* const*, llvm::ValueAsMetadata* 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 %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 0x23e920
subq %r15, %r14
je 0x27d4e6
movl 0x8(%rbx), %edi
shlq $0x3, %rdi
addq (%rbx), %rdi
movq %r15, %rsi
movq %r14, %rdx
ca... | /llvm/ADT/SmallVector.h |
llvm::detail::DenseSetPair<llvm::DILocation*>* llvm::DenseMapBase<llvm::DenseMap<llvm::DILocation*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DILocation>, llvm::detail::DenseSetPair<llvm::DILocation*>>, llvm::DILocation*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DILocation>, llvm::detail::DenseSetP... | 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 0x27dcab
notl %eax
addl %esi, %eax
subl 0xc(%rbx), %eax
movl %esi, %ecx
shrl $0x3, %ecx
cmpl %ecx, %eax
jbe 0x27dcad
incl 0x8... | /llvm/ADT/DenseMap.h |
bool llvm::MDNodeOpsKey::compareOps<llvm::MDOperand>(llvm::ArrayRef<llvm::MDOperand>, llvm::MDNode const*, unsigned int) | static bool compareOps(ArrayRef<T> Ops, const MDNode *RHS, unsigned Offset) {
if (Ops.size() != RHS->getNumOperands() - Offset)
return false;
return std::equal(Ops.begin(), Ops.end(), RHS->op_begin() + Offset);
} | pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %ebp
movq %rdi, %rbx
movq -0x10(%rdx), %rax
testb $0x2, %al
jne 0x27e1f5
shrl $0x6, %eax
andl $0xf, %eax
jmp 0x27e1f8
movl -0x18(%rdx), %eax
subl %ebp, %eax
cmpq %rsi, %rax
jne 0x27e224
addq $-0x10, %rdx
leaq (%rbx,%rsi,8), %r14
movq %rdx, %rdi
callq 0x23bfd8
movl %ebp, %ecx
... | /IR/LLVMContextImpl.h |
std::pair<llvm::DenseMapIterator<llvm::DIStringType*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DIStringType>, llvm::detail::DenseSetPair<llvm::DIStringType*>, false>, bool> llvm::DenseMapBase<llvm::DenseMap<llvm::DIStringType*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DIStringType>, llvm::detail::... | 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 0x2803ae
movl %eax, %ecx
movq (%r13), %rax
testb %cl, %cl
je 0x280374
xorl %ecx, %ecx
jmp 0x280387
movq %r14,... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::DIDerivedType*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DIDerivedType>, llvm::detail::DenseSetPair<llvm::DIDerivedType*>>, llvm::DIDerivedType*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DIDerivedType>, llvm::detail::DenseSetPair<llvm::DIDerivedType*>>::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
callq 0x2810d0
movl $0x1000, %r13d # imm = 0x1000
leaq 0x8(%rsp), %r12
cmpq %rbx, %r14
je 0x281152
movq (%r14), %rax
orq %r13, %rax
cmpq $-0x1000, %rax # imm = 0xF000
je 0x28114c
mov... | /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::DIFile*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DIFile>, llvm::detail::DenseSetPair<llvm::DIFile*>>, llvm::DIFile*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DIFile>, llvm::detail::DenseSetPair<llvm::DIFile*>>::LookupBucketFor<llvm::DIFile*>(llvm::DIFi... | 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 0x28277d
movq %rsi, %r14
movq (%rdi), %r15
movq %rsi, %rdi
callq 0x28279a
decl %ebp
movq (%r14), %rsi
pushq $0x1
popq %r8
xorl %edx, %edx
andl %ebp, %eax
leaq (%r15,%rax,8), %rdi
movq (%rdi), %r9
movb $0x1, ... | /llvm/ADT/DenseMap.h |
llvm::MDNodeKeyImpl<llvm::DISubprogram>::getHashValue() const | unsigned getHashValue() const {
// Use the Scope's linkage name instead of using the scope directly, as the
// scope may be a temporary one which can replaced, which would produce a
// different hash for the same DISubprogram.
llvm::StringRef ScopeLinkageName;
if (auto *CT = dyn_cast_or_null<DICompo... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x282b77
cmpb $0xe, (%rdi)
jne 0x282b77
callq 0x28085e
testq %rax, %rax
je 0x282b77
movq %rax, %rdi
callq 0x29f646
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
testb $0x8, 0x4c(%rbx)
jne 0x282ba2
cmpq $0x... | /IR/LLVMContextImpl.h |
llvm::MDNodeSubsetEqualImpl<llvm::DISubprogram>::isDeclarationOfODRMember(bool, llvm::Metadata const*, llvm::MDString const*, llvm::Metadata const*, llvm::DISubprogram const*) | static bool isDeclarationOfODRMember(bool IsDefinition, const Metadata *Scope,
const MDString *LinkageName,
const Metadata *TemplateParams,
const DISubprogram *RHS) {
// Check whether the LHS is elig... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edi, %ebp
testq %rsi, %rsi
sete %al
orb %bpl, %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
jne 0x282f6d
movq %rsi, %r12
cmpb $0xe, (%rsi)
jne 0x282f6d
movq %r8, %r14
movq %rdx, %r15
movq %r12, %rdi
callq 0x28085e
testq %rax, %rax
je 0x282f6d
mov... | /IR/LLVMContextImpl.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::DILexicalBlockFile*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DILexicalBlockFile>, llvm::detail::DenseSetPair<llvm::DILexicalBlockFile*>>, llvm::DILexicalBlockFile*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DILexicalBlockFile>, llvm::detail::DenseSetPai... | 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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movl 0x10(%rdi), %ebp
testl %ebp, %ebp
je 0x283ad2
movq %rsi, %r14
movq (%rdi), %r12
movq %rsi, %rdi
callq 0x283b10
movl %eax, %r15d
decl %ebp
pushq $0x1
popq %rax
movl %eax, 0xc(%rsp)
movq $0x0, 0x10(%rsp)
andl %ebp, %r1... | /llvm/ADT/DenseMap.h |
llvm::DenseMapIterator<llvm::DITemplateTypeParameter*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DITemplateTypeParameter>, llvm::detail::DenseSetPair<llvm::DITemplateTypeParameter*>, false> llvm::DenseMapBase<llvm::DenseMap<llvm::DITemplateTypeParameter*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DI... | iterator find_as(const LookupKeyT &Val) {
BucketT *TheBucket;
if (LookupBucketFor(Val, TheBucket))
return makeIterator(TheBucket,
shouldReverseIterate<KeyT>() ? getBuckets()
: getBucketsEnd(),
*this,... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
callq 0x285150
testb %al, %al
je 0x28513d
movq 0x8(%rsp), %rax
movl 0x10(%rbx), %edx
shlq $0x3, %rdx
addq (%rbx), %rdx
jmp 0x28514a
movl 0x10(%rbx), %eax
shlq $0x3, %rax
addq (%rbx), %rax
movq %rax, %rdx
addq $0x10, %rsp
popq %rbx
retq
| /llvm/ADT/DenseMap.h |
llvm::MDNodeKeyImpl<llvm::DITemplateValueParameter>::isKeyOf(llvm::DITemplateValueParameter const*) const | dwarf::Tag DINode::getTag() const { return (dwarf::Tag)SubclassData16; } | movzwl 0x2(%rsi), %eax
cmpl %eax, (%rdi)
jne 0x2859df
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
movq %rsi, %rdi
callq 0x28533c
cmpq %rax, %r15
jne 0x2859e2
movq 0x10(%r14), %r15
movq %rbx, %rdi
callq 0x24b1b6
cmpq %rax, %r15
jne 0x2859e2
movb 0x1(%rbx), %al
shrb $0x7, %al
cmp... | /IR/DebugInfoMetadata.cpp |
llvm::detail::DenseSetPair<llvm::DITemplateValueParameter*>* llvm::DenseMapBase<llvm::DenseMap<llvm::DITemplateValueParameter*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DITemplateValueParameter>, llvm::detail::DenseSetPair<llvm::DITemplateValueParameter*>>, llvm::DITemplateValueParameter*, llvm::detail::Dens... | 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 0x285c01
notl %eax
addl %esi, %eax
subl 0xc(%rbx), %eax
movl %esi, %ecx
shrl $0x3, %ecx
cmpl %ecx, %eax
jbe 0x285c03
incl 0x8... | /llvm/ADT/DenseMap.h |
std::pair<llvm::DenseMapIterator<llvm::DIExpression*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DIExpression>, llvm::detail::DenseSetPair<llvm::DIExpression*>, false>, bool> llvm::DenseMapBase<llvm::DenseMap<llvm::DIExpression*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DIExpression>, llvm::detail::... | 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 0x2877a8
movl %eax, %ecx
movq (%r13), %rax
testb %cl, %cl
je 0x28776e
xorl %ecx, %ecx
jmp 0x287781
movq %r14,... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::DIGlobalVariableExpression*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DIGlobalVariableExpression>, llvm::detail::DenseSetPair<llvm::DIGlobalVariableExpression*>>, llvm::DIGlobalVariableExpression*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DIGlobalVariableExp... | 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 0x287e72
movl $0x1000, %r13d # imm = 0x1000
leaq 0x8(%rsp), %r12
cmpq %rbx, %r14
je 0x287ef4
movq (%r14), %rax
orq %r13, %rax
cmpq $-0x1000, %rax # imm = 0xF000
je 0x287eee
mov... | /llvm/ADT/DenseMap.h |
llvm::detail::DenseSetPair<llvm::DIMacro*>* llvm::DenseMapBase<llvm::DenseMap<llvm::DIMacro*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DIMacro>, llvm::detail::DenseSetPair<llvm::DIMacro*>>, llvm::DIMacro*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::DIMacro>, llvm::detail::DenseSetPair<llvm::DIMacro*... | 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 0x289321
notl %eax
addl %esi, %eax
subl 0xc(%rbx), %eax
movl %esi, %ecx
shrl $0x3, %ecx
cmpl %ecx, %eax
jbe 0x289323
incl 0x8... | /llvm/ADT/DenseMap.h |
std::pair<llvm::DenseMapIterator<llvm::DIArgList*, llvm::detail::DenseSetEmpty, llvm::DIArgListInfo, llvm::detail::DenseSetPair<llvm::DIArgList*>, false>, bool> llvm::DenseMapBase<llvm::DenseMap<llvm::DIArgList*, llvm::detail::DenseSetEmpty, llvm::DIArgListInfo, llvm::detail::DenseSetPair<llvm::DIArgList*>>, llvm::DIAr... | 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 0x289d24
movl %eax, %ecx
movq (%r13), %rax
testb %cl, %cl
je 0x289cea
xorl %ecx, %ecx
jmp 0x289cfd
movq %r14,... | /llvm/ADT/DenseMap.h |
llvm::Argument::removeAttrs(llvm::AttributeMask const&) | void Argument::removeAttrs(const AttributeMask &AM) {
AttributeList AL = getParent()->getAttributes();
AL = AL.removeParamAttributes(Parent->getContext(), getArgNo(), AM);
getParent()->setAttributes(AL);
} | pushq %rbx
subq $0x10, %rsp
movq %rsi, %rcx
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq 0x70(%rax), %rdx
leaq 0x8(%rsp), %rdi
movq %rdx, (%rdi)
movq 0x8(%rax), %rax
movq (%rax), %rsi
movl 0x20(%rbx), %edx
callq 0x22c522
movq 0x18(%rbx), %rcx
movq %rax, 0x70(%rcx)
addq $0x10, %rsp
popq %rbx
retq
| /IR/Function.cpp |
llvm::Intrinsic::getIntrinsicInfoTableEntries(unsigned int, llvm::SmallVectorImpl<llvm::Intrinsic::IITDescriptor>&) | void Intrinsic::getIntrinsicInfoTableEntries(ID id,
SmallVectorImpl<IITDescriptor> &T){
// Check to see if the intrinsic's type was expressible by the table.
unsigned TableVal = IIT_Table[id-1];
// Decode the TableVal into an array of IITValues.
SmallVector<unsigned... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
decl %edi
leaq 0x28(%rsp), %rax
movq %rax, -0x18(%rax)
andq $0x0, -0x10(%rax)
leaq 0x15325f(%rip), %rcx # 0x3e3840
movl (%rcx,%rdi,4), %ebp
movq $0x8, -0x8(%rax)
testl %ebp, %ebp
js 0x29061f
leaq 0x10(%rsp), %r14
movl %ebp, %r15d... | /IR/Function.cpp |
DecodeIITType(unsigned int&, llvm::ArrayRef<unsigned char>, IIT_Info, llvm::SmallVectorImpl<llvm::Intrinsic::IITDescriptor>&) | static void DecodeIITType(unsigned &NextElt, ArrayRef<unsigned char> Infos,
IIT_Info LastInfo,
SmallVectorImpl<Intrinsic::IITDescriptor> &OutputTable) {
using namespace Intrinsic;
bool IsScalableVector = (LastInfo == IIT_SCALABLE_VEC);
IIT_Info Info = IIT_Info(Infos[N... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rdx, (%rsp)
movq %rsi, %r14
movq %rdi, %r15
cmpl $0x2b, %ecx
sete %sil
pushq $0x2
popq %rbp
leaq 0xf5b02(%rip), %r12 # 0x3861a0
movl %esi, %ecx
movl (%r15), %eax
leal 0x1(%rax), %edx
movl %edx, (%r15)
movzbl (%r14,%rax... | /IR/Function.cpp |
llvm::IntrinsicInst::isAssumeLikeIntrinsic() const | bool isAssumeLikeIntrinsic() const {
switch (getIntrinsicID()) {
default: break;
case Intrinsic::assume:
case Intrinsic::sideeffect:
case Intrinsic::pseudoprobe:
case Intrinsic::dbg_assign:
case Intrinsic::dbg_declare:
case Intrinsic::dbg_value:
case Intrinsic::dbg_label:
case In... | pushq %rax
callq 0x22bcb0
movl %eax, %ecx
movb $0x1, %al
leal -0xb(%rcx), %edx
cmpl $0x3a, %edx
jbe 0x292f16
leal -0x97(%rcx), %edx
cmpl $0x36, %edx
jbe 0x292f28
leal -0x111(%rcx), %edx
cmpl $0x2a, %edx
ja 0x292f0a
movabsq $0x40000000601, %rsi # imm = 0x40000000601
btq %rdx, %rsi
jb 0x292f38
cmpl $0x16c, %ecx ... | /llvm/IR/IntrinsicInst.h |
getMangledTypeStr[abi:cxx11](llvm::Type*, bool&) | static std::string getMangledTypeStr(Type *Ty, bool &HasUnnamedType) {
std::string Result;
if (PointerType *PTyp = dyn_cast<PointerType>(Ty)) {
Result += "p" + utostr(PTyp->getAddressSpace());
} else if (ArrayType *ATyp = dyn_cast<ArrayType>(Ty)) {
Result += "a" + utostr(ATyp->getNumElements()) +
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl 0x8(%rsi), %esi
movzbl %sil, %eax
cmpl $0xf, %eax
setne %cl
testq %r15, %r15
sete %dl
orb %cl, %dl
je... | /IR/Function.cpp |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::GlobalObject const*, llvm::StringRef, llvm::DenseMapInfo<llvm::GlobalObject const*, void>, llvm::detail::DenseMapPair<llvm::GlobalObject const*, llvm::StringRef>>, llvm::GlobalObject const*, llvm::StringRef, llvm::DenseMapInfo<llvm::GlobalObject const*, void>, llvm::detail::... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x294e33
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
imulq $0x18, %r8, %rax
leaq (%rdi,%rax), %r11
movq (%rdi,%rax), %rbx
movb $0x1, %al... | /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::Function const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, llvm::DenseMapInfo<llvm::Function const*, void>, llvm::detail::DenseMapPair<llvm::Function const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x29c9c3
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
imulq $0x28, %r8, %rax
leaq (%rdi,%rax), %r11
movq (%rdi,%rax), %rbx
movb $0x1, %al... | /llvm/ADT/DenseMap.h |
llvm::detail::DenseMapPair<llvm::Function const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>* llvm::DenseMapBase<llvm::DenseMap<llvm::Function const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, llvm::DenseMapInfo<llvm::Function const*, void>, llv... | BucketT *InsertIntoBucket(BucketT *TheBucket, KeyArg &&Key,
ValueArgs &&... Values) {
TheBucket = InsertIntoBucketImpl(Key, Key, TheBucket);
TheBucket->getFirst() = std::forward<KeyArg>(Key);
::new (&TheBucket->getSecond()) ValueT(std::forward<ValueArgs>(Values)...);
return ... | pushq %rbx
movq %rdx, %rbx
movq %rsi, %rcx
movq %rdx, %rsi
callq 0x29ca80
movq (%rbx), %rcx
movq %rcx, (%rax)
leaq 0x18(%rax), %rcx
movq %rcx, 0x8(%rax)
andq $0x0, 0x10(%rax)
movb $0x0, 0x18(%rax)
popq %rbx
retq
| /llvm/ADT/DenseMap.h |
llvm::DataLayout::getPrivateGlobalPrefix() const | StringRef getPrivateGlobalPrefix() const {
switch (ManglingMode) {
case MM_None:
return "";
case MM_ELF:
case MM_WinCOFF:
return ".L";
case MM_GOFF:
return "L#";
case MM_Mips:
return "$";
case MM_MachO:
case MM_WinCOFFX86:
return "L";
case MM_XCOFF:
... | movslq 0x1c(%rdi), %rax
leaq 0x15f41f(%rip), %rcx # 0x3fd638
movq (%rcx,%rax,8), %rdx
leaq 0x15f454(%rip), %rcx # 0x3fd678
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
retq
| /llvm/IR/DataLayout.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::GlobalValue const*, unsigned int, llvm::DenseMapInfo<llvm::GlobalValue const*, void>, llvm::detail::DenseMapPair<llvm::GlobalValue const*, unsigned int>>, llvm::GlobalValue const*, unsigned int, llvm::DenseMapInfo<llvm::GlobalValue const*, void>, llvm::detail::DenseMapPair<l... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x29e324
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 |
canonicalizeMetadataForValue(llvm::LLVMContext&, llvm::Metadata*) | static Metadata *canonicalizeMetadataForValue(LLVMContext &Context,
Metadata *MD) {
if (!MD)
// !{}
return MDNode::get(Context, std::nullopt);
// Return early if this isn't a single-operand MDNode.
auto *N = dyn_cast<MDNode>(MD);
if (!N || N->getNumOperands... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x29e603
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x23c30e
testq %rax, %rax
je 0x29e5fa
movq %rax, %r15
movq -0x10(%rax), %rax
testb $0x2, %al
jne 0x29e5c4
shrl $0x6, %eax
andl $0xf, %eax
jmp 0x29e5c8
movl -0x18(%r15), %eax
cmpl $0x1, %eax
jne 0x29e5fa
a... | /IR/Metadata.cpp |
llvm::ReplaceableMetadataImpl::SalvageDebugInfo(llvm::Constant const&) | bool isUsedByMetadata() const { return IsUsedByMD; } | testb $0x8, 0x7(%rdi)
je 0x29ee59
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq (%rax), %rax
movl $0x1f8, %edi # imm = 0x1F8
addq (%rax), %rdi
movq %rbx, %rsi
callq 0x29ee5a
movq 0x8(%rax), %r14
addq $0x18, %r14
movq %r14, %rdi
ca... | /llvm/IR/Value.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.