name string | code string | asm string | file string |
|---|---|---|---|
llvm::Instruction::~Instruction() | Instruction::~Instruction() {
assert(!getParent() && "Instruction still linked in the program!");
// Replace any extant metadata uses of this instruction with undef to
// preserve debug info accuracy. Some alternatives include:
// - Treat Instruction like any other Value, and point its extant metadata
// u... | pushq %rbx
movq %rdi, %rbx
testb $0x8, 0x7(%rdi)
je 0x25b1f4
movq 0x8(%rbx), %rdi
callq 0x225a64
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2648ae
movq %rbx, %rdi
movl $0x26, %esi
xorl %edx, %edx
callq 0x26701a
movq 0x30(%rbx), %rsi
testq %rsi, %rsi
je 0x25b215
leaq 0x30(%rbx), %rdi
callq 0x263ab8
movq %rbx, %rdi
popq %rb... | /IR/Instruction.cpp |
llvm::Instruction::copyMetadata(llvm::Instruction const&, llvm::ArrayRef<unsigned int>) | void Instruction::copyMetadata(const Instruction &SrcInst,
ArrayRef<unsigned> WL) {
if (!SrcInst.hasMetadata())
return;
SmallDenseSet<unsigned, 4> WLS(WL.begin(), WL.end());
// Otherwise, enumerate and copy over metadata from the old instruction to the
// new one.
SmallVec... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r15
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x30(%rsi)
jne 0x25bc46
movl $0x20000000, %eax # imm = 0x20000000
andl 0x4(%r14), %eax
je 0x25bd7c
leaq 0x38(%rsp), %rsi
movq %rdx, (%rsi)
leaq (%rdx,%r15,4), %rax
leaq 0x1... | /IR/Instruction.cpp |
llvm::CallBrInst::setIndirectDest(unsigned int, llvm::BasicBlock*) | unsigned getNumIndirectDests() const { return NumIndirectDests; } | movl 0x58(%rdi), %eax
shlq $0x5, %rax
subq %rax, %rdi
movl %esi, %eax
shlq $0x5, %rax
addq %rdi, %rax
addq $-0x20, %rax
cmpq $0x0, (%rax)
je 0x25bf77
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rsi
movq %rcx, (%rsi)
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0x25bf77
movq 0x10(%rax), %rsi
movq %rsi, 0x10(%rcx)
movq %rdx, (%ra... | /llvm/IR/Instructions.h |
llvm::CallBase::hasClobberingOperandBundles() const | bool CallBase::hasClobberingOperandBundles() const {
return hasOperandBundlesOtherThan(
{LLVMContext::OB_deopt, LLVMContext::OB_funclet,
LLVMContext::OB_ptrauth, LLVMContext::OB_kcfi}) &&
getIntrinsicID() != Intrinsic::assume;
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movaps 0x18dd07(%rip), %xmm0 # 0x3ea640
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movl $0x4, %edx
callq 0x25cc7e
testb %al, %al
je 0x25c97e
movq -0x20(%rbx), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x25c95f
cmpb $0x0, (%rcx)
cmoveq %rcx, %rax
testq %rax, %rax
je 0x25c96e
movq 0... | /IR/Instructions.cpp |
llvm::CallBase::populateBundleOperandInfos(llvm::ArrayRef<llvm::OperandBundleDefT<llvm::Value*>>, unsigned int) | CallBase::op_iterator
CallBase::populateBundleOperandInfos(ArrayRef<OperandBundleDef> Bundles,
const unsigned BeginIndex) {
auto It = op_begin() + BeginIndex;
for (auto &B : Bundles)
It = std::copy(B.input_begin(), B.input_end(), It);
auto *ContextImpl = getContext().pImp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
movl 0x4(%rdi), %eax
shll $0x5, %eax
movq %rdi, %rcx
subq %rax, %rcx
movl %ebp, %r14d
shlq $0x5, %r14
addq %rcx, %r14
testq %rdx, %rdx
je 0x25ca0d
imulq $0x38, %rdx, %r12
xorl %r13d, %r13d
movq 0... | /IR/Instructions.cpp |
llvm::CallBase::onlyWritesMemory() const | bool CallBase::onlyWritesMemory() const {
return getMemoryEffects().onlyWritesMemory();
} | pushq %rax
callq 0x25cd28
xorl %ecx, %ecx
xorl %edx, %edx
movl %eax, %esi
shrl %cl, %esi
orb %sil, %dl
addq $0x2, %rcx
cmpq $0x6, %rcx
jne 0x25cdd6
testb $0x1, %dl
sete %al
popq %rcx
retq
nop
| /IR/Instructions.cpp |
llvm::BranchInst::BranchInst(llvm::BasicBlock*, llvm::InsertPosition) | BranchInst::BranchInst(BasicBlock *IfTrue, InsertPosition InsertBefore)
: Instruction(Type::getVoidTy(IfTrue->getContext()), Instruction::Br,
OperandTraits<BranchInst>::op_end(this) - 1, 1,
InsertBefore) {
assert(IfTrue && "Branch destination may not be null!");
Op<-1>() = If... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x221f78
movq %rax, %rdi
callq 0x26f6e2
leaq -0x20(%r14), %r15
movq %r13, 0x10(%rsp)
movq %r12, 0x18(%rsp)
movups 0x10(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r14... | /IR/Instructions.cpp |
llvm::InsertElementInst::InsertElementInst(llvm::Value*, llvm::Value*, llvm::Value*, llvm::Twine const&, llvm::InsertPosition) | InsertElementInst::InsertElementInst(Value *Vec, Value *Elt, Value *Index,
const Twine &Name,
InsertPosition InsertBef)
: Instruction(Vec->getType(), InsertElement,
OperandTraits<InsertElementInst>::op_begin(this), 3,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
movq 0x8(%rsi), %rsi
leaq -0x60(%rdi), %rbp
movaps 0x50(%rsp), %xmm0
movups %xmm0, (%rsp)
movl $0x3e, %edx
movq %rbp, %rcx
movl $0x3, %r8d
callq 0x25b158
cmpq... | /IR/Instructions.cpp |
int& llvm::SmallVectorImpl<int>::emplace_back<int&>(int&) | reference emplace_back(ArgTypes &&... Args) {
if (LLVM_UNLIKELY(this->size() >= this->capacity()))
return this->growAndEmplaceBack(std::forward<ArgTypes>(Args)...);
::new ((void *)this->end()) T(std::forward<ArgTypes>(Args)...);
this->set_size(this->size() + 1);
return this->back();
} | pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
cmpl 0xc(%rdi), %ecx
jae 0x25e94a
movq (%rbx), %rax
movl (%rsi), %edx
movl %edx, (%rax,%rcx,4)
movl 0x8(%rbx), %ecx
incl %ecx
movl %ecx, 0x8(%rbx)
movl %ecx, %ecx
leaq (%rax,%rcx,4), %rax
addq $-0x4, %rax
popq %rbx
retq
movl (%rsi), %esi
movq %rbx, %rdi
callq 0xada2c
movq... | /llvm/ADT/SmallVector.h |
llvm::CmpInst::getSwappedPredicate(llvm::CmpInst::Predicate) | CmpInst::Predicate CmpInst::getSwappedPredicate(Predicate pred) {
switch (pred) {
default: llvm_unreachable("Unknown cmp predicate!");
case ICMP_EQ: case ICMP_NE:
return pred;
case ICMP_SGT: return ICMP_SLT;
case ICMP_SLT: return ICMP_SGT;
case ICMP_SGE: return ICMP_SLE;
case ICMP_SLE: r... | movslq %edi, %rax
leaq 0x18b01e(%rip), %rcx # 0x3eacc0
movl (%rcx,%rax,4), %eax
retq
| /IR/Instructions.cpp |
llvm::GCRelocateInst::getDerivedPtr() const | Value *GCRelocateInst::getDerivedPtr() const {
auto *Statepoint = getStatepoint();
if (isa<UndefValue>(Statepoint))
return UndefValue::get(Statepoint->getType());
auto *GCInst = cast<GCStatepointInst>(Statepoint);
if (auto Opt = GCInst->getOperandBundle(LLVMContext::OB_gc_live))
return *(Opt->Inputs.be... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
callq 0x260e9e
movq %rax, %rbx
movb (%rax), %al
andb $-0x2, %al
cmpb $0xc, %al
jne 0x260fe8
movq 0x8(%rbx), %rdi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x225a64
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
movl $0x5, %edx
callq 0x25cbd2
mo... | /IR/IntrinsicInst.cpp |
llvm::LLVMContext::getMDKindID(llvm::StringRef) const | unsigned LLVMContext::getMDKindID(StringRef Name) const {
// If this is new, assign it its ID.
return pImpl->CustomMDKindNames.insert(
std::make_pair(
Name, pImpl->CustomMDKindNames.size()))
.first->second;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq (%rdi), %r15
movl 0xa94(%r15), %eax
addq $0xa88, %r15 # imm = 0xA88
leaq 0x10(%rsp), %r12
movq %rsi, -0x10(%r12)
movq %rdx, -0x8(%r12)
movl %eax, (%r12)
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xa75aa
movq %r15, %... | /IR/LLVMContext.cpp |
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 *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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rax
movq %rdx, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
movl 0x10(%rdi), %esi
leal 0x4(,%rcx,4), %edx
leal (%rsi,%rsi,2), %edi
cmpl %edi, %edx
jae 0x261a7b
notl %ecx
addl %esi, %ecx
subl 0xc(%rbx), %ecx
movl %esi, %edx
shrl $0x3, %edx
cmpl %edx, %ecx
jbe 0x... | /llvm/ADT/DenseMap.h |
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>>>>::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, %rbx
movl 0x10(%rdi), %r15d
decl %esi
movl %esi, %eax
shrl %eax
orl %esi, %eax
movl %eax, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x4, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x8, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x10, %eax
orl %ecx, %eax
incl %ea... | /llvm/ADT/DenseMap.h |
llvm::hash_code llvm::hashing::detail::hash_combine_range_impl<llvm::MDOperand const*>(llvm::MDOperand const*, llvm::MDOperand const*) | hash_code hash_combine_range_impl(InputIteratorT first, InputIteratorT last) {
const uint64_t seed = get_execution_seed();
char buffer[64], *buffer_ptr = buffer;
char *const buffer_end = std::end(buffer);
while (first != last && store_and_advance(buffer_ptr, buffer_end,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rsi, %rdi
sete %al
movq %rsp, %rsi
je 0x2620b3
xorl %edx, %edx
movq %rdx, %rcx
cmpq $0x38, %rdx
jg 0x262094
leaq 0x8(%rdx), %rcx
movq (%r14), %rdi
movq %rdi, (%rsi)
cmpq $0x38, %rdx
jg 0x2620af
addq ... | /llvm/ADT/Hashing.h |
getNameWithPrefixImpl(llvm::raw_ostream&, llvm::Twine const&, (anonymous namespace)::ManglerPrefixTy, llvm::DataLayout const&, char) | static void getNameWithPrefixImpl(raw_ostream &OS, const Twine &GVName,
ManglerPrefixTy PrefixTy,
const DataLayout &DL, char Prefix) {
SmallString<256> TmpData;
StringRef Name = GVName.toStringRef(TmpData);
assert(!Name.empty() && "getNameWithPre... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movl %r8d, %r12d
movq %rcx, %r13
movl %edx, %ebp
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x18(%rsp), %rcx
movq %rcx, -0x18(%rcx)
movq $0x0, -0x10(%rcx)
movq $0x100, -0x8(%rcx) # imm = 0x100
movq %rsp, %rsi
mov... | /IR/Mangler.cpp |
llvm::DebugValueUser::handleChangedValue(void*, llvm::Metadata*) | void DebugValueUser::handleChangedValue(void *Old, Metadata *New) {
// NOTE: We could inform the "owner" that a value has changed through
// getOwner, if needed.
auto OldMD = static_cast<Metadata **>(Old);
ptrdiff_t Idx = std::distance(&*DebugValues.begin(), OldMD);
// If replacing a ValueAsMetadata with a nu... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x263825
testq %rdx, %rdx
jne 0x263825
movq (%rbx), %rax
movb (%rax), %cl
decb %cl
cmpb $0x1, %cl
ja 0x263825
movq 0x80(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x2261d8
movq %rax, %rdi
callq 0x26383e
movq %rax, %rdx
subq %r14, %rbx
sarq... | /IR/Metadata.cpp |
llvm::ReplaceableMetadataImpl::getOrCreate(llvm::Metadata&) | ReplaceableMetadataImpl *ReplaceableMetadataImpl::getOrCreate(Metadata &MD) {
if (auto *N = dyn_cast<MDNode>(&MD)) {
return !N->isResolved() || N->isAlwaysReplaceable()
? N->Context.getOrCreateReplaceableUses()
: nullptr;
}
if (auto ArgList = dyn_cast<DIArgList>(&MD))
return ... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1d5652
movl %eax, %ebp
xorl %edi, %edi
testb %bpl, %bpl
cmovneq %rbx, %rdi
je 0x263a75
movb 0x1(%rdi), %al
andb $0x7f, %al
cmpb $0x2, %al
je 0x263a6c
cmpl $0x0, -0x8(%rdi)
jne 0x263a6c
cmpb $0x1e, (%rdi)
jne 0x263ab3
addq $0x8, %rdi
callq 0x264784
testb %bpl, %bp... | /IR/Metadata.cpp |
llvm::ReplaceableMetadataImpl::moveRef(void*, void*, llvm::Metadata const&) | void ReplaceableMetadataImpl::moveRef(void *Ref, void *New,
const Metadata &MD) {
auto I = UseMap.find(Ref);
assert(I != UseMap.end() && "Expected to move a reference");
auto OwnerAndIndex = I->second;
UseMap.erase(I);
bool WasInserted = UseMap.insert(std::make_pair(New, ... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x10(%rdi), %r15
movq %r15, %rdi
callq 0x263e9e
movups 0x8(%rax), %xmm0
movaps %xmm0, (%rsp)
movq $-0x2000, (%rax) # imm = 0xE000
addl $-0x2, 0x10(%r14)
incl 0x14(%r14)
leaq 0x18(%rsp), %rcx
movq %rbx, -0x8(%rcx)
movaps (%rsp)... | /IR/Metadata.cpp |
llvm::SmallVectorTemplateBase<std::pair<llvm::PointerUnion<llvm::MetadataAsValue*, llvm::Metadata*, llvm::DebugValueUser*>, unsigned long>*, true>::push_back(std::pair<llvm::PointerUnion<llvm::MetadataAsValue*, llvm::Metadata*, llvm::DebugValueUser*>, unsigned long>*) | 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 0x263c2f
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 0xa6f56
jm... | /llvm/ADT/SmallVector.h |
llvm::ReplaceableMetadataImpl::getAllDbgVariableRecordUsers() | SmallVector<DbgVariableRecord *>
ReplaceableMetadataImpl::getAllDbgVariableRecordUsers() {
SmallVector<std::pair<OwnerTy, uint64_t> *> DVRUsersWithID;
for (auto Pair : UseMap) {
OwnerTy Owner = Pair.second.first;
if (Owner.isNull())
continue;
if (!Owner.is<DebugValueUser *>())
continue;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x28(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x600000000, %rcx # imm = 0x600000000
movq %rcx, -0x8(%rax)
movl 0x10(%rsi), %eax
cmpl $0x1, %eax
ja 0x263c9b
leaq 0x18(%r14), %rcx
testl %eax, %e... | /IR/Metadata.cpp |
llvm::Value::getMetadata(unsigned int, llvm::SmallVectorImpl<llvm::MDNode*>&) const | bool hasMetadata() const { return (bool)HasMetadata; } | testb $0x20, 0x7(%rdi)
jne 0x266d2b
retq
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x274dd0
movl $0xaa0, %edi # imm = 0xAA0
addq (%rax), %rdi
movq %r14, %rsi
callq 0x26af7a
leaq 0x8(%rax), %rdi
movl %ebp, %esi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %rbp
jmp 0x26... | /llvm/IR/Value.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::Value const*, llvm::MDAttachments, llvm::DenseMapInfo<llvm::Value const*, void>, llvm::detail::DenseMapPair<llvm::Value const*, llvm::MDAttachments>>, llvm::Value const*, llvm::MDAttachments, llvm::DenseMapInfo<llvm::Value const*, void>, llvm::detail::DenseMapPair<llvm::Value con... | bool erase(const KeyT &Val) {
BucketT *TheBucket;
if (!LookupBucketFor(Val, TheBucket))
return false; // not in map.
TheBucket->getSecond().~ValueT();
TheBucket->getFirst() = getTombstoneKey();
decrementNumEntries();
incrementNumTombstones();
return true;
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
callq 0x26afc4
movl %eax, %ebp
testb %al, %al
je 0x266ed2
movq 0x8(%rsp), %r14
leaq 0x8(%r14), %rdi
callq 0x262010
movq $-0x2000, (%r14) # imm = 0xE000
movq 0x8(%rbx), %xmm0
paddd 0xd8243(%rip), %xmm0 # 0x33f110
movq %xmm0,... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::SmallDenseMap<void*, std::pair<llvm::PointerUnion<llvm::MetadataAsValue*, llvm::Metadata*, llvm::DebugValueUser*>, unsigned long>, 4u, llvm::DenseMapInfo<void*, void>, llvm::detail::DenseMapPair<void*, std::pair<llvm::PointerUnion<llvm::MetadataAsValue*, llvm::Metadata*, llvm::DebugValueUser*>,... | 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 0x267800
movl %eax, %ecx
movq (%r15), %rax
testb %cl, %cl
jne 0x2677f5
movq %r14, %rdi
movq %rbx, %rsi
movq %rbx, %rdx
movq %rax, %rcx
callq 0x2678a0
movq (%rbx), %rcx
movq %rcx, (%rax)
xorps %xm... | /llvm/ADT/DenseMap.h |
llvm::detail::DenseMapPair<void*, std::pair<llvm::PointerUnion<llvm::MetadataAsValue*, llvm::Metadata*, llvm::DebugValueUser*>, unsigned long>>* llvm::DenseMapBase<llvm::SmallDenseMap<void*, std::pair<llvm::PointerUnion<llvm::MetadataAsValue*, llvm::Metadata*, llvm::DebugValueUser*>, unsigned long>, 4u, llvm::DenseMapI... | 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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rax
movq %rdx, %r14
movq %rdi, %rbx
movl (%rdi), %edx
movl %edx, %ecx
shrl %ecx
movl $0x4, %esi
testb $0x1, %dl
jne 0x2678c5
movl 0x10(%rbx), %esi
leal 0x4(,%rcx,4), %edx
leal (%rsi,%rsi,2), %edi
cmpl %edi, %edx
jae 0x2678fc
notl %ecx
addl %esi, %ecx
subl 0x... | /llvm/ADT/DenseMap.h |
llvm::SmallVectorTemplateBase<llvm::MDOperand, false>::moveElementsForGrow(llvm::MDOperand*) | 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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %rbx
movq (%rdi), %rdi
movl 0x8(%rbx), %eax
leaq (%rdi,%rax,8), %rsi
callq 0x2691ac
movl 0x8(%rbx), %r14d
testq %r14, %r14
je 0x2691a3
movq (%rbx), %rbx
shlq $0x3, %r14
addq $-0x8, %rbx
movq (%rbx,%r14), %rsi
testq %rsi, %rsi
je 0x26919d
leaq (%rbx,%r14), %rdi... | /llvm/ADT/SmallVector.h |
std::pair<llvm::DenseMapIterator<llvm::MDTuple*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::MDTuple>, llvm::detail::DenseSetPair<llvm::MDTuple*>, false>, bool> llvm::DenseMapBase<llvm::DenseMap<llvm::MDTuple*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::MDTuple>, llvm::detail::DenseSetPair<llvm::MDTupl... | 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 %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r12
movq %rsi, %rdi
movq %rdx, %rsi
movq %r12, %rdx
callq 0x2692d0
movl %eax, %ecx
movq (%r12), %rax
testb %cl, %cl
je 0x269292
xorl %ecx, %ecx
jmp 0x2692ab
movq %r14, %rdi
movq %r15, %rsi
movq %r15, %rdx
... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::MDTuple*, llvm::detail::DenseSetEmpty, llvm::MDNodeInfo<llvm::MDTuple>, llvm::detail::DenseSetPair<llvm::MDTuple*>>::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 |
bool llvm::MDNodeOpsKey::compareOps<llvm::MDTuple>(llvm::MDTuple const*, unsigned int) const | unsigned getHash() const { return Hash; } | movl 0x20(%rdi), %eax
cmpl 0x4(%rsi), %eax
jne 0x269e72
movl %edx, %ecx
movq %rsi, %rdx
movq 0x8(%rdi), %rsi
testq %rsi, %rsi
je 0x269e75
movq (%rdi), %rdi
jmp 0x23d040
xorl %eax, %eax
retq
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rsi
movq %rax, %rdi
jmp 0x23cfcc
nop
| /IR/LLVMContextImpl.h |
llvm::SmallVectorImpl<llvm::MDAttachments::Attachment>::assignRemote(llvm::SmallVectorImpl<llvm::MDAttachments::Attachment>&&) | void assignRemote(SmallVectorImpl &&RHS) {
this->destroy_range(this->begin(), this->end());
if (!this->isSmall())
free(this->begin());
this->BeginX = RHS.BeginX;
this->Size = RHS.Size;
this->Capacity = RHS.Capacity;
RHS.resetToSmall();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %r15d
testq %r15, %r15
je 0x26b58c
movq (%r14), %r12
addq $-0x8, %r12
shlq $0x4, %r15
movq (%r12,%r15), %rsi
testq %rsi, %rsi
je 0x26b586
leaq (%r12,%r15), %rdi
callq 0x263ab8
addq $-0x10, %r15
jne 0x26b574
movq (%r14... | /llvm/ADT/SmallVector.h |
bool llvm::DenseMapBase<llvm::DenseMap<std::pair<unsigned int, llvm::FunctionType const*>, unsigned int, llvm::DenseMapInfo<std::pair<unsigned int, llvm::FunctionType const*>, void>, llvm::detail::DenseMapPair<std::pair<unsigned int, llvm::FunctionType const*>, unsigned int>>, std::pair<unsigned int, llvm::FunctionType... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x26d06d
pushq %rbp
pushq %r14
pushq %rbx
movq (%rdi), %rdi
movl (%rsi), %r8d
movl 0x8(%rsi), %eax
leal (%r8,%r8,8), %r9d
leal (%r8,%r9,4), %r9d
movl %eax, %r10d
shrl $0x4, %r10d
shrl $0x9, %eax
xorl %r10d, %eax
shlq $0x20, %r9
orq %r9, %rax
movabsq $-0x40a7b892e31b1a47, %r10 #... | /llvm/ADT/DenseMap.h |
llvm::StringMapEntry<llvm::Comdat>* llvm::StringMapEntry<llvm::Comdat>::create<llvm::MallocAllocator, llvm::Comdat>(llvm::StringRef, llvm::MallocAllocator&, llvm::Comdat&&) | static StringMapEntry *create(StringRef key, AllocatorTy &allocator,
InitTy &&...initVals) {
return new (StringMapEntryBase::allocateWithKey(
sizeof(StringMapEntry), alignof(StringMapEntry), key, allocator))
StringMapEntry(key.size(), std::forward<InitTy>(initVals)...... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r12
leaq 0x49(%rsi), %rdi
movl $0x8, %esi
callq 0xa608d
movq %rax, %r15
testq %r14, %r14
je 0x26d39a
leaq 0x48(%r15), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x8b0b0
movb $0x0, 0x48(%r15,%r14)
movq %r14, (%r15)
movq %r... | /llvm/ADT/StringMapEntry.h |
llvm::cl::list<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, llvm::cl::parser<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::list<char [13], llvm::cl::desc, llvm::cl::MiscFlags, llvm::cl::OptionHidden>(char const (&) [13], llvm::cl::desc const&,... | explicit list(const Mods &... Ms)
: Option(ZeroOrMore, 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
movl $0x1, %esi
xorl %edx, %edx
callq 0xa30d0
xorps %xmm0, %xmm0
movups %xmm0, 0xa0(%r14)
movups %xmm0, 0x90(%r14)
movups %xmm0, 0x80(%r14)
movb $0x0, 0xb0(%r14)
leaq 0x274826(%rip), %ra... | /llvm/Support/CommandLine.h |
llvm::cl::list<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, llvm::cl::parser<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>::list<char [19], llvm::cl::value_desc, llvm::cl::desc, llvm::cl::MiscFlags, llvm::cl::OptionHidden>(char const (&) [19], ... | explicit list(const Mods &... Ms)
: Option(ZeroOrMore, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
movl $0x1, %esi
xorl %edx, %edx
callq 0xa30d0
xorps %xmm0, %xmm0
movups %xmm0, 0xa0(%r14)
movups %xmm0, 0x90(%r14)
movups %xmm0, 0x80(%r14)
movb $0x0... | /llvm/Support/CommandLine.h |
llvm::Type::getFltSemantics() const | TypeID getTypeID() const { return ID; } | movzbl 0x8(%rdi), %eax
leaq 0x17c909(%rip), %rcx # 0x3ec220
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0xc24b4
jmp 0xc24e4
jmp 0xc24c4
jmp 0xc24cc
jmp 0xc24bc
jmp 0xc24d4
jmp 0xc24dc
nop
| /llvm/IR/Type.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::FunctionType*, llvm::detail::DenseSetEmpty, llvm::FunctionTypeKeyInfo, llvm::detail::DenseSetPair<llvm::FunctionType*>>, llvm::FunctionType*, llvm::detail::DenseSetEmpty, llvm::FunctionTypeKeyInfo, llvm::detail::DenseSetPair<llvm::FunctionType*>>::LookupBucketFor<llvm::Funct... | 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 0x2715ce
movq %rsi, %r14
movq (%rdi), %r15
movq %rsi, %rdi
callq 0x2715e8
decl %ebp
andl %ebp, %eax
movl $0x1, %esi
xorl %edx, %edx
movl %eax, %edi
leaq (%r15,%rdi,8), %rdi
movq (%rdi), %r8
cmpq %r8, (%r14)
... | /llvm/ADT/DenseMap.h |
llvm::TargetExtTypeKeyInfo::getHashValue(llvm::TargetExtTypeKeyInfo::KeyTy const&) | static unsigned getHashValue(const KeyTy &Key) {
return hash_combine(
Key.Name,
hash_combine_range(Key.TypeParams.begin(), Key.TypeParams.end()),
hash_combine_range(Key.IntParams.begin(), Key.IntParams.end()));
} | pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq 0x18(%rbx), %rax
leaq (%rdi,%rax,8), %rsi
callq 0x27113c
leaq 0x18(%rsp), %r14
movq %rax, (%r14)
movq 0x20(%rbx), %rdi
movq 0x28(%rbx), %rax
leaq (%rdi,%rax,4), %rsi
callq 0x205d4d
leaq 0x10(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x60(%rsp), ... | /IR/LLVMContextImpl.h |
llvm::User::growHungoffUses(unsigned int, bool) | void User::growHungoffUses(unsigned NewNumUses, bool IsPhi) {
assert(HasHungOffUses && "realloc must have hung off uses");
unsigned OldNumUses = getNumOperands();
// We don't support shrinking the number of uses. We wouldn't have enough
// space to copy the old uses in to the new space.
assert(NewNumUses >... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r15
movl 0x4(%rdi), %eax
movl %eax, %r13d
andl $0x7ffffff, %r13d # imm = 0x7FFFFFF
btl $0x1e, %eax
jb 0x274787
movl %r13d, %eax
shll $0x5, %eax
movq %r15, %rcx
subq %rax, %rcx
movq %rcx, (%rsp)... | /IR/User.cpp |
llvm::Value::deleteValue() | void Value::replaceAllUsesWith(Value *New) {
doRAUW(New, ReplaceMetadataUses::Yes);
} | pushq %rbx
movzbl (%rdi), %eax
addl $-0x16, %eax
leaq 0x1776b0(%rip), %rcx # 0x3ec2a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rdi, %rbx
callq 0x25b1d6
movq %rbx, %rdi
popq %rbx
jmp 0x274974
popq %rbx
jmpq *0x18(%rdi)
movq %rdi, %rbx
callq 0x274d06
jmp 0x274c01
movq %rdi, %rbx
callq 0x274d26
jmp 0... | /IR/Value.cpp |
llvm::ValueHandleBase::ValueIsRAUWd(llvm::Value*, llvm::Value*) | void ValueHandleBase::ValueIsRAUWd(Value *Old, Value *New) {
assert(Old->HasValueHandle &&"Should only be called if ValueHandles present");
assert(Old != New && "Changing value into itself!");
assert(Old->getType() == New->getType() &&
"replaceAllUses of value with new value of different type!");
// G... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
leaq 0x20(%rsp), %rsi
movq %rdi, (%rsi)
movq 0x8(%rdi), %rax
movq (%rax), %rax
movl $0xa70, %edi # imm = 0xA70
addq (%rax), %rdi
callq 0x2768be
movq 0x8(%rax), %r15
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rd... | /IR/Value.cpp |
(anonymous namespace)::Verifier::visitDICompileUnit(llvm::DICompileUnit const&) | void Verifier::visitDICompileUnit(const DICompileUnit &N) {
CheckDI(N.isDistinct(), "compile units must be distinct", &N);
CheckDI(N.getTag() == dwarf::DW_TAG_compile_unit, "invalid tag", &N);
// Don't bother verifying the compilation directory or producer string
// as those could be empty.
CheckDI(N.getRawF... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movb 0x1(%rsi), %al
andb $0x7f, %al
cmpb $0x1, %al
jne 0x282da1
movq %r14, %rdi
callq 0x23775e
cmpw $0x11, %ax
jne 0x282daa
movb (%r14), %al
movq %r14, %rdx
cmpb $0x10, %al
je 0x282e09
leaq -0x10(%r14), %r... | /IR/Verifier.cpp |
(anonymous namespace)::Verifier::visitDISubprogram(llvm::DISubprogram const&) | void Verifier::visitDISubprogram(const DISubprogram &N) {
CheckDI(N.getTag() == dwarf::DW_TAG_subprogram, "invalid tag", &N);
CheckDI(isScope(N.getRawScope()), "invalid scope", &N, N.getRawScope());
if (auto *F = N.getRawFile())
CheckDI(isa<DIFile>(F), "invalid file", &N, F);
else
CheckDI(N.getLine() ==... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x23775e
cmpw $0x2e, %ax
jne 0x283489
leaq -0x10(%r14), %r15
movq -0x10(%r14), %rax
testb $0x2, %al
jne 0x2834b1
leal (%rax,%rax), %edx
andl $0x78, %edx
movq %r15, %rcx
subq %rdx, %rcx
jmp 0x2834b5
leaq 0x16c563(%rip... | /IR/Verifier.cpp |
(anonymous namespace)::Verifier::visitDIAssignID(llvm::DIAssignID const&) | unsigned getNumOperands() const {
if (!IsLarge)
return SmallNumOps;
return getLarge().size();
} | movq -0x10(%rsi), %rax
testb $0x2, %al
jne 0x28439e
shrl $0x6, %eax
andl $0xf, %eax
jmp 0x2843a1
movl -0x18(%rsi), %eax
subq $0x38, %rsp
testl %eax, %eax
je 0x2843b2
leaq 0x16bed9(%rip), %rcx # 0x3f0289
jmp 0x2843c2
movb 0x1(%rsi), %al
andb $0x7f, %al
cmpb $0x1, %al
je 0x2843e0
leaq 0x16bee3(%rip), %rcx # 0x3f02a... | /llvm/IR/Metadata.h |
(anonymous namespace)::Verifier::visitTemplateParams(llvm::MDNode const&, llvm::Metadata const&) | void Verifier::visitTemplateParams(const MDNode &N, const Metadata &RawParams) {
auto *Params = dyn_cast<MDTuple>(&RawParams);
CheckDI(Params, "invalid template params", &N, &RawParams);
for (Metadata *Op : Params->operands()) {
CheckDI(Op && isa<DITemplateParameter>(Op), "invalid template parameter",
... | subq $0x48, %rsp
xorl %r8d, %r8d
cmpb $0x5, (%rdx)
cmoveq %rdx, %r8
movq %r8, 0x18(%rsp)
jne 0x284d87
movq -0x10(%r8), %rax
testb $0x2, %al
jne 0x284db9
addq $-0x10, %r8
leal (%rax,%rax), %ecx
andl $0x78, %ecx
subq %rcx, %r8
shrl $0x6, %eax
andl $0xf, %eax
movq %r8, %rcx
jmp 0x284dc1
leaq 0x16afcf(%rip), %rcx # 0x3e... | /IR/Verifier.cpp |
(anonymous namespace)::Verifier::visitDbgLabelIntrinsic(llvm::StringRef, llvm::DbgLabelInst&) | void Verifier::visitDbgLabelIntrinsic(StringRef Kind, DbgLabelInst &DLI) {
CheckDI(isa<DILabel>(DLI.getRawLabel()),
"invalid llvm.dbg." + Kind + " intrinsic variable", &DLI,
DLI.getRawLabel());
// Ignore broken !dbg attachments; they're checked elsewhere.
if (MDNode *N = DLI.getDebugLoc().get... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl 0x4(%rcx), %eax
shll $0x5, %eax
subq %rax, %rcx
movq (%rcx), %rcx
movq 0x18(%rcx), %rax
cmpb $0x1b, (%rax)
jne 0x292590
movq 0x30(%r14), %rcx
testq %rcx, %rcx
je 0x2925... | /IR/Verifier.cpp |
llvm::DenseMap<llvm::Function*, std::pair<unsigned int, unsigned int>, llvm::DenseMapInfo<llvm::Function*, void>, llvm::detail::DenseMapPair<llvm::Function*, std::pair<unsigned int, 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), %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 |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::Instruction*, unsigned int, llvm::DenseMapInfo<llvm::Instruction*, void>, llvm::detail::DenseMapPair<llvm::Instruction*, unsigned int>>, llvm::Instruction*, unsigned int, llvm::DenseMapInfo<llvm::Instruction*, void>, llvm::detail::DenseMapPair<llvm::Instruction*, unsigned in... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x2945e1
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, %ebx
shlq $0x4, %rbx
leaq (%rdi,%rbx), %r11
movq (%rdi,%rbx), %rbx
cmpq %rbx, (%rsi)
jne... | /llvm/ADT/DenseMap.h |
void llvm::VerifierSupport::WriteTs<llvm::Instruction*, llvm::InvokeInst*>(llvm::Instruction* const&, llvm::InvokeInst* const&) | void WriteTs(const T1 &V1, const Ts &... Vs) {
Write(V1);
WriteTs(Vs...);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movq (%rsi), %rsi
testq %rsi, %rsi
je 0x294a68
movq %rbx, %rdi
callq 0x27f980
movq (%r14), %rsi
testq %rsi, %rsi
je 0x294a7f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x27f980
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /IR/Verifier.cpp |
llvm::MapVector<llvm::Instruction*, llvm::Instruction*, llvm::DenseMap<llvm::Instruction*, unsigned int, llvm::DenseMapInfo<llvm::Instruction*, void>, llvm::detail::DenseMapPair<llvm::Instruction*, unsigned int>>, llvm::SmallVector<std::pair<llvm::Instruction*, llvm::Instruction*>, 0u>>::find(llvm::Instruction* const&) | iterator find(const KeyT &Key) {
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 0x29684c
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 |
llvm::DenseMapBase<llvm::DenseMap<llvm::BasicBlock*, std::unique_ptr<llvm::DomTreeNodeBase<llvm::BasicBlock>, std::default_delete<llvm::DomTreeNodeBase<llvm::BasicBlock>>>, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, std::unique_ptr<llvm::DomTreeNodeBase<llvm::BasicBlock>,... | unsigned getNumBuckets() const {
return NumBuckets;
} | pushq %r15
pushq %r14
pushq %rbx
movl 0x10(%rdi), %r14d
testq %r14, %r14
je 0x2970ed
movq (%rdi), %rbx
shlq $0x4, %r14
addq $0x8, %rbx
movl $0x1000, %r15d # imm = 0x1000
movq -0x8(%rbx), %rax
orq %r15, %rax
cmpq $-0x1000, %rax # imm = 0xF000
je 0x2970e3
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x2970dc
m... | /llvm/ADT/DenseMap.h |
evaluateICmpRelation(llvm::Constant*, llvm::Constant*) | static ICmpInst::Predicate evaluateICmpRelation(Constant *V1, Constant *V2) {
assert(V1->getType() == V2->getType() &&
"Cannot compare different types of values!");
if (V1 == V2) return ICmpInst::ICMP_EQ;
// The following folds only apply to pointers.
if (!V1->getType()->isPointerTy())
return ICmp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
cmpq %rsi, %rdi
je 0x29c805
movq %rdi, %rsi
movq 0x8(%rdi), %rax
movl $0x2a, %ebp
cmpb $0xf, 0x8(%rax)
jne 0x29c80a
movb (%rsi), %cl
movl $0x3, %edx
movl $0x3, %edi
cmpb $0x5, %cl
je 0x29c7c7
movl $0x2, %edi
cmpb $0x4, %cl
jb 0x29c7c7
sete %al
movzb... | /IR/ConstantFold.cpp |
llvm::DominatorTree::dominates(llvm::Instruction const*, llvm::BasicBlock const*) const | bool DominatorTree::dominates(const Instruction *Def,
const BasicBlock *UseBB) const {
const BasicBlock *DefBB = Def->getParent();
// Any unreachable use is dominated, even if DefBB == UseBB.
if (!isReachableFromEntry(UseBB))
return true;
// Unreachable definitions don't domi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
movq 0x28(%rsi), %r14
leaq 0x18(%rdi), %r13
movq %r13, %rdi
movq %rdx, %rsi
callq 0x28cbd4
movq %rax, %rcx
movl 0x28(%r15), %edx
shlq $0x4, %rdx
addq 0x18(%r15), %rdx
movb $0x1, %al
cmpq %r... | /IR/Dominators.cpp |
unsigned int llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::BasicBlock, false>>::runDFS<false, bool (*)(llvm::BasicBlock*, llvm::BasicBlock*)>(llvm::BasicBlock*, unsigned int, bool (*)(llvm::BasicBlock*, llvm::BasicBlock*), unsigned int, llvm::DenseMap<llvm::BasicBlock*, unsigned int, llvm::DenseMapInf... | unsigned runDFS(NodePtr V, unsigned LastNum, DescendCondition Condition,
unsigned AttachToNum,
const NodeOrderMap *SuccOrder = nullptr) {
assert(V);
SmallVector<std::pair<NodePtr, unsigned>, 64> WorkList = {{V, AttachToNum}};
NodeToInfo[V].Parent = AttachToNum;
while... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x498, %rsp # imm = 0x498
movq %r9, 0x18(%rsp)
movl %r8d, %r14d
movq %rcx, %r15
movl %edx, %ebx
movq %rdi, %r12
leaq 0x30(%rsp), %rbp
movq %rsi, (%rbp)
leaq 0x48(%rsp), %rdx
movq %rsi, -0x10(%rdx)
movl %r8d, -0x8(%rdx)
leaq 0x98(%rsp), %... | /llvm/Support/GenericDomTreeConstruction.h |
llvm::Registry<llvm::GCStrategy>::Add<(anonymous namespace)::StatepointGC>::CtorFn() | static std::unique_ptr<T> CtorFn() { return std::make_unique<V>(); } | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x30, %edi
callq 0x8b140
movq %rax, %r14
movq %rax, %rdi
callq 0x2a7494
leaq 0x23b141(%rip), %rax # 0x4e2d50
movq %rax, (%r14)
movl $0x101, 0x28(%r14) # imm = 0x101
movq %r14, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /llvm/Support/Registry.h |
(anonymous namespace)::AsmParser::addAliasForDirective(llvm::StringRef, llvm::StringRef) | void addAliasForDirective(StringRef Directive, StringRef Alias) override {
DirectiveKindMap[Directive.lower()] = DirectiveKindMap[Alias.lower()];
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x58(%rsp), %r14
movq %rsi, (%r14)
movq %rdx, 0x8(%r14)
leaq 0x48(%rsp), %rsi
movq %rcx, (%rsi)
movq %r8, 0x8(%rsi)
addq $0x370, %rbx # imm = 0x370
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0xa814a
movq (%r15), %rsi
movq 0x8(... | /MC/MCParser/AsmParser.cpp |
(anonymous namespace)::AsmParser::parseDirectiveIfb(llvm::SMLoc, bool) | bool AsmParser::parseDirectiveIfb(SMLoc DirectiveLoc, bool ExpectBlank) {
TheCondStack.push_back(TheCondState);
TheCondState.TheCond = AsmCond::IfCond;
if (TheCondState.Ignore) {
eatToEndOfStatement();
} else {
StringRef Str = parseStringToEndOfStatement();
if (parseEOL())
return true;
... | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq 0x148(%rdi), %rsi
cmpq 0x150(%rdi), %rsi
je 0x2b2335
movq 0x134(%rbx), %rax
movq %rax, (%rsi)
addq $0x8, 0x148(%rbx)
jmp 0x2b2348
leaq 0x134(%rbx), %rdx
leaq 0x140(%rbx), %rdi
callq 0x2ba0e6
movl $0x1, 0x134(%rbx)
movq (%rbx), %rax
cmpb $0x1, 0x139(%... | /MC/MCParser/AsmParser.cpp |
(anonymous namespace)::AsmParser::parseDirectiveIfc(llvm::SMLoc, bool) | bool AsmParser::parseDirectiveIfc(SMLoc DirectiveLoc, bool ExpectEqual) {
TheCondStack.push_back(TheCondState);
TheCondState.TheCond = AsmCond::IfCond;
if (TheCondState.Ignore) {
eatToEndOfStatement();
} else {
StringRef Str1 = parseStringToComma();
if (parseComma())
return true;
String... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq 0x148(%rdi), %rsi
cmpq 0x150(%rdi), %rsi
je 0x2b23dd
movq 0x134(%rbx), %rax
movq %rax, (%rsi)
addq $0x8, 0x148(%rbx)
jmp 0x2b23f0
leaq 0x134(%rbx), %rdx
leaq 0x140(%rbx), %rdi
callq 0x2ba0e6
movl $0x1... | /MC/MCParser/AsmParser.cpp |
(anonymous namespace)::AsmParser::handleMacroEntry(llvm::MCAsmMacro*, llvm::SMLoc) | bool AsmParser::handleMacroEntry(MCAsmMacro *M, SMLoc NameLoc) {
// Arbitrarily limit macro nesting depth (default matches 'as'). We can
// eliminate this, although we should protect against infinite loops.
unsigned MaxNestingDepth = AsmMacroMaxNestingDepth;
if (ActiveMacros.size() == MaxNestingDepth) {
std... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %rdi, %rbx
leaq 0x23fabf(%rip), %rax # 0x4f2930
movl 0x80(%rax), %r12d
movq 0x178(%rdi), %rax
subq 0x170(%rdi), %rax
sarq $0x3, %rax
cmpq %r12, %rax
jne 0x2b2f5e
leaq 0xb0(%rsp), %r14
movq %r14, %rdi
cal... | /MC/MCParser/AsmParser.cpp |
(anonymous namespace)::AsmParser::parseDirectiveAbort(llvm::SMLoc) | bool AsmParser::parseDirectiveAbort(SMLoc DirectiveLoc) {
StringRef Str = parseStringToEndOfStatement();
if (parseEOL())
return true;
if (Str.empty())
return Error(DirectiveLoc, ".abort detected. Assembly stopping");
// FIXME: Actually abort assembly here.
return Error(DirectiveLoc,
"... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
callq *0xc8(%rax)
movq %rax, %r15
movq %rdx, %r12
movq %r14, %rdi
callq 0x2c9472
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x2b3f94
testq %r12, %r12
je 0x2b3f6f
leaq 0x30(%rsp), %rax
movw $0x503, 0x20(... | /MC/MCParser/AsmParser.cpp |
(anonymous namespace)::AsmParser::parseDirectiveEnd(llvm::SMLoc) | bool AsmParser::parseDirectiveEnd(SMLoc DirectiveLoc) {
if (parseEOL())
return true;
while (Lexer.isNot(AsmToken::Eof))
Lexer.Lex();
return false;
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x2c9472
movl %eax, %ebp
testb %al, %al
jne 0x2b8b4e
movq 0x30(%rbx), %rax
cmpl $0x0, (%rax)
je 0x2b8b4e
leaq 0x28(%rbx), %r14
movq %r14, %rdi
callq 0x2b2a76
movq 0x30(%rbx), %rax
cmpl $0x0, (%rax)
jne 0x2b8b3d
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop... | /MC/MCParser/AsmParser.cpp |
(anonymous namespace)::AsmParser::parseDirectiveRealDCB(llvm::StringRef, llvm::fltSemantics const&) | bool AsmParser::parseDirectiveRealDCB(StringRef IDVal, const fltSemantics &Semantics) {
SMLoc NumValuesLoc = Lexer.getLoc();
int64_t NumValues;
if (checkForValidSection() || parseAbsoluteExpression(NumValues))
return true;
if (NumValues < 0) {
Warning(NumValuesLoc, "'" + Twine(IDVal) + "' directive wit... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r15
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
addq $0x28, %rdi
callq 0x2c9222
movq %rax, %r12
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x108(%rax)
movb $0x1, %r14b
testb %al, %al
jne 0x2b93be
movq (%rbx), %rax
movq %rsp... | /MC/MCParser/AsmParser.cpp |
llvm::AsmToken const* llvm::SmallVectorTemplateCommon<llvm::AsmToken, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<llvm::AsmToken, false>>(llvm::SmallVectorTemplateBase<llvm::AsmToken, false>*, llvm::AsmToken const&, unsigned long) | static const T *reserveForParamAndGetAddressImpl(U *This, const T &Elt,
size_t N) {
size_t NewSize = This->size() + N;
if (LLVM_LIKELY(NewSize <= This->capacity()))
return &Elt;
bool ReferencesStorage = false;
int64_t Index = -1;
if (!U::Take... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x8(%rdi), %ecx
movl 0xc(%rdi), %eax
addq %rcx, %rdx
cmpq %rax, %rdx
ja 0x2ba5be
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
movq (%rdi), %rax
leaq (%rcx,%rcx,4), %rcx
cmpq %rbx, %rax
setbe %sil
... | /llvm/ADT/SmallVector.h |
llvm::SmallVectorTemplateBase<llvm::AsmToken, false>::grow(unsigned long) | void SmallVectorTemplateBase<T, TriviallyCopyable>::grow(size_t MinSize) {
size_t NewCapacity;
T *NewElts = mallocForGrow(MinSize, NewCapacity);
moveElementsForGrow(NewElts);
takeAllocationForGrow(NewElts, NewCapacity);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %rsp, %r12
movl $0x28, %ecx
movq %r15, %rsi
movq %r12, %r8
callq 0xa6e10
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2ba67a
movq (%r12), %r12
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x2ba666
callq ... | /llvm/ADT/SmallVector.h |
llvm::APFloat::Storage::Storage<>(llvm::fltSemantics const&) | Storage(const fltSemantics &Semantics, ArgTypes &&... Args) {
if (usesLayout<IEEEFloat>(Semantics)) {
new (&IEEE) IEEEFloat(Semantics, std::forward<ArgTypes>(Args)...);
return;
}
if (usesLayout<DoubleAPFloat>(Semantics)) {
new (&Double) DoubleAPFloat(Semantics, std::forward<Arg... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xc24dc
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
cmpq %rbx, %rax
je 0x2bd164
popq %rbx
popq %r14
jmp 0xc2d26
popq %rbx
popq %r14
jmp 0xc8aaa
| /llvm/ADT/APFloat.h |
(anonymous namespace)::AsmParser::parseCVFileId(long&, llvm::StringRef) | bool AsmParser::parseCVFileId(int64_t &FileNumber, StringRef DirectiveName) {
SMLoc Loc;
return parseTokenLoc(Loc) ||
parseIntToken(FileNumber, "expected integer in '" + DirectiveName +
"' directive") ||
check(FileNumber < 1, Loc, "file number less than one i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq %rsp, %rsi
movq $0x0, (%rsi)
callq 0x2c9458
movb $0x1, %bpl
testb %al, %al
jne 0x2be21d
leaq 0xa8(%rsp), %rax
movw $0x503, 0x20(%rax) # imm = 0x503
leaq 0x13d2cb(%... | /MC/MCParser/AsmParser.cpp |
llvm::MCAsmParser::printPendingErrors() | bool printPendingErrors() {
bool rv = !PendingErrors.empty();
for (auto &Err : PendingErrors) {
printError(Err.Loc, Twine(Err.Msg), Err.Range);
}
PendingErrors.clear();
return rv;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0x10(%rdi), %rbx
movl 0x18(%rdi), %r12d
testq %r12, %r12
je 0x2bf3fa
movq %rdi, %r14
movq 0x10(%rdi), %r13
imulq $0x70, %r12, %rbp
addq %r13, %rbp
movq %rsp, %r15
movq (%r13), %rsi
movw $0x105, 0x20(%rsp) # imm = 0x105
movq 0x8... | /llvm/MC/MCParser/MCAsmParser.h |
llvm::SetVector<llvm::MCSection*, llvm::SmallVector<llvm::MCSection*, 0u>, llvm::DenseSet<llvm::MCSection*, llvm::DenseMapInfo<llvm::MCSection*, void>>, 0u>::insert(llvm::MCSection* const&) | bool insert(const value_type &X) {
if constexpr (canBeSmall())
if (isSmall()) {
if (!llvm::is_contained(vector_, X)) {
vector_.push_back(X);
if (vector_.size() > N)
makeBig();
return true;
}
return false;
}
bool result = set_.insert(... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2bf4a6
movb 0x10(%r15), %bpl
cmpb $0x1, %bpl
jne 0x2bf45b
addq $0x18, %rbx
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x2bf468
movl... | /llvm/ADT/SetVector.h |
(anonymous namespace)::AsmParser::parseBinOpRHS(unsigned int, llvm::MCExpr const*&, llvm::SMLoc&) | bool AsmParser::parseBinOpRHS(unsigned Precedence, const MCExpr *&Res,
SMLoc &EndLoc) {
SMLoc StartLoc = Lexer.getLoc();
while (true) {
MCBinaryExpr::Opcode Kind = MCBinaryExpr::Add;
unsigned TokPrec = getBinOpPrecedence(Lexer.getKind(), Kind);
// If the next token is lowe... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %rbx
movq %rdx, 0x20(%rsp)
movl %esi, %ebp
movq %rdi, %r15
addq $0x28, %rdi
callq 0x2c9222
movq %rax, 0x18(%rsp)
leaq 0x8(%rsp), %r12
leaq 0x28(%rsp), %r13
movl %eax, 0x4(%rsp)
movl %ebp, 0xc(%rsp)
movq %rbx, 0x10(%rsp)
movl $... | /MC/MCParser/AsmParser.cpp |
bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::COFFAsmParser, &(anonymous namespace)::COFFAsmParser::ParseDirectivePopSection(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc) | static bool HandleDirective(MCAsmParserExtension *Target,
StringRef Directive,
SMLoc DirectiveLoc) {
T *Obj = static_cast<T*>(Target);
return (Obj->*Handler)(Directive, DirectiveLoc);
} | pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, %rdi
callq 0x2e2782
testb %al, %al
je 0x2c1814
xorl %eax, %eax
jmp 0x2c1836
leaq 0x13ab6a(%rip), %rax # 0x3fc385
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movw $0x103, 0x20(%rsi) # imm = 0x103
movq 0x8(%... | /llvm/MC/MCParser/MCAsmParserExtension.h |
bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::COFFAsmParser, &(anonymous namespace)::COFFAsmParser::ParseDirectiveSecRel32(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc) | static bool HandleDirective(MCAsmParserExtension *Target,
StringRef Directive,
SMLoc DirectiveLoc) {
T *Obj = static_cast<T*>(Target);
return (Obj->*Handler)(Directive, DirectiveLoc);
} | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0xc0(%rax)
testb %al, %al
je 0x2c1a46
leaq 0x139226(%rip), %rax # 0x3fac67
jmp 0x2c1adf
movq $0x0, 0x8(%rsp)
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq ... | /llvm/MC/MCParser/MCAsmParserExtension.h |
bool llvm::function_ref<bool ()>::callback_fn<(anonymous namespace)::COFFAsmParser::ParseDirectiveRVA(llvm::StringRef, llvm::SMLoc)::$_0>(long) | static Ret callback_fn(intptr_t callable, Params ...params) {
return (*reinterpret_cast<Callable*>(callable))(
std::forward<Params>(params)...);
} | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq (%rdi), %r14
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
movq 0x8(%r14), %rdi
movq (%rdi), %rax
callq *0xc0(%rax)
testb %al, %al
je 0x2c1f3b
leaq 0x138d4c(%rip), %rax # 0x3fac67
leaq 0x20(%rsp), %rsi
movq %rax, (%rsi)
movw $0x103, 0x20(%rsi) # imm = ... | /llvm/ADT/STLFunctionalExtras.h |
llvm::MCAsmParser::Error(llvm::SMLoc, llvm::Twine const&, llvm::SMRange) | bool MCAsmParser::Error(SMLoc L, const Twine &Msg, SMRange Range) {
MCPendingError PErr;
PErr.Loc = L;
Msg.toVector(PErr.Msg);
PErr.Range = Range;
PendingErrors.push_back(PErr);
// If we threw this parsing error after a lexing error, this should
// supercede the lexing error and so we remove it from the ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
leaq 0x28(%rsp), %r12
movq %r12, -0x18(%r12)
movq $0x0, -0x10(%r12)
movq $0x40, -0x8(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%r12)
movq %rsi, -0x20(%r12)
movq %rdx, %rdi
movq %rax, %rsi
... | /MC/MCParser/MCAsmParser.cpp |
llvm::MCAsmParser::parseEOL(llvm::Twine const&) | bool MCAsmParser::parseEOL(const Twine &Msg) {
if (getTok().getKind() != AsmToken::EndOfStatement)
return Error(getTok().getLoc(), Msg);
Lex();
return false;
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x8(%rax), %rax
movl (%rax), %ebp
movq (%r14), %rax
cmpl $0x9, %ebp
je 0x2c95c2
movq %r14, %rdi
callq *0x28(%rax)
movq 0x8(%rax), %rdi
callq 0x2c9228
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
... | /MC/MCParser/MCAsmParser.cpp |
llvm::MCAsmParser::parseMany(llvm::function_ref<bool ()>, bool) | bool MCAsmParser::parseMany(function_ref<bool()> parseOne, bool hasComma) {
if (parseOptionalToken(AsmToken::EndOfStatement))
return false;
while (true) {
if (parseOne())
return true;
if (parseOptionalToken(AsmToken::EndOfStatement))
return false;
if (hasComma && parseToken(AsmToken::Com... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x9, %esi
callq 0x2c9702
testb %al, %al
je 0x2c989b
xorl %ebp, %ebp
jmp 0x2c98f6
movq %r14, %rdi
callq *%r15
movb $0x1, %bpl
testb %al, %al
jne 0x2c98f6
movq %rsp, %r1... | /MC/MCParser/MCAsmParser.cpp |
void llvm::cl::apply<llvm::cl::opt<unsigned int, false, llvm::cl::parser<unsigned int>>, char [28], llvm::cl::initializer<int>, llvm::cl::OptionHidden, llvm::cl::desc>(llvm::cl::opt<unsigned int, false, llvm::cl::parser<unsigned int>>*, char const (&) [28], llvm::cl::initializer<int> const&, llvm::cl::OptionHidden cons... | void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq %rsi, %rdi
callq 0x8b300
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x9d01e
movq (%r15), %rax
movl (%rax), %eax
movl %eax, 0x80(%r13)
movb $0x1, 0x94(%r13)
movl %eax, 0x9... | /llvm/Support/CommandLine.h |
llvm::MCAsmParser::MCPendingError const* llvm::SmallVectorTemplateCommon<llvm::MCAsmParser::MCPendingError, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<llvm::MCAsmParser::MCPendingError, false>>(llvm::SmallVectorTemplateBase<llvm::MCAsmParser::MCPendingError, false>*, llvm::MCAsmParser::MCPend... | static const T *reserveForParamAndGetAddressImpl(U *This, const T &Elt,
size_t N) {
size_t NewSize = This->size() + N;
if (LLVM_LIKELY(NewSize <= This->capacity()))
return &Elt;
bool ReferencesStorage = false;
int64_t Index = -1;
if (!U::Take... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x8(%rdi), %ecx
movl 0xc(%rdi), %eax
addq %rcx, %rdx
cmpq %rax, %rdx
ja 0x2c99c0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
movq (%rdi), %rax
imulq $0x70, %rcx, %rcx
addq %rax, %rcx
cmpq %rbx, %... | /llvm/ADT/SmallVector.h |
bool llvm::MCAsmParserExtension::HandleDirective<(anonymous namespace)::WasmAsmParser, &(anonymous namespace)::WasmAsmParser::parseDirectiveType(llvm::StringRef, llvm::SMLoc)>(llvm::MCAsmParserExtension*, llvm::StringRef, llvm::SMLoc) | static bool HandleDirective(MCAsmParserExtension *Target,
StringRef Directive,
SMLoc DirectiveLoc) {
T *Obj = static_cast<T*>(Target);
return (Obj->*Handler)(Directive, DirectiveLoc);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movq 0x8(%rax), %rdx
cmpl $0x2, (%rdx)
jne 0x2caa33
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq 0x8(%rax), %rdi
movq 0x20(%rbx), %rax
movq 0x8(%rax), %rax
movups 0x8(%rax), %xmm0
leaq 0x8(%rsp... | /llvm/MC/MCParser/MCAsmParserExtension.h |
llvm::AsmLexer::LexDigit() | AsmToken AsmLexer::LexDigit() {
// MASM-flavor binary integer: [01]+[yY] (if DefaultRadix < 16, [bByY])
// MASM-flavor octal integer: [0-7]+[oOqQ]
// MASM-flavor decimal integer: [0-9]+[tT] (if DefaultRadix < 16, [dDtT])
// MASM-flavor hexadecimal integer: [0-9][0-9a-fA-F]*[hH]
if (LexMasmIntegers && isdigit(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0x75(%rsi)
jne 0x2cb9a0
movq 0x98(%r14), %rax
movsbl -0x1(%rax), %ecx
leal -0x30(%rcx), %edx
cmpl $0x9, %edx
ja 0x2cb9a0
leaq 0x98(%r14), %r15
leaq -0x1(%rax), %rdi
movl %ecx, %edx
andb $-0x2, %... | /MC/MCParser/AsmLexer.cpp |
radixName[abi:cxx11](unsigned int) | static std::string radixName(unsigned Radix) {
switch (Radix) {
case 2:
return "binary";
case 8:
return "octal";
case 10:
return "decimal";
case 16:
return "hexadecimal";
default:
return "base-" + std::to_string(Radix);
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %r14d
movq %rdi, %rbx
leal -0x2(%r14), %eax
rorl %eax
cmpl $0x7, %eax
ja 0x2cc5ad
leaq 0x1319f1(%rip), %rcx # 0x3fdf24
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x131e0e(%rip), %rsi # 0... | /MC/MCParser/AsmLexer.cpp |
llvm::MCContext::reset() | void MCContext::reset() {
SrcMgr = nullptr;
InlineSrcMgr.reset();
LocInfos.clear();
DiagHandler = defaultDiagHandler;
// Call the destructors so the fragments are freed
COFFAllocator.DestroyAll();
DXCAllocator.DestroyAll();
ELFAllocator.DestroyAll();
GOFFAllocator.DestroyAll();
MachOAllocator.Destr... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq $0x0, 0x50(%rdi)
addq $0x58, %rdi
xorl %esi, %esi
callq 0x2d3cfa
movq 0x60(%rbx), %rax
cmpq %rax, 0x68(%rbx)
je 0x2cf5e0
movq %rax, 0x68(%rbx)
leaq 0x78(%rbx), %rdi
leaq -0x428(%rip), %rsi # 0x2cf1c3
callq 0x2cfa88
leaq 0x180(%rbx), %rdi
callq 0x2cfb00
leaq 0x1... | /MC/MCContext.cpp |
llvm::SpecificBumpPtrAllocator<llvm::MCSectionSPIRV>::DestroyAll() | void DestroyAll() {
auto DestroyElements = [](char *Begin, char *End) {
assert(Begin == (char *)alignAddr(Begin, Align::Of<T>()));
for (char *Ptr = Begin; Ptr + sizeof(T) <= End; Ptr += sizeof(T))
reinterpret_cast<T *>(Ptr)->~T();
};
for (auto I = Allocator.Slabs.begin(), E = Allocator.... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x18(%rdi), %eax
testq %rax, %rax
je 0x2d03b4
movq 0x10(%rbx), %r15
leaq (%r15,%rax,8), %r12
movl $0x1e, %ebp
movq 0x10(%rbx), %rax
movq %r15, %rcx
subq %rax, %rcx
shrq $0xa, %rcx
andl $0x1ffffff, %ecx # imm = 0x1FF... | /llvm/Support/Allocator.h |
llvm::StringMap<llvm::MCSectionELF*, llvm::MallocAllocator>::clear() | bool empty() const { return NumItems == 0; } | cmpl $0x0, 0xc(%rdi)
je 0x2d086d
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %r14d
testq %r14, %r14
je 0x2d085a
xorl %r15d, %r15d
movq (%rbx), %r12
movq (%r12,%r15,8), %rdi
cmpq $-0x8, %rdi
je 0x2d084a
testq %rdi, %rdi
je 0x2d084a
movq (%rdi), %rsi
addq $0x11, %rsi
movl $0x8, ... | /llvm/ADT/StringMap.h |
llvm::MCContext::createXCOFFSymbolImpl(llvm::StringMapEntry<llvm::MCSymbolTableValue> const*, bool) | MCSymbolXCOFF *MCContext::createXCOFFSymbolImpl(const MCSymbolTableEntry *Name,
bool IsTemporary) {
if (!Name)
return new (nullptr, *this) MCSymbolXCOFF(nullptr, IsTemporary);
StringRef OriginalName = Name->first();
if (OriginalName.starts_with("._Renamed..") |... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
movl %edx, %ebp
movq %rdi, %r12
movabsq $-0xffff000fffff, %r14 # imm = 0xFFFF0000FFF00001
testq %rsi, %rsi
je 0x2d0fcf
movq %rsi, %r13
leaq 0x18(%rsi), %rbx
movq (%rsi), %r15
cmpq $0xb, %r15
jb 0x2d0f01
movabsq... | /MC/MCContext.cpp |
llvm::MCContext::getXCOFFSection(llvm::StringRef, llvm::SectionKind, std::optional<llvm::XCOFF::CsectProperties>, bool, std::optional<llvm::XCOFF::DwarfSectionSubtypeFlags>) | MCSectionXCOFF *MCContext::getXCOFFSection(
StringRef Section, SectionKind Kind,
std::optional<XCOFF::CsectProperties> CsectProp, bool MultiSymbolsAllowed,
std::optional<XCOFF::DwarfSectionSubtypeFlags> DwarfSectionSubtypeFlags) {
bool IsDwarfSec = DwarfSectionSubtypeFlags.has_value();
assert((IsDwarfSe... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movl %r9d, 0x38(%rsp)
movl %r8d, %ebx
movl %ecx, 0x3c(%rsp)
movq %rdi, %rbp
btq $0x20, 0x170(%rsp)
leaq 0x90(%rsp), %rax
jae 0x2d2973
movq %rax, 0x80(%rsp)
testq %rsi, %rsi
je 0x2d2996
addq %rsi, %rdx
leaq 0x80(... | /MC/MCContext.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::MCSection*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::MCSection*, void>, llvm::detail::DenseSetPair<llvm::MCSection*>>, llvm::MCSection*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::MCSection*, void>, llvm::detail::DenseSetPair<llvm::MCSection*>>::clear() | unsigned getNumEntries() const {
return NumEntries;
} | movl 0x8(%rdi), %eax
testl %eax, %eax
jne 0x2d3ee9
cmpl $0x0, 0xc(%rdi)
je 0x2d3fbc
shll $0x2, %eax
movl 0x10(%rdi), %ecx
cmpl %ecx, %eax
setae %al
cmpl $0x41, %ecx
setb %dl
orb %al, %dl
je 0x2d3fbe
testq %rcx, %rcx
je 0x2d3fb4
movq (%rdi), %rax
movabsq $0x1fffffffffffffff, %rdx # imm = 0x1FFFFFFFFFFFFFFF
addq %rdx, %r... | /llvm/ADT/DenseMap.h |
llvm::MCContext::XCOFFSectionKey::operator<(llvm::MCContext::XCOFFSectionKey const&) const | bool operator<(const XCOFFSectionKey &Other) const {
if (IsCsect && Other.IsCsect)
return std::tie(SectionName, MappingClass) <
std::tie(Other.SectionName, Other.MappingClass);
if (IsCsect != Other.IsCsect)
return IsCsect;
return std::tie(SectionName, DwarfSubtypeFlags) ... | subq $0x28, %rsp
movb 0x24(%rdi), %al
cmpb $0x1, %al
jne 0x2d57d8
cmpb $0x1, 0x24(%rsi)
jne 0x2d57d8
leaq 0x20(%rdi), %rcx
leaq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq %rdi, 0x8(%rax)
leaq 0x20(%rsi), %rdx
leaq 0x8(%rsp), %rcx
movq %rdx, (%rcx)
movq %rsi, 0x8(%rcx)
movq %rax, %rdi
movq %rcx, %rsi
callq 0x2d580e
jmp 0x2... | /llvm/MC/MCContext.h |
llvm::MCGenDwarfLabelEntry::Make(llvm::MCSymbol*, llvm::MCStreamer*, llvm::SourceMgr&, llvm::SMLoc&) | bool isTemporary() const { return IsTemporary; } | testb $0x2, 0x8(%rdi)
jne 0x2d6323
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r13
movq 0x8(%rsi), %r14
movq 0x118(%rsi), %rax
leaq 0x6f8(%r14), %rdi
movq 0x8(%rax), %rax
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x30(... | /llvm/MC/MCSymbol.h |
llvm::MCStreamer::emitIntValue(llvm::APInt const&) | void MCStreamer::emitIntValue(const APInt &Value) {
if (Value.getNumWords() == 1) {
emitIntValue(Value.getLimitedValue(), Value.getBitWidth() / 8);
return;
}
const bool IsLittleEndianTarget = Context.getAsmInfo()->isLittleEndian();
const bool ShouldSwap = sys::IsLittleEndianHost != IsLittleEndianTarget... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rsi), %eax
leaq 0x3f(%rax), %rcx
andq $-0x40, %rcx
cmpq $0x40, %rcx
jne 0x2dfd79
movq %r14, %rdi
movq $-0x1, %rsi
callq 0xcc298
movl 0x8(%r14), %edx
shrl $0x3, %edx
movq (%rbx), %rcx
movq 0x208(%rcx), %rcx
movq %rbx, ... | /MC/MCStreamer.cpp |
llvm::MCCFIInstruction::createNegateRAState(llvm::MCSymbol*, llvm::SMLoc) | static MCCFIInstruction createNegateRAState(MCSymbol *L, SMLoc Loc = {}) {
return MCCFIInstruction(OpNegateRAState, L, 0, INT64_C(0), Loc);
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rsi, (%rdi)
movb $0xf, 0x20(%rdi)
movq %rdx, 0x28(%rdi)
addq $0x30, %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
xorl %r15d, %r15d
movq %r15, 0x40(%rbx)
leaq 0x109a62(%rip), %r14 # 0x3eb126
movq %r14, %rsi
movq %r14, %rdx
callq 0x2e2974
leaq 0x48(%rbx), %rdi... | /llvm/MC/MCDwarf.h |
llvm::cl::opt<(anonymous namespace)::DefaultOnOff, false, llvm::cl::parser<(anonymous namespace)::DefaultOnOff>>::handleOccurrence(unsigned int, llvm::StringRef, llvm::StringRef) | bool handleOccurrence(unsigned pos, StringRef ArgName,
StringRef Arg) override {
typename ParserClass::parser_data_type Val =
typename ParserClass::parser_data_type();
if (Parser.parse(*this, ArgName, Arg, Val))
return true; // Parse error!
this->setValue(Val);
this... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r14
movq %rdx, %r15
movl %esi, 0x4(%rsp)
movq %rdi, %rbx
movl $0x0, (%rsp)
movq 0xa0(%rdi), %rax
cmpq $0x0, 0x18(%rax)
cmovneq %r8, %r15
cmovneq %r9, %r14
movl 0xb0(%rdi), %eax
testq %rax, %rax
je 0x2e45cd
movq 0xa8(%rbx), %r... | /llvm/Support/CommandLine.h |
(anonymous namespace)::CodeViewErrorCategory::message[abi:cxx11](int) const | std::string message(int Condition) const override {
switch (static_cast<cv_error_code>(Condition)) {
case cv_error_code::unspecified:
return "An unknown CodeView error has occurred.";
case cv_error_code::insufficient_buffer:
return "The buffer is not large enough to read the requested number of ... | pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
decl %edx
leaq 0x11bbe6(%rip), %rax # 0x40059c
movslq (%rax,%rdx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x11bbfc(%rip), %rsi # 0x4005c2
leaq 0x11bc1c(%rip), %rdx # 0x4005e9
jmp 0x2e4a1d
leaq 0x11bc36(%rip), %rsi # 0x40060c
leaq 0x11bc44(%r... | /DebugInfo/CodeView/CodeViewError.cpp |
(anonymous namespace)::FieldListVisitHelper::FieldListVisitHelper(llvm::codeview::TypeVisitorCallbacks&, llvm::ArrayRef<unsigned char>, llvm::codeview::VisitorDataSource) | FieldListVisitHelper(TypeVisitorCallbacks &Callbacks, ArrayRef<uint8_t> Data,
VisitorDataSource Source)
: Stream(Data, llvm::endianness::little), Reader(Stream),
Deserializer(Reader),
Visitor((Source == VDS_BytesPresent) ? Pipeline : Callbacks) {
if (Source == VDS_BytesP... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %r8d, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1d8bb4(%rip), %rax # 0x4bd738
addq $0x10, %rax
movq %rax, (%rdi)
movl $0x1, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
leaq 0x20(%rdi), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq ... | /DebugInfo/CodeView/CVTypeVisitor.cpp |
llvm::Error llvm::codeview::FieldListDeserializer::visitKnownMemberImpl<llvm::codeview::VirtualBaseClassRecord>(llvm::codeview::CVMemberRecord&, llvm::codeview::VirtualBaseClassRecord&) | Error visitKnownMemberImpl(CVMemberRecord &CVR, RecordType &Record) {
if (auto EC = Mapping.Mapping.visitKnownMember(CVR, Record))
return EC;
uint32_t EndOffset = Mapping.Reader.getOffset();
uint32_t RecordLength = EndOffset - Mapping.StartOffset;
Mapping.Reader.setOffset(Mapping.StartOffset);
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
addq $0x10, %rsi
callq 0x2f3fa4
cmpq $0x0, (%rbx)
jne 0x2e75f4
movq 0x8(%r15), %rsi
movl 0x38(%rsi), %ecx
movl 0x68(%r15), %eax
subl %eax, %ecx
movq %rax, 0x38(%rsi)
addq $0x8, %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x3167be
cmpq $0x0,... | /llvm/DebugInfo/CodeView/TypeDeserializer.h |
llvm::Error llvm::make_error<llvm::codeview::CodeViewError, llvm::codeview::cv_error_code, char const (&) [31]>(llvm::codeview::cv_error_code&&, char const (&) [31]) | Error make_error(ArgTs &&... Args) {
return Error(std::make_unique<ErrT>(std::forward<ArgTs>(Args)...));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl $0x40, %edi
callq 0x8b140
movq %rax, %r14
movl (%r12), %ebp
callq 0x2e4964
movw $0x101, 0x28(%rsp) # imm = 0x101
cmpb $0x0, (%r15)
je 0x2e87d6
movq %r15, 0x8(%rsp)
movb $0x3, %dl
jmp 0x2e87d... | /llvm/Support/Error.h |
llvm::codeview::LazyRandomTypeCollection::visitRange(llvm::codeview::TypeIndex, unsigned int, llvm::codeview::TypeIndex) | void LazyRandomTypeCollection::visitRange(TypeIndex Begin, uint32_t BeginOffset,
TypeIndex End) {
auto RI = Types.at(BeginOffset);
assert(RI != Types.end());
ensureCapacityFor(End);
while (Begin != End) {
LargestTypeIndex = std::max(LargestTypeIndex, Begin);
au... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movl %ecx, %ebx
movl %edx, %ecx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x78(%rdi), %rsi
leaq 0xa8(%rdi), %rdx
movq %rsp, %rdi
xorl %r8d, %r8d
callq 0xfc7f4
movq %r14, %rdi
movl %ebx, %esi
callq 0x2e9368
cmpl %ebx, %ebp
je 0x2e9d16
movq %rsp, %r15
movl 0xc(%r14)... | /DebugInfo/CodeView/LazyRandomTypeCollection.cpp |
(anonymous namespace)::TypeNameComputer::visitTypeBegin(llvm::codeview::CVRecord<llvm::codeview::TypeLeafKind>&, llvm::codeview::TypeIndex) | Error TypeNameComputer::visitTypeBegin(CVType &Record, TypeIndex Index) {
// Reset Name to the empty string. If the visitor sets it, we know it.
Name = "";
CurrentTypeIndex = Index;
return Error::success();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x18(%rsi), %rdi
xorl %r12d, %r12d
movq %r12, 0x20(%rsi)
leaq 0x100dea(%rip), %rdx # 0x3eb126
movq %rdx, %rsi
callq 0x955d6
movl %ebx, 0x10(%r14)
movq %r12, (%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
pop... | /DebugInfo/CodeView/RecordName.cpp |
(anonymous namespace)::TypeNameComputer::visitKnownRecord(llvm::codeview::CVRecord<llvm::codeview::TypeLeafKind>&, llvm::codeview::ArgListRecord&) | Error TypeNameComputer::visitKnownRecord(CVType &CVR, ArgListRecord &Args) {
auto Indices = Args.getIndices();
uint32_t Size = Indices.size();
Name = "(";
for (uint32_t I = 0; I < Size; ++I) {
if (Indices[I] < CurrentTypeIndex)
Name.append(Types.getTypeName(Indices[I]));
else
Name.append("<u... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, 0x40(%rsp)
movq 0x8(%rcx), %rbp
movq 0x10(%rcx), %rbx
subq %rbp, %rbx
leaq 0x18(%rsi), %r15
movq $0x0, 0x20(%rsi)
leaq 0x60ed0(%rip), %rsi # 0x34b701
leaq 0x60eca(%rip), %rdx # 0x34b702
movq %r15, %rdi
... | /DebugInfo/CodeView/RecordName.cpp |
(anonymous namespace)::TypeNameComputer::visitKnownRecord(llvm::codeview::CVRecord<llvm::codeview::TypeLeafKind>&, llvm::codeview::ArrayRecord&) | Error TypeNameComputer::visitKnownRecord(CVType &CVR, ArrayRecord &AT) {
Name = AT.getName();
return Error::success();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rcx), %rax
movq 0x20(%rcx), %rdx
addq %rax, %rdx
xorl %r14d, %r14d
movq %r14, 0x20(%rsi)
leaq 0x18(%rsi), %rdi
movq %rax, %rsi
callq 0x955d6
movq %r14, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
| /DebugInfo/CodeView/RecordName.cpp |
llvm::codeview::SymbolRecordMapping::visitKnownRecord(llvm::codeview::CVRecord<llvm::codeview::SymbolKind>&, llvm::codeview::DataSym&) | Error SymbolRecordMapping::visitKnownRecord(CVSymbol &CVR, DataSym &Data) {
error(IO.mapInteger(Data.Type));
error(IO.mapInteger(Data.DataOffset));
error(IO.mapInteger(Data.Segment));
error(IO.mapStringZ(Data.Name));
return Error::success();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
addq $0x10, %r15
leaq 0x2(%rcx), %rdx
leaq 0x8(%rsp), %rcx
movw $0x101, 0x20(%rcx) # imm = 0x101
movq %r15, %rsi
callq 0x2f5be8
cmpq $0x0, (%rbx)
jne 0x2ecc67
leaq 0x8(%r14), %rdx
leaq 0x8(%rsp), %rcx
movw $0x101, 0x2... | /DebugInfo/CodeView/SymbolRecordMapping.cpp |
llvm::codeview::SymbolRecordMapping::visitKnownRecord(llvm::codeview::CVRecord<llvm::codeview::SymbolKind>&, llvm::codeview::DefRangeSym&) | Error SymbolRecordMapping::visitKnownRecord(CVSymbol &CVR,
DefRangeSym &DefRange) {
error(IO.mapInteger(DefRange.Program));
error(mapLocalVariableAddrRange(IO, DefRange.Range));
error(IO.mapVectorTail(DefRange.Gaps, MapGap()));
return Error::success();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
addq $0x10, %r15
leaq 0x4(%rcx), %rdx
leaq 0x8(%rsp), %rcx
movw $0x101, 0x20(%rcx) # imm = 0x101
movq %r15, %rsi
callq 0x2eb82e
cmpq $0x0, (%rbx)
jne 0x2ed3fe
leaq 0x8(%r14), %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq... | /DebugInfo/CodeView/SymbolRecordMapping.cpp |
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.