name string | code string | asm string | file string |
|---|---|---|---|
(anonymous namespace)::ShrinkWrap::init(llvm::MachineFunction&) | void init(MachineFunction &MF) {
RCI.runOnMachineFunction(MF);
MDT = &getAnalysis<MachineDominatorTreeWrapperPass>().getDomTree();
MPDT = &getAnalysis<MachinePostDominatorTreeWrapperPass>().getPostDomTree();
Save = nullptr;
Restore = nullptr;
MBFI = &getAnalysis<MachineBlockFrequencyInfoWrapperP... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x38, %rdi
movq 0x28(%rsp), %rsi
callq 0x362d7d0
movq (%rsp), %rdi
callq 0x88b270
movq %rax, %rdi
callq 0x88b290
movq (%rsp), %rdi
movq %rax, 0x178(%rdi)
callq 0xd60fd0
movq %rax, %rdi
callq 0xd60ff0
movq (%rsp), ... | /CodeGen/ShrinkWrap.cpp |
llvm::BlockFrequency::operator>>=(unsigned int) | BlockFrequency &operator>>=(const unsigned count) {
// Frequency can never be 0 by design.
assert(Frequency != 0);
// Shift right by count.
Frequency >>= count;
// Saturate to 1 if we are 0.
Frequency |= Frequency == 0;
return *this;
} | movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq -0x8(%rsp), %rax
movl -0xc(%rsp), %ecx
movq (%rax), %rdx
movl %ecx, %ecx
shrq %cl, %rdx
movq %rdx, %rcx
movq %rcx, (%rax)
cmpq $0x0, (%rax)
sete %cl
andb $0x1, %cl
movzbl %cl, %ecx
orq (%rax), %rcx
movq %rcx, (%rax)
retq
nopw %cs:(%rax,%rax)
nop
| /llvm/Support/BlockFrequency.h |
llvm::SplitEditor::overlapIntv(llvm::SlotIndex, llvm::SlotIndex) | void SplitEditor::overlapIntv(SlotIndex Start, SlotIndex End) {
assert(OpenIdx && "openIntv not called before overlapIntv");
const VNInfo *ParentVNI = Edit->getParent().getVNInfoAt(Start);
assert(ParentVNI == Edit->getParent().getVNInfoBefore(End) &&
"Parent changes value in extended range");
assert(LI... | subq $0x68, %rsp
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rax), %rdi
callq 0x36a17b0
movq %rax, %rdi
movq 0x60(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rsi
callq 0xed4790
movq %rax, 0x48(%rsp)
cmpq $0x0, 0x48(%rsp)
je 0x36a382b
m... | /CodeGen/SplitKit.cpp |
llvm::DenseMapIterator<llvm::AllocaInst const*, llvm::MachineFrameInfo::SSPLayoutKind, llvm::DenseMapInfo<llvm::AllocaInst const*, void>, llvm::detail::DenseMapPair<llvm::AllocaInst const*, llvm::MachineFrameInfo::SSPLayoutKind>, false>::AdvancePastEmptyBuckets() | void AdvancePastEmptyBuckets() {
assert(Ptr <= End);
const KeyT Empty = KeyInfoT::getEmptyKey();
const KeyT Tombstone = KeyInfoT::getTombstoneKey();
while (Ptr != End && (KeyInfoT::isEqual(Ptr->getFirst(), Empty) ||
KeyInfoT::isEqual(Ptr->getFirst(), Tombstone)))
++Ptr;
... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0xb8ec60
movq %rax, 0x18(%rsp)
callq 0xb8ec80
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdx
movq (%rdx), %rcx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, 0x7(%rsp)
je 0x36cde88
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x36cc650
... | /llvm/ADT/DenseMap.h |
llvm::TargetInstrInfo::describeLoadedValue(llvm::MachineInstr const&, llvm::Register) const | std::optional<ParamLoadedValue>
TargetInstrInfo::describeLoadedValue(const MachineInstr &MI,
Register Reg) const {
const MachineFunction *MF = MI.getMF();
const TargetRegisterInfo *TRI = MF->getSubtarget().getRegisterInfo();
DIExpression *Expr = DIExpression::get(MF->getFuncti... | subq $0x268, %rsp # imm = 0x268
movq %rdi, 0x38(%rsp)
movq %rdi, 0x40(%rsp)
movl %ecx, 0x264(%rsp)
movq %rsi, 0x258(%rsp)
movq %rdx, 0x250(%rsp)
movq 0x258(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x250(%rsp), %rdi
callq 0x341b2a0
movq %rax, 0x248(%rsp)
movq 0x248(%rsp), %rdi
callq 0x73c170
movq %rax, %rdi
mov... | /CodeGen/TargetInstrInfo.cpp |
llvm::TargetLoweringObjectFileXCOFF::getSectionForConstant(llvm::DataLayout const&, llvm::SectionKind, llvm::Constant const*, llvm::Align&) const | MCSection *TargetLoweringObjectFileXCOFF::getSectionForConstant(
const DataLayout &DL, SectionKind Kind, const Constant *C,
Align &Alignment) const {
// TODO: Enable emiting constant pool to unique sections when we support it.
if (Alignment > Align(16))
report_fatal_error("Alignments greater than 16 not... | subq $0x48, %rsp
movl %edx, 0x3c(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movb (%rax), %al
movb %al, 0x17(%rsp)
leaq 0x16(%rsp), %rdi
movl $0x10, %esi
callq 0x4e37b0
movb 0x17(%rsp), %al
movzbl %al, %edi... | /CodeGen/TargetLoweringObjectFileImpl.cpp |
llvm::WindowScheduler::schedulePhi(int, unsigned int&) | void WindowScheduler::schedulePhi(int Offset, unsigned &II) {
LLVM_DEBUG(dbgs() << "Start scheduling Phis:\n");
for (auto &Phi : MBB->phis()) {
int LateCycle = INT_MAX;
auto *SU = TripleDAG->getSUnit(&Phi);
for (auto &Succ : SU->Succs) {
// Phi doesn't have any Anti successors.
if (Succ.getK... | subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movl %esi, 0xac(%rsp)
movq %rdx, 0xa0(%rsp)
movq 0xb0(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x373789d
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0xe5c260
movq %rax, 0x88(%rsp)
movq %rdx, 0x90(%rsp)
leaq 0x88(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x98(%rsp), %rdi
callq 0x8c... | /CodeGen/WindowScheduler.cpp |
(anonymous namespace)::WinEHPrepareImpl::replaceUseWithLoad(llvm::Value*, llvm::Use&, llvm::AllocaInst*&, llvm::DenseMap<llvm::BasicBlock*, llvm::Value*, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::Value*>>&, llvm::Function&) | void WinEHPrepareImpl::replaceUseWithLoad(
Value *V, Use &U, AllocaInst *&SpillSlot,
DenseMap<BasicBlock *, Value *> &Loads, Function &F) {
// Lazilly create the spill slot.
if (!SpillSlot)
SpillSlot = new AllocaInst(V->getType(), DL->getAllocaAddrSpace(), nullptr,
Twine(V... | subq $0x308, %rsp # imm = 0x308
movq %rdi, 0x300(%rsp)
movq %rsi, 0x2f8(%rsp)
movq %rdx, 0x2f0(%rsp)
movq %rcx, 0x2e8(%rsp)
movq %r8, 0x2e0(%rsp)
movq %r9, 0x2d8(%rsp)
movq 0x300(%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x2e8(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x3745939
movl $0x50, %edi
callq 0x7c6790
movq %rax... | /CodeGen/WinEHPrepare.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::BasicBlock*, llvm::Value*, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::Value*>>, llvm::BasicBlock*, llvm::Value*, llvm::DenseMapInfo<llvm::BasicBlock*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock*, llvm::Value*>>::getMin... | 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 + ... | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x3745fae
movl $0x0, 0x14(%rsp)
jmp 0x3745fce
movl 0x4(%rsp), %eax
shll $0x2, %eax
movl $0x3, %ecx
xorl %edx, %edx
divl %ecx
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x5487c0
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::XRayInstrumentation::replaceRetWithPatchableRet(llvm::MachineFunction&, llvm::TargetInstrInfo const*, (anonymous namespace)::InstrumentationOptions) | void XRayInstrumentation::replaceRetWithPatchableRet(
MachineFunction &MF, const TargetInstrInfo *TII,
InstrumentationOptions op) {
// We look for *all* terminators and returns, then replace those with
// PATCHABLE_RET instructions.
SmallVector<MachineInstr *, 4> Terminators;
for (auto &MBB : MF) {
... | subq $0x158, %rsp # imm = 0x158
movw %cx, %ax
movw %ax, 0x156(%rsp)
movq %rdi, 0x148(%rsp)
movq %rsi, 0x140(%rsp)
movq %rdx, 0x138(%rsp)
leaq 0x108(%rsp), %rdi
callq 0x91be70
movq 0x140(%rsp), %rax
movq %rax, 0x100(%rsp)
movq 0x100(%rsp), %rdi
callq 0x7edfc0
movq %rax, 0xf8(%rsp)
movq 0x100(%rsp), %rdi
callq... | /CodeGen/XRayInstrumentation.cpp |
collectRegDefs(llvm::MachineInstr const&, llvm::SmallSet<llvm::Register, 32u, std::less<llvm::Register>>&, llvm::TargetRegisterInfo const*) | static void collectRegDefs(const MachineInstr &MI, DefinedRegsSet &Regs,
const TargetRegisterInfo *TRI) {
for (const MachineOperand &MO : MI.all_defs()) {
if (MO.getReg() && MO.getReg().isPhysical()) {
Regs.insert(MO.getReg());
for (MCRegAliasIterator AI(MO.getReg(), TRI, tr... | subq $0x118, %rsp # imm = 0x118
movq %rdi, 0x110(%rsp)
movq %rsi, 0x108(%rsp)
movq %rdx, 0x100(%rsp)
movq 0x110(%rsp), %rsi
leaq 0xc8(%rsp), %rdi
callq 0xca6410
leaq 0xc8(%rsp), %rax
movq %rax, 0xf8(%rsp)
movq 0xf8(%rsp), %rsi
leaq 0xb0(%rsp), %rdi
callq 0xca6460
movq 0xf8(%rsp), %rsi
leaq 0x98(%rsp), %rdi
c... | /CodeGen/LiveDebugValues/VarLocBasedImpl.cpp |
(anonymous namespace)::VarLocBasedLDV::process(llvm::MachineInstr&, (anonymous namespace)::VarLocBasedLDV::OpenRangesSet&, (anonymous namespace)::VarLocBasedLDV::VarLocMap&, llvm::SmallVector<(anonymous namespace)::VarLocBasedLDV::TransferDebugPair, 4u>&, std::multimap<llvm::MachineInstr const*, (anonymous namespace)::... | void VarLocBasedLDV::process(MachineInstr &MI, OpenRangesSet &OpenRanges,
VarLocMap &VarLocIDs, TransferMap &Transfers,
InstToEntryLocMap &EntryValTransfers,
RegDefToInstMap &RegSetInstrs) {
if (!MI.isDebugInstr())
LastNonDbgMI... | subq $0x38, %rsp
movq 0x40(%rsp), %rax
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
callq 0x823c40
testb $0x1, %al
jne 0x375192e
movq (%rsp), %rax
movq 0x28(%rsp), %rcx
movq ... | /CodeGen/LiveDebugValues/VarLocBasedImpl.cpp |
(anonymous namespace)::VarLocBasedLDV::VarLoc::BuildDbgValue(llvm::MachineFunction&) const | MachineInstr *BuildDbgValue(MachineFunction &MF) const {
assert(!isEntryBackupLoc() &&
"Tried to produce DBG_VALUE for backup VarLoc");
const DebugLoc &DbgLoc = MI.getDebugLoc();
bool Indirect = MI.isIndirectDebugValue();
const auto &IID = MI.getDesc();
const DILocalVariable *... | subq $0x2c8, %rsp # imm = 0x2C8
movq %rdi, 0x2c0(%rsp)
movq %rsi, 0x2b8(%rsp)
movq 0x2c0(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x30(%rax), %rdi
callq 0x73ff30
movq %rax, %rcx
movq 0x80(%rsp), %rax
movq %rcx, 0x2b0(%rsp)
movq 0x30(%rax), %rdi
callq 0x1fa1d40
movb %al, %cl
movq 0x80(%rsp), %rax
andb $0x1, %cl... | /CodeGen/LiveDebugValues/VarLocBasedImpl.cpp |
llvm::DenseMapIterator<llvm::DebugVariable, llvm::SmallVector<(anonymous namespace)::LocIndex, 2u>, llvm::DenseMapInfo<llvm::DebugVariable, void>, llvm::detail::DenseMapPair<llvm::DebugVariable, llvm::SmallVector<(anonymous namespace)::LocIndex, 2u>>, false>::AdvancePastEmptyBuckets() | void AdvancePastEmptyBuckets() {
assert(Ptr <= End);
const KeyT Empty = KeyInfoT::getEmptyKey();
const KeyT Tombstone = KeyInfoT::getTombstoneKey();
while (Ptr != End && (KeyInfoT::isEqual(Ptr->getFirst(), Empty) ||
KeyInfoT::isEqual(Ptr->getFirst(), Tombstone)))
++Ptr;
... | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x13faed0
leaq 0x10(%rsp), %rdi
callq 0x13fc960
movq 0x8(%rsp), %rdx
movq (%rdx), %rcx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, 0x7(%rsp)
je 0x3754808
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x375312... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::DILocalVariable const*, llvm::SmallSet<llvm::DbgVariableFragmentInfo, 4u, std::less<llvm::DbgVariableFragmentInfo>>, llvm::DenseMapInfo<llvm::DILocalVariable const*, void>, llvm::detail::DenseMapPair<llvm::DILocalVariable const*, llvm::SmallSet<llvm::DbgVariableFragmentInfo, 4u, ... | iterator find(const_arg_type_t<KeyT> Val) {
BucketT *TheBucket;
if (LookupBucketFor(Val, TheBucket))
return makeIterator(TheBucket,
shouldReverseIterate<KeyT>() ? getBuckets()
: getBucketsEnd(),
*thi... | subq $0x48, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
leaq 0x28(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x3760820
testb $0x1, %al
jne 0x375fd2d
jmp 0x375fd8b
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x3760950
testb $0x1, %al
jne 0x375fd42
jmp 0x375fd53
movq 0x... | /llvm/ADT/DenseMap.h |
llvm::DenseMapIterator<llvm::DILocalVariable const*, llvm::SmallSet<llvm::DbgVariableFragmentInfo, 4u, std::less<llvm::DbgVariableFragmentInfo>>, llvm::DenseMapInfo<llvm::DILocalVariable const*, void>, llvm::detail::DenseMapPair<llvm::DILocalVariable const*, llvm::SmallSet<llvm::DbgVariableFragmentInfo, 4u, std::less<l... | void AdvancePastEmptyBuckets() {
assert(Ptr <= End);
const KeyT Empty = KeyInfoT::getEmptyKey();
const KeyT Tombstone = KeyInfoT::getTombstoneKey();
while (Ptr != End && (KeyInfoT::isEqual(Ptr->getFirst(), Empty) ||
KeyInfoT::isEqual(Ptr->getFirst(), Tombstone)))
++Ptr;
... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x3752d10
movq %rax, 0x18(%rsp)
callq 0x3760b70
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdx
movq (%rdx), %rcx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, 0x7(%rsp)
je 0x3760d78
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x37538d... | /llvm/ADT/DenseMap.h |
void llvm::SmallVectorTemplateBase<llvm::DbgVariableFragmentInfo, true>::uninitialized_copy<llvm::DbgVariableFragmentInfo const, llvm::DbgVariableFragmentInfo>(llvm::DbgVariableFragmentInfo const*, llvm::DbgVariableFragmentInfo const*, llvm::DbgVariableFragmentInfo*, std::enable_if<std::is_same<std::remove_const<llvm::... | static void uninitialized_copy(
T1 *I, T1 *E, T2 *Dest,
std::enable_if_t<std::is_same<std::remove_const_t<T1>, T2>::value> * =
nullptr) {
// Use memcpy for PODs iterated by pointers (which includes SmallVector
// iterators): std::uninitialized_copy optimizes to memmove, but we can
// u... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0x3762ce8
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rax
subq %rax, %rdx
sarq $0x4, %rdx
shlq $0x4, %rdx
callq 0x348690
addq $0x... | /llvm/ADT/SmallVector.h |
llvm::SmallDenseMap<unsigned int, llvm::DILocation const*, 8u, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::DILocation const*>>::shrink_and_clear() | void shrink_and_clear() {
unsigned OldSize = this->size();
this->destroyAll();
// Reduce the number of buckets.
unsigned NewNumBuckets = 0;
if (OldSize) {
NewNumBuckets = 1 << (Log2_32_Ceil(OldSize) + 1);
if (NewNumBuckets > InlineBuckets && NewNumBuckets < 64u)
NewNumBuckets = ... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x37a1670
movq 0x10(%rsp), %rdi
movl %eax, 0x1c(%rsp)
callq 0x37a1680
movl $0x0, 0x18(%rsp)
cmpl $0x0, 0x1c(%rsp)
je 0x37a15f6
movl 0x1c(%rsp), %edi
callq 0x91b7e0
movl %eax, %ecx
addl $0x1, %ecx
movl $0x1, %eax
shll %cl, %eax
movl... | /llvm/ADT/DenseMap.h |
llvm::cl::opt<llvm::cl::boolOrDefault, false, llvm::cl::parser<llvm::cl::boolOrDefault>>::opt<char [18], llvm::cl::initializer<llvm::cl::boolOrDefault>, llvm::cl::OptionHidden>(char const (&) [18], llvm::cl::initializer<llvm::cl::boolOrDefault> const&, llvm::cl::OptionHidden const&) | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorl %edx, %edx
movl %edx, %esi
callq 0x3f6a60
movq 0x8(%rsp), %rdi
addq $0x80, %rdi
callq 0x77b9f0
movq 0x8(%rsp), %rsi
leaq 0x5dddd38(%rip), %rax # 0x95b6340
addq $0x10... | /llvm/Support/CommandLine.h |
llvm::CriticalAntiDepBreaker::PrescanInstruction(llvm::MachineInstr&) | void CriticalAntiDepBreaker::PrescanInstruction(MachineInstr &MI) {
// It's not safe to change register allocation for source operands of
// instructions that have special allocation requirements. Also assume all
// registers used in a call must not be changed (ABI).
// FIXME: The issue with predicated instruct... | subq $0x288, %rsp # imm = 0x288
movq %rdi, 0x280(%rsp)
movq %rsi, 0x278(%rsp)
movq 0x280(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x278(%rsp), %rdi
movl $0x1, %esi
callq 0x734350
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x95(%rsp)
jne 0x37f7acf
movq 0x278(%rsp), %rdi
movl $0x1, %esi
callq 0x344c9... | /CodeGen/CriticalAntiDepBreaker.cpp |
llvm::CriticalAntiDepBreaker::ScanInstruction(llvm::MachineInstr&, unsigned int) | void CriticalAntiDepBreaker::ScanInstruction(MachineInstr &MI, unsigned Count) {
// Update liveness.
// Proceeding upwards, registers that are defed but not used in this
// instruction are now dead.
assert(!MI.isKill() && "Attempting to scan a kill instruction");
if (!TII->isPredicated(MI)) {
// Predicat... | subq $0x228, %rsp # imm = 0x228
movq %rdi, 0x220(%rsp)
movq %rsi, 0x218(%rsp)
movl %edx, 0x214(%rsp)
movq 0x220(%rsp), %rax
movq %rax, 0x88(%rsp)
movq 0x18(%rax), %rdi
movq 0x218(%rsp), %rsi
movq (%rdi), %rax
callq *0x340(%rax)
testb $0x1, %al
jne 0x37f87f7
movl $0x0, 0x210(%rsp)
movq 0x218(%rsp), %rdi
callq... | /CodeGen/CriticalAntiDepBreaker.cpp |
llvm::detail::DenseMapPair<llvm::MachineInstr*, llvm::SUnit const*>* llvm::DenseMapBase<llvm::DenseMap<llvm::MachineInstr*, llvm::SUnit const*, llvm::DenseMapInfo<llvm::MachineInstr*, void>, llvm::detail::DenseMapPair<llvm::MachineInstr*, llvm::SUnit const*>>, llvm::MachineInstr*, llvm::SUnit const*, llvm::DenseMapInfo... | 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... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x548460
movq 0x10(%rsp), %rdi
callq 0x37fc210
movq 0x10(%rsp), %rdi
addl $0x1, %eax
movl %eax, 0x24(%rsp)
callq 0x37fbce0
movl %eax, 0x20(%rsp)
movl 0x24(%rsp), %ea... | /llvm/ADT/DenseMap.h |
scalarize(llvm::BinaryOperator*, llvm::SmallVectorImpl<llvm::BinaryOperator*>&) | static void scalarize(BinaryOperator *BO,
SmallVectorImpl<BinaryOperator *> &Replace) {
VectorType *VTy = cast<FixedVectorType>(BO->getType());
IRBuilder<> Builder(BO);
unsigned NumElements = VTy->getElementCount().getFixedValue();
Value *Result = PoisonValue::get(VTy);
for (unsigned I... | subq $0x208, %rsp # imm = 0x208
movq %rdi, 0x200(%rsp)
movq %rsi, 0x1f8(%rsp)
movq 0x200(%rsp), %rdi
callq 0x782840
movq %rax, %rdi
callq 0x78e870
movq %rax, 0x1f0(%rsp)
movq 0x200(%rsp), %rax
movq %rax, 0x58(%rsp)
leaq 0x150(%rsp), %rdi
callq 0x7b2080
movq 0x58(%rsp), %rsi
movq 0x150(%rsp), %rcx
movq 0x158(... | /CodeGen/ExpandLargeDivRem.cpp |
llvm::detail::DenseMapPair<std::pair<int, llvm::VNInfo*>, unsigned int>* llvm::DenseMapBase<llvm::DenseMap<std::pair<int, llvm::VNInfo*>, unsigned int, llvm::DenseMapInfo<std::pair<int, llvm::VNInfo*>, void>, llvm::detail::DenseMapPair<std::pair<int, llvm::VNInfo*>, unsigned int>>, std::pair<int, llvm::VNInfo*>, unsign... | 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... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x548460
movq 0x8(%rsp), %rdi
callq 0x381cbf0
movq 0x8(%rsp), %rdi
addl $0x1, %eax
movl %eax, 0x24(%rsp)
callq 0x3816890
movl %eax, 0x20(%rsp)
movl 0x24(%rsp), %eax
s... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<int, std::unique_ptr<llvm::LiveInterval, std::default_delete<llvm::LiveInterval>>, llvm::DenseMapInfo<int, void>, llvm::detail::DenseMapPair<int, std::unique_ptr<llvm::LiveInterval, std::default_delete<llvm::LiveInterval>>>>::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... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl 0x10(%rax), %ecx
movl %ecx, 0x18(%rsp)
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movl $0x40, 0xc(%rsp)
movl 0x1c(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x5487c0
movl %eax, 0x8(%rsp)
leaq 0x... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::InlineSpiller::hoistSpillInsideBB(llvm::LiveInterval&, llvm::MachineInstr&) | bool InlineSpiller::hoistSpillInsideBB(LiveInterval &SpillLI,
MachineInstr &CopyMI) {
SlotIndex Idx = LIS.getInstructionIndex(CopyMI);
#ifndef NDEBUG
VNInfo *VNI = SpillLI.getVNInfoAt(Idx.getRegSlot());
assert(VNI && VNI->def == Idx.getRegSlot() && "Not defined by copy");
#e... | pushq %rbx
subq $0x210, %rsp # imm = 0x210
movq %rdi, 0x200(%rsp)
movq %rsi, 0x1f8(%rsp)
movq %rdx, 0x1f0(%rsp)
movq 0x200(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x10(%rax), %rdi
movq 0x1f0(%rsp), %rsi
callq 0xb3b410
movq %rax, 0x1e8(%rsp)
movq 0x1f0(%rsp), %rdi
movl $0x1, %esi
callq 0x73fa00
movq %rax, %rdi... | /CodeGen/InlineSpiller.cpp |
llvm::DenseMapIterator<llvm::LiveInterval*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::LiveInterval*, void>, llvm::detail::DenseSetPair<llvm::LiveInterval*>, false>::DenseMapIterator(llvm::detail::DenseSetPair<llvm::LiveInterval*>*, llvm::detail::DenseSetPair<llvm::LiveInterval*>*, llvm::DebugEpochBase const... | DenseMapIterator(pointer Pos, pointer E, const DebugEpochBase &Epoch,
bool NoAdvance = false)
: DebugEpochBase::HandleBase(&Epoch), Ptr(Pos), End(E) {
assert(isHandleInSync() && "invalid construction!");
if (NoAdvance) return;
if (shouldReverseIterate<KeyT>()) {
RetreatPastEm... | subq $0x38, %rsp
movb %r8b, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rsi
callq 0x5481a0
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rcx
m... | /llvm/ADT/DenseMap.h |
llvm::SmallVectorImpl<llvm::MachineInstr const*>::erase(llvm::MachineInstr const* const*, llvm::MachineInstr const* const*) | iterator erase(const_iterator CS, const_iterator CE) {
// Just cast away constness because this is a non-const member function.
iterator S = const_cast<iterator>(CS);
iterator E = const_cast<iterator>(CE);
assert(this->isRangeInStorage(S, E) && "Range to erase is out of bounds.");
iterator N = S;
... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
callq 0x8f6eb0
movq (... | /llvm/ADT/SmallVector.h |
(anonymous namespace)::CheckDebugMachineModule::~CheckDebugMachineModule() | bool runOnModule(Module &M) override {
NamedMDNode *NMD = M.getNamedMetadata("llvm.mir.debugify");
if (!NMD) {
errs() << "WARNING: Please run mir-debugify to generate "
"llvm.mir.debugify metadata first.\n";
return false;
}
MachineModuleInfo &MMI =
getAnalysis<Machin... | pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x312e5b0
popq %rax
retq
| /CodeGen/MachineCheckDebugify.cpp |
llvm::cl::opt<llvm::cl::boolOrDefault, false, llvm::cl::parser<llvm::cl::boolOrDefault>>::opt<char [25], llvm::cl::OptionHidden>(char const (&) [25], llvm::cl::OptionHidden const&) | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
xorl %edx, %edx
movl %edx, %esi
callq 0x3f6a60
movq (%rsp), %rdi
addq $0x80, %rdi
callq 0x77b9f0
movq (%rsp), %rsi
leaq 0x5d29150(%rip), %rax # 0x95b6340
addq $0x10, %rax
movq %rax, (%rsi)
movq %... | /llvm/Support/CommandLine.h |
(anonymous namespace)::AssignmentTrackingLowering::emitPromotedVarLocs(FunctionVarLocsBuilder*) | bool AssignmentTrackingLowering::emitPromotedVarLocs(
FunctionVarLocsBuilder *FnVarLocs) {
bool InsertedAnyIntrinsics = false;
// Go through every block, translating debug intrinsics for fully promoted
// variables into FnVarLocs location defs. No analysis required for these.
auto TranslateDbgRecord = [&](a... | subq $0x158, %rsp # imm = 0x158
movq %rdi, 0x150(%rsp)
movq %rsi, 0x148(%rsp)
movq 0x150(%rsp), %rax
movb $0x0, 0x147(%rsp)
movq %rax, 0x128(%rsp)
leaq 0x148(%rsp), %rcx
movq %rcx, 0x130(%rsp)
leaq 0x147(%rsp), %rcx
movq %rcx, 0x138(%rsp)
movq 0x60(%rax), %rax
movq %rax, 0x120(%rsp)
movq 0x120(%rsp), %rdi
ca... | /CodeGen/AssignmentTrackingAnalysis.cpp |
llvm::SmallVectorImpl<std::pair<llvm::VariableID, llvm::at::AssignmentInfo>>::operator=(llvm::SmallVectorImpl<std::pair<llvm::VariableID, llvm::at::AssignmentInfo>>&&) | SmallVectorImpl<T> &SmallVectorImpl<T>::operator=(SmallVectorImpl<T> &&RHS) {
// Avoid self-assignment.
if (this == &RHS) return *this;
// If the RHS isn't small, clear this vector and then steal its buffer.
if (!RHS.isSmall()) {
this->assignRemote(std::move(RHS));
return *this;
}
// If we already... | subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpq 0x50(%rsp), %rax
jne 0x389915e
movq 0x30(%rsp), %rax
movq %rax, 0x60(%rsp)
jmp 0x3899337
movq 0x50(%rsp), %rdi
callq 0x38993d0
testb $0x1, %al
jne 0x389918a
movq 0x30(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x3... | /llvm/ADT/SmallVector.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::VariableID, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::VariableID, void>, llvm::detail::DenseSetPair<llvm::VariableID>>, llvm::VariableID, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::VariableID, void>, llvm::detail::DenseSetPair<llvm::VariableID>>::moveFromOl... | 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... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x3894610
callq 0x38946d0
movl %eax, 0x3c(%rsp)
callq 0x38a66c0
movl %eax, 0x38(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rs... | /llvm/ADT/DenseMap.h |
llvm::IntervalMap<unsigned int, unsigned int, 16u, llvm::IntervalMapHalfOpenInfo<unsigned int>>::branchRoot(unsigned int) | IntervalMapImpl::IdxPair IntervalMap<KeyT, ValT, N, Traits>::
branchRoot(unsigned Position) {
using namespace IntervalMapImpl;
// How many external leaf nodes to hold RootLeaf+1?
const unsigned Nodes = RootLeaf::Capacity / Leaf::Capacity + 1;
// Compute element distribution among new nodes.
unsigned size[Nod... | subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movl %esi, 0x94(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x2, 0x90(%rsp)
movl $0x0, 0x84(%rsp)
leaq 0xa0(%rsp), %rdi
leaq 0x84(%rsp), %rsi
leaq 0x94(%rsp), %rdx
callq 0x1198cd0
movq 0x28(%rsp), %rax
movl 0xc4(%rax), %esi
leaq 0x88(%rsp), %r8
movl 0x94(%rsp), %r9d
mo... | /llvm/ADT/IntervalMap.h |
void llvm::sort<__gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>>(__gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigned long>>>, __gnu_cxx::__normal_iterator<unsigned long*, std::vector<unsigned long, std::allocator<unsigne... | inline void sort(IteratorTy Start, IteratorTy End) {
if constexpr (detail::sort_trivially_copyable<IteratorTy>::value) {
// Forward trivially copyable types to array_pod_sort. This avoids a large
// amount of code bloat for a minor performance hit.
array_pod_sort(Start, End);
} else {
#ifdef EXPENSIVE_C... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x38e0310
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
| /llvm/ADT/STLExtras.h |
llvm::LTOModule::addDefinedFunctionSymbol(llvm::PointerUnion<llvm::GlobalValue*, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int>*>) | void LTOModule::addDefinedFunctionSymbol(ModuleSymbolTable::Symbol Sym) {
SmallString<64> Buffer;
{
raw_svector_ostream OS(Buffer);
SymTab.printSymbolName(OS, Sym);
Buffer.c_str();
}
const Function *F = cast<Function>(cast<GlobalValue *>(Sym));
addDefinedFunctionSymbol(Buffer, F);
} | subq $0xc8, %rsp
movq %rsi, 0xc0(%rsp)
movq %rdi, 0xb8(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, (%rsp)
leaq 0x60(%rsp), %rdi
callq 0xae6c60
leaq 0x28(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x4e3350
movq (%rsp), %rdi
addq $0x50, %rdi
movq 0xc0(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdx
leaq 0x28(%rsp), %rsi
... | /LTO/LTOModule.cpp |
llvm::remarks::parseHotnessThresholdOption(llvm::StringRef) | inline Expected<std::optional<uint64_t>> parseHotnessThresholdOption(StringRef Arg) {
if (Arg == "auto")
return std::nullopt;
int64_t Val;
if (Arg.getAsInteger(10, Val))
return createStringError(llvm::inconvertibleErrorCode(),
"Not an integer: %s", Arg.data());
// Negative... | subq $0x88, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x70(%rsp)
movq %rdx, 0x78(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x68(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x4b9befb(%rip), %rsi # 0x84a85c1
callq 0x3ee9c0
movq 0x60(%... | /llvm/Remarks/HotnessThresholdParser.h |
llvm::DenseMap<std::pair<llvm::MCSymbol const*, unsigned int>, llvm::MCSymbolRefExpr const*, llvm::DenseMapInfo<std::pair<llvm::MCSymbol const*, unsigned int>, void>, llvm::detail::DenseMapPair<std::pair<llvm::MCSymbol const*, unsigned int>, llvm::MCSymbolRefExpr 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;
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %ecx
movl %ecx, 0x10(%rax)
cmpl $0x0, 0x10(%rax)
jne 0x39223f7
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movb $0x0, 0x27(%rsp)
jmp 0x392241d
movq 0x8(%rsp), %rax
movl 0x10(%rax), %eax
imulq $0x18, %rax,... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<unsigned int, llvm::MCCVFunctionInfo::LineInfo, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::MCCVFunctionInfo::LineInfo>>, unsigned int, llvm::MCCVFunctionInfo::LineInfo, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsign... | void destroyAll() {
if (getNumBuckets() == 0) // Nothing to do.
return;
const KeyT EmptyKey = getEmptyKey(), TombstoneKey = getTombstoneKey();
for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) {
if (!KeyInfoT::isEqual(P->getFirst(), EmptyKey) &&
!KeyInfoT::isEqual(P->... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x39358e0
cmpl $0x0, %eax
jne 0x3935841
jmp 0x39358d5
callq 0x39358f0
movl %eax, 0x1c(%rsp)
callq 0x3935900
movq (%rsp), %rdi
movl %eax, 0x18(%rsp)
callq 0x3935910
movq (%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x3935920
movq %rax, 0x8(... | /llvm/ADT/DenseMap.h |
void llvm::SmallVectorImpl<llvm::CodeViewContext::FileInfo>::resizeImpl<false>(unsigned long) | void resizeImpl(size_type N) {
if (N == this->size())
return;
if (N < this->size()) {
this->truncate(N);
return;
}
this->reserve(N);
for (auto I = this->end(), E = this->begin() + N; I != E; ++I)
if (ForOverwrite)
new (&*I) T;
else
new (&*I) T();
t... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0x3a8dca0
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jne 0x3935ab9
jmp 0x3935b72
movq 0x18(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0... | /llvm/ADT/SmallVector.h |
llvm::StringMap<llvm::MCSymbolTableValue, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul, 128ul>&>::~StringMap() | ~StringMap() {
// Delete all the elements in the map, but don't reset the elements
// to default values. This is a copy of clear(), but avoids unnecessary
// work not required in the destructor.
if (!empty()) {
for (unsigned I = 0, E = NumBuckets; I != E; ++I) {
StringMapEntryBase *Bucket... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x3f5b50
testb $0x1, %al
jne 0x393ac9d
movq 0x18(%rsp), %rax
movl $0x0, 0x2c(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x28(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x28(%rsp), %eax
je 0x393ac9b
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl 0x2... | /llvm/ADT/StringMap.h |
llvm::DenseMapBase<llvm::DenseMap<unsigned int, llvm::MCLabel*, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::MCLabel*>>, unsigned int, llvm::MCLabel*, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::MCLabel*>>::initEmpty() | void initEmpty() {
setNumEntries(0);
setNumTombstones(0);
assert((getNumBuckets() & (getNumBuckets()-1)) == 0 &&
"# initial buckets must be a power of two!");
const KeyT EmptyKey = getEmptyKey();
for (BucketT *B = getBuckets(), *E = getBucketsEnd(); B != E; ++B)
::new (&B->getFirst... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
xorl %esi, %esi
callq 0x3949cc0
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x3949ce0
callq 0x3949d00
movq (%rsp), %rdi
movl %eax, 0x1c(%rsp)
callq 0x3949d10
movq (%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x3949d20
movq %rax, 0x8(%rsp)
movq 0x10(... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<llvm::MCFragment const*, llvm::MCSymbol const*, llvm::DenseMapInfo<llvm::MCFragment const*, void>, llvm::detail::DenseMapPair<llvm::MCFragment const*, llvm::MCSymbol 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;
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %ecx
movl %ecx, 0x10(%rax)
cmpl $0x0, 0x10(%rax)
jne 0x3976fa7
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movb $0x0, 0x27(%rsp)
jmp 0x3976fcf
movq 0x8(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, %edi
sh... | /llvm/ADT/DenseMap.h |
llvm::SmallVectorImpl<char>::resize(unsigned long, char) | void resize(size_type N, ValueParamT NV) {
if (N == this->size())
return;
if (N < this->size()) {
this->truncate(N);
return;
}
// N > this->size(). Defer to append.
this->append(N - this->size(), NV);
} | subq $0x38, %rsp
movb %dl, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movb %al, 0x27(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x3a8dfc0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jne 0x398196c
jmp 0x39819c7
movq 0x10(%rsp), %rdi
movq 0x28(%rsp),... | /llvm/ADT/SmallVector.h |
isARMTerminator(llvm::WinEH::Instruction const&) | static bool isARMTerminator(const WinEH::Instruction &inst) {
switch (static_cast<Win64EH::UnwindOpcodes>(inst.Operation)) {
case Win64EH::UOP_End:
case Win64EH::UOP_EndNop:
case Win64EH::UOP_WideEndNop:
return true;
default:
return false;
}
} | movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x14(%rsp)
subl $0x1b, %eax
je 0x39b6526
jmp 0x39b6518
movl -0x14(%rsp), %eax
addl $-0x3c, %eax
subl $0x1, %eax
ja 0x39b652d
jmp 0x39b6526
movb $0x1, -0x1(%rsp)
jmp 0x39b6532
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
no... | /MC/MCWin64EH.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::MCSection const*, unsigned int, llvm::DenseMapInfo<llvm::MCSection const*, void>, llvm::detail::DenseMapPair<llvm::MCSection const*, unsigned int>>, llvm::MCSection const*, unsigned int, llvm::DenseMapInfo<llvm::MCSection const*, void>, llvm::detail::DenseMapPair<llvm::MCSection ... | void clear() {
incrementEpoch();
if (getNumEntries() == 0 && getNumTombstones() == 0) return;
// If the capacity of the array is huge, and the # elements used is small,
// shrink the array.
if (getNumEntries() * 4 < getNumBuckets() && getNumBuckets() > 64) {
shrink_and_clear();
return;
... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x548460
movq 0x18(%rsp), %rdi
callq 0x39c1c70
cmpl $0x0, %eax
jne 0x39bad7b
movq 0x18(%rsp), %rdi
callq 0x39c1c80
cmpl $0x0, %eax
jne 0x39bad7b
jmp 0x39bae40
movq 0x18(%rsp), %rdi
callq 0x39c1c70
movq 0x18(%rsp), %rdi
shll $0x2, %... | /llvm/ADT/DenseMap.h |
llvm::MachObjectWriter::MachObjectWriter(std::unique_ptr<llvm::MCMachObjectTargetWriter, std::default_delete<llvm::MCMachObjectTargetWriter>>, llvm::raw_pwrite_stream&, bool) | MachObjectWriter(std::unique_ptr<MCMachObjectTargetWriter> MOTW,
raw_pwrite_stream &OS, bool IsLittleEndian)
: TargetObjectWriter(std::move(MOTW)),
StringTable(TargetObjectWriter->is64Bit() ? StringTableBuilder::MachO64
: StringTableBuil... | subq $0x48, %rsp
movq %rsi, 0x8(%rsp)
movb %cl, %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x39643a0
movq 0x8(%rsp), %rsi
movq 0x20(%rsp), %rdi
leaq 0x5d16150(%rip), %rax # 0x96dc650
addq $0x10, %rax
movq ... | /llvm/MC/MCMachObjectWriter.h |
llvm::SPIRVObjectWriter::writeHeader(llvm::MCAssembler const&) | void SPIRVObjectWriter::writeHeader(const MCAssembler &Asm) {
constexpr uint32_t MagicNumber = 0x07230203;
constexpr uint32_t GeneratorID = 43;
constexpr uint32_t GeneratorMagicNumber =
(GeneratorID << 16) | (LLVM_VERSION_MAJOR);
constexpr uint32_t Schema = 0;
W.write<uint32_t>(MagicNumber);
W.write<... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
movl $0x7230203, 0x14(%rsp) # imm = 0x7230203
movl $0x2b, 0x10(%rsp)
movl $0x2b0013, 0xc(%rsp) # imm = 0x2B0013
movl $0x0, 0x8(%rsp)
addq $0x68, %rdi
movl $0x7230203, %esi # imm = 0x7230203
callq 0x2703d60
mo... | /MC/SPIRVObjectWriter.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::CachedHashStringRef, unsigned long, llvm::DenseMapInfo<llvm::CachedHashStringRef, void>, llvm::detail::DenseMapPair<llvm::CachedHashStringRef, unsigned long>>, llvm::CachedHashStringRef, unsigned long, llvm::DenseMapInfo<llvm::CachedHashStringRef, void>, llvm::detail::DenseMapPai... | void clear() {
incrementEpoch();
if (getNumEntries() == 0 && getNumTombstones() == 0) return;
// If the capacity of the array is huge, and the # elements used is small,
// shrink the array.
if (getNumEntries() * 4 < getNumBuckets() && getNumBuckets() > 64) {
shrink_and_clear();
return;
... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x548460
movq 0x8(%rsp), %rdi
callq 0x39c96b0
cmpl $0x0, %eax
jne 0x39c890b
movq 0x8(%rsp), %rdi
callq 0x39caa00
cmpl $0x0, %eax
jne 0x39c890b
jmp 0x39c89d9
movq 0x8(%rsp), %rdi
callq 0x39c96b0
movq 0x8(%rsp), %rdi
shll $0x2, %eax
m... | /llvm/ADT/DenseMap.h |
bool llvm::hashing::detail::store_and_advance<llvm::wasm::ValType>(char*&, char*, llvm::wasm::ValType const&, unsigned long) | bool store_and_advance(char *&buffer_ptr, char *buffer_end, const T& value,
size_t offset = 0) {
size_t store_size = sizeof(value) - offset;
if (buffer_ptr + store_size > buffer_end)
return false;
const char *value_data = reinterpret_cast<const char *>(&value);
memcpy(buffer_ptr, valu... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movl $0x4, %eax
subq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
addq 0x8(%rsp), %rax
cmpq 0x20(%rsp), %rax
jbe 0x39da632
movb $0x0, 0x37(%rsp)
jmp 0x39da66b
movq 0x18(%rsp), %rax
m... | /llvm/ADT/Hashing.h |
llvm::wasm::WasmExport const* llvm::SmallVectorTemplateCommon<llvm::wasm::WasmExport, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<llvm::wasm::WasmExport, true>>(llvm::SmallVectorTemplateBase<llvm::wasm::WasmExport, true>*, llvm::wasm::WasmExport 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... | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rdi
callq 0x3a8dca0
addq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
callq 0x3a8dab0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
ja 0x39dee87
movq 0... | /llvm/ADT/SmallVector.h |
(anonymous namespace)::MCAsmStreamer::emitLinkerOptions(llvm::ArrayRef<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>) | void MCAsmStreamer::emitLinkerOptions(ArrayRef<std::string> Options) {
assert(!Options.empty() && "At least one option is required!");
OS << "\t.linker_option \"" << Options[0] << '"';
for (const std::string &Opt : llvm::drop_begin(Options))
OS << ", " << '"' << Opt << '"';
EmitEOL();
} | subq $0x58, %rsp
movq %rsi, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movq 0x128(%rax), %rdi
leaq 0x4925909(%rip), %rsi # 0x83397d3
callq 0x41be30
movq %rax, 0x8(%rsp)
leaq 0x48(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3151a10
movq 0x8(%rsp), %rdi
movq %... | /MC/MCAsmStreamer.cpp |
llvm::detail::IEEEFloat::isSignificandAllZerosExceptMSB() const | bool IEEEFloat::isSignificandAllZerosExceptMSB() const {
const integerPart *Parts = significandParts();
const unsigned PartCount = partCountForBits(semantics->precision);
for (unsigned i = 0; i < PartCount - 1; i++) {
if (Parts[i])
return false;
}
const unsigned NumHighBits =
PartCount * int... | subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x3a207f0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rsp)
movq (%rax), %rax
movl 0x8(%rax), %edi
callq 0x3a20f30
movl %eax, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movl 0x1c(%rsp), %ecx
subl $0x1, %ecx
cmpl... | /Support/APFloat.cpp |
llvm::APFloat::compareAbsoluteValue(llvm::APFloat const&) const | cmpResult compareAbsoluteValue(const APFloat &RHS) const {
assert(&getSemantics() == &RHS.getSemantics() &&
"Should only compare APFloats with the same semantics");
if (usesLayout<IEEEFloat>(getSemantics()))
return U.IEEE.compareAbsoluteValue(RHS.U.IEEE);
if (usesLayout<DoubleAPFloat>(getSe... | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x41c790
movq %rax, %rdi
callq 0x41c730
testb $0x1, %al
jne 0x3a323ab
jmp 0x3a323c8
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
movq 0x10(%rsp), %rsi
addq $0x8, %rsi
callq 0x3a23070
movl %eax, 0x24(%rsp)
jmp 0x3a323fd... | /llvm/ADT/APFloat.h |
llvm::APInt::sqrt() const | APInt APInt::sqrt() const {
// Determine the magnitude of the value.
unsigned magnitude = getActiveBits();
// Use a fast table for some small values. This also gets rid of some
// rounding errors in libc sqrt for small values.
if (magnitude <= 5) {
static const uint8_t results[32] = {
/* 0 */ ... | subq $0x1b8, %rsp # imm = 0x1B8
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x1b0(%rsp)
movq %rsi, 0x1a8(%rsp)
movq 0x1a8(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x4398d0
movl %eax, 0x1a4(%rsp)
cmpl $0x5, 0x1a4(%rsp)
ja 0x3a3e1f4
movq 0x38(%rsp), %rdi
movl 0x8(%rdi), %eax
movl %eax... | /Support/APInt.cpp |
(anonymous namespace)::CommandLineParser::addOption(llvm::cl::Option*, llvm::cl::SubCommand*) | void addOption(Option *O, SubCommand *SC) {
bool HadErrors = false;
if (O->hasArgStr()) {
// If it's a DefaultOption, check to make sure it isn't already there.
if (O->isDefaultOption() && SC->OptionsMap.contains(O->ArgStr))
return;
// Add argument to the argument map!
if (!SC->... | subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rdx, 0xd0(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0x30(%rsp)
movb $0x0, 0xcf(%rsp)
movq 0xd8(%rsp), %rdi
callq 0x54bf10
testb $0x1, %al
jne 0x3a563da
jmp 0x3a56534
movq 0xd8(%rsp), %rdi
callq 0x3a4bb30
testb $0x1, %al
jne 0x3a563ed
jmp 0x3a5643c
movq 0xd... | /Support/CommandLine.cpp |
llvm::cl::opt<(anonymous namespace)::HelpPrinter, true, llvm::cl::parser<bool>>::opt<char [17], llvm::cl::desc, llvm::cl::LocationClass<(anonymous namespace)::HelpPrinter>, llvm::cl::OptionHidden, llvm::cl::ValueExpected, llvm::cl::cat, llvm::cl::sub>(char const (&) [17], llvm::cl::desc const&, llvm::cl::LocationClass<... | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | subq $0x58, %rsp
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %rax
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %r9, 0x28(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x18(%rsp)
xorl %edx, %edx
movl %edx, %esi
callq 0x3f6a60
movq 0x18(%rsp), %rdi
addq $0x80, %rdi... | /llvm/Support/CommandLine.h |
void llvm::cl::sub::apply<llvm::cl::opt<(anonymous namespace)::HelpPrinter, true, llvm::cl::parser<bool>>>(llvm::cl::opt<(anonymous namespace)::HelpPrinter, true, llvm::cl::parser<bool>>&) const | void apply(Opt &O) const {
if (Sub)
O.addSubCommand(*Sub);
else if (Group)
for (SubCommand *SC : Group->getSubCommands())
O.addSubCommand(*SC);
} | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rax)
je 0x3a5d8d3
movq (%rsp), %rax
movq 0x38(%rsp), %rdi
movq (%rax), %rsi
callq 0x3a5d960
jmp 0x3a5d959
movq (%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3a5d957
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x3... | /llvm/Support/CommandLine.h |
llvm::cl::opt<(anonymous namespace)::VersionPrinter, true, llvm::cl::parser<bool>>::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... | subq $0x68, %rsp
movq %rdx, 0x50(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x48(%rsp)
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq 0x38(%rsp), %rsi
movq %rsi, 0x8(%rsp)
movb $0x0, 0x33(%rsp)
movq %rsi, %rdi
addq $0x90, %rdi
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rax
movq %rax... | /llvm/Support/CommandLine.h |
llvm::StringRef::find(llvm::StringRef, unsigned long) const | size_t StringRef::find(StringRef Str, size_t From) const {
if (From > Length)
return npos;
const char *Start = Data + From;
size_t Size = Length - From;
const char *Needle = Str.data();
size_t N = Str.size();
if (N == 0)
return From;
if (Size < N)
return npos;
if (N == 1) {
const char ... | subq $0x178, %rsp # imm = 0x178
movq %rsi, 0x160(%rsp)
movq %rdx, 0x168(%rsp)
movq %rdi, 0x158(%rsp)
movq %rcx, 0x150(%rsp)
movq 0x158(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movq 0x150(%rsp), %rax
cmpq 0x8(%rcx), %rax
jbe 0x3a9a063
movq $-0x1, 0x170(%rsp)
jmp 0x3a9a3f3
movq 0x10(%rsp), %rax
movq (%rax), %rcx
addq... | /Support/StringRef.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::SuffixTreeInternalNode*, std::pair<llvm::SuffixTreeNode*, llvm::SuffixTreeNode*>, llvm::DenseMapInfo<llvm::SuffixTreeInternalNode*, void>, llvm::detail::DenseMapPair<llvm::SuffixTreeInternalNode*, std::pair<llvm::SuffixTreeNode*, llvm::SuffixTreeNode*>>>, llvm::SuffixTreeInternal... | void initEmpty() {
setNumEntries(0);
setNumTombstones(0);
assert((getNumBuckets() & (getNumBuckets()-1)) == 0 &&
"# initial buckets must be a power of two!");
const KeyT EmptyKey = getEmptyKey();
for (BucketT *B = getBuckets(), *E = getBucketsEnd(); B != E; ++B)
::new (&B->getFirst... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
xorl %esi, %esi
callq 0x3aa00f0
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x3aa0110
callq 0x3aa0130
movq (%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x3aa0140
movq (%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x3aa0150
movq %rax, 0x8(%rsp)
movq 0x10(... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::ThreadPoolTaskGroup*, unsigned int, llvm::DenseMapInfo<llvm::ThreadPoolTaskGroup*, void>, llvm::detail::DenseMapPair<llvm::ThreadPoolTaskGroup*, unsigned int>>, llvm::ThreadPoolTaskGroup*, unsigned int, llvm::DenseMapInfo<llvm::ThreadPoolTaskGroup*, void>, llvm::detail::DenseMapP... | 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... | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x3aa3b90
callq 0x3aa3c50
movq %rax, 0x48(%rsp)
callq 0x3aa4480
movq %rax, 0x40(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rs... | /llvm/ADT/DenseMap.h |
llvm::yaml::Scanner::scanPlainScalar() | bool Scanner::scanPlainScalar() {
StringRef::iterator Start = Current;
unsigned ColStart = Column;
unsigned LeadingBlanks = 0;
assert(Indent >= -1 && "Indent must be >= -1 !");
unsigned indent = static_cast<unsigned>(Indent + 1);
while (Current != End) {
if (*Current == '#')
break;
while (Cur... | subq $0xf8, %rsp
movq %rdi, 0xe8(%rsp)
movq 0xe8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rax), %rcx
movq %rcx, 0xe0(%rsp)
movl 0x3c(%rax), %ecx
movl %ecx, 0xdc(%rsp)
movl $0x0, 0xd8(%rsp)
movl 0x38(%rax), %eax
addl $0x1, %eax
movl %eax, 0xd4(%rsp)
movq 0x8(%rsp), %rcx
movq 0x28(%rcx), %rax
cmpq 0x30(%rcx), %rax
je ... | /Support/YAMLParser.cpp |
llvm::json::fixUTF8[abi:cxx11](llvm::StringRef) | std::string fixUTF8(llvm::StringRef S) {
// This isn't particularly efficient, but is only for error-recovery.
std::vector<UTF32> Codepoints(S.size()); // 1 codepoint per byte suffices.
const UTF8 *In8 = reinterpret_cast<const UTF8 *>(S.data());
UTF32 *Out32 = Codepoints.data();
ConvertUTF8toUTF32(&In8, In8 +... | subq $0xc8, %rsp
movq %rdi, 0x60(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb0(%rsp)
movq %rdx, 0xb8(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0x3f3670
movq %rax, 0x10(%rsp)
leaq 0x97(%rsp), %rdi
callq 0x4343a0
movq 0x10(%rsp), %rsi
leaq 0x98(%rsp), %rdi
leaq 0x97(%rsp), %rdx
callq 0x932920
l... | /Support/JSON.cpp |
llvm::json::(anonymous namespace)::Parser::eatWhitespace() | void eatWhitespace() {
while (P != End && (*P == ' ' || *P == '\r' || *P == '\n' || *P == '\t'))
++P;
} | movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rdx
movq 0x18(%rdx), %rcx
xorl %eax, %eax
cmpq 0x20(%rdx), %rcx
movb %al, -0x11(%rsp)
je 0x3af6d07
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x12(%rsp)
je 0x3af6cff
mov... | /Support/JSON.cpp |
buildCopyFromRegs(llvm::MachineIRBuilder&, llvm::ArrayRef<llvm::Register>, llvm::ArrayRef<llvm::Register>, llvm::LLT, llvm::LLT, llvm::ISD::ArgFlagsTy) | static void buildCopyFromRegs(MachineIRBuilder &B, ArrayRef<Register> OrigRegs,
ArrayRef<Register> Regs, LLT LLTy, LLT PartLLT,
const ISD::ArgFlagsTy Flags) {
MachineRegisterInfo &MRI = *B.getMRI();
if (PartLLT == LLTy) {
// We should have avoided int... | subq $0xbb8, %rsp # imm = 0xBB8
leaq 0xbc8(%rsp), %rax
movq %rax, 0x170(%rsp)
movq 0xbc0(%rsp), %rax
movq %rsi, 0xba8(%rsp)
movq %rdx, 0xbb0(%rsp)
movq %rcx, 0xb98(%rsp)
movq %r8, 0xba0(%rsp)
movq %r9, 0xb90(%rsp)
movq %rax, 0xb88(%rsp)
movq %rdi, 0xb80(%rsp)
movq 0xb80(%rsp), %rdi
callq 0x800310
movq %rax, ... | /CodeGen/GlobalISel/CallLowering.cpp |
llvm::Combiner::WorkListMaintainer::reportFullyCreatedInstrs() | void reportFullyCreatedInstrs() {
LLVM_DEBUG(for (const auto *MI
: CreatedInstrs) {
dbgs() << "Created: ";
MI->print(dbgs());
});
LLVM_DEBUG(CreatedInstrs.clear());
} | movq %rdi, -0x8(%rsp)
jmp 0x3b26647
jmp 0x3b26649
jmp 0x3b2664b
retq
nopl (%rax)
| /CodeGen/GlobalISel/Combiner.cpp |
(anonymous namespace)::ChoosePreferredUse(llvm::MachineInstr&, llvm::PreferredTuple&, llvm::LLT, unsigned int, llvm::MachineInstr*) | PreferredTuple ChoosePreferredUse(MachineInstr &LoadMI,
PreferredTuple &CurrentUse,
const LLT TyForCandidate,
unsigned OpcodeForCandidate,
MachineInstr *MIForCandidate) {
if (!Curren... | subq $0x88, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, 0x18(%rsp)
movq %rcx, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movl %r8d, 0x6c(%rsp)
movq %r9, 0x60(%rsp)
movq 0x70(%rsp), %rdi
callq 0x7fcef0
testb $0x1, %al
jne 0x3b2b09e
movq 0x70(%rsp), %rax
movl 0x8(%rax), %eax
cmpl 0x6c(%rsp), %eax
je 0x3b2b054
movq ... | /CodeGen/GlobalISel/CombinerHelper.cpp |
llvm::CombinerHelper::isIndexedLoadStoreLegal(llvm::GLoadStore&) const | bool CombinerHelper::isIndexedLoadStoreLegal(GLoadStore &LdSt) const {
// Check for legality.
LLT PtrTy = MRI.getType(LdSt.getPointerReg());
LLT Ty = MRI.getType(LdSt.getReg(0));
LLT MemTy = LdSt.getMMO().getMemoryType();
SmallVector<LegalityQuery::MemDesc, 2> MemDescrs(
{{MemTy, MemTy.getSizeInBits().g... | subq $0x1c8, %rsp # imm = 0x1C8
movq %rdi, 0x1c0(%rsp)
movq %rsi, 0x1b8(%rsp)
movq 0x1c0(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x1b8(%rsp), %rdi
callq 0x828200
movq 0x10(%rsp), %rdi
movl %eax, 0x1ac(%rsp)
movl 0x1ac(%rsp), %esi
callq 0x7f52b0
movq %rax, %rcx
movq 0... | /CodeGen/GlobalISel/CombinerHelper.cpp |
llvm::CombinerHelper::matchCombineTruncOfShift(llvm::MachineInstr&, std::pair<llvm::MachineInstr*, llvm::LLT>&) | bool CombinerHelper::matchCombineTruncOfShift(
MachineInstr &MI, std::pair<MachineInstr *, LLT> &MatchInfo) {
assert(MI.getOpcode() == TargetOpcode::G_TRUNC && "Expected a G_TRUNC");
Register DstReg = MI.getOperand(0).getReg();
Register SrcReg = MI.getOperand(1).getReg();
if (!MRI.hasOneNonDBGUse(SrcReg))
... | subq $0x1d8, %rsp # imm = 0x1D8
movq %rdi, 0x1c8(%rsp)
movq %rsi, 0x1c0(%rsp)
movq %rdx, 0x1b8(%rsp)
movq 0x1c8(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x1c0(%rsp), %rdi
xorl %esi, %esi
callq 0x73fa00
movq %rax, %rdi
callq 0x72c500
movl %eax, 0x1b4(%rsp)
movq 0x1c0(%rsp), %rdi
movl $0x1, %esi
callq 0x73fa00
m... | /CodeGen/GlobalISel/CombinerHelper.cpp |
llvm::CombinerHelper::matchBitfieldExtractFromShr(llvm::MachineInstr&, std::function<void (llvm::MachineIRBuilder&)>&) | bool CombinerHelper::matchBitfieldExtractFromShr(
MachineInstr &MI, std::function<void(MachineIRBuilder &)> &MatchInfo) {
const unsigned Opcode = MI.getOpcode();
assert(Opcode == TargetOpcode::G_ASHR || Opcode == TargetOpcode::G_LSHR);
const Register Dst = MI.getOperand(0).getReg();
const unsigned ExtrOpc... | subq $0x188, %rsp # imm = 0x188
movq %rdi, 0x178(%rsp)
movq %rsi, 0x170(%rsp)
movq %rdx, 0x168(%rsp)
movq 0x178(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x170(%rsp), %rdi
callq 0x72bbb0
movl %eax, 0x164(%rsp)
movq 0x170(%rsp), %rdi
xorl %esi, %esi
callq 0x73fa00
movq %rax, %rdi
callq 0x72c500
movl %eax, %ecx
m... | /CodeGen/GlobalISel/CombinerHelper.cpp |
llvm::CombinerHelper::reassociationCanBreakAddressingModePattern(llvm::MachineInstr&) | bool CombinerHelper::reassociationCanBreakAddressingModePattern(
MachineInstr &MI) {
auto &PtrAdd = cast<GPtrAdd>(MI);
Register Src1Reg = PtrAdd.getBaseReg();
auto *Src1Def = getOpcodeDef<GPtrAdd>(Src1Reg, MRI);
if (!Src1Def)
return false;
Register Src2Reg = PtrAdd.getOffsetReg();
if (MRI.hasOneN... | subq $0x1b8, %rsp # imm = 0x1B8
movq %rdi, 0x1a8(%rsp)
movq %rsi, 0x1a0(%rsp)
movq 0x1a8(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x1a0(%rsp), %rdi
callq 0x3b34f10
movq %rax, 0x198(%rsp)
movq 0x198(%rsp), %rdi
callq 0x8b3210
movl %eax, %ecx
movq 0x38(%rsp), %rax
movl %ecx, 0x194(%rsp)
movl 0x194(%rsp), %ecx
mo... | /CodeGen/GlobalISel/CombinerHelper.cpp |
llvm::CombinerHelper::matchMulOBy2(llvm::MachineInstr&, std::function<void (llvm::MachineIRBuilder&)>&) | bool CombinerHelper::matchMulOBy2(MachineInstr &MI, BuildFnTy &MatchInfo) {
unsigned Opc = MI.getOpcode();
assert(Opc == TargetOpcode::G_UMULO || Opc == TargetOpcode::G_SMULO);
if (!mi_match(MI.getOperand(3).getReg(), MRI, m_SpecificICstOrSplat(2)))
return false;
MatchInfo = [=, &MI](MachineIRBuilder &B) ... | subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
movq 0x40(%rsp), %rdi
callq 0x72bbb0
movl %eax, 0x34(%rsp)
movq 0x40(%rsp), %rdi
movl $0x3, %esi
callq 0x73fa00
movq %rax, %rdi
callq 0x72c500
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, 0x30(%rsp... | /CodeGen/GlobalISel/CombinerHelper.cpp |
(anonymous namespace)::ExtraFlags::ExtraFlags(llvm::CallBase const&) | explicit ExtraFlags(const CallBase &CB) {
const InlineAsm *IA = cast<InlineAsm>(CB.getCalledOperand());
if (IA->hasSideEffects())
Flags |= InlineAsm::Extra_HasSideEffects;
if (IA->isAlignStack())
Flags |= InlineAsm::Extra_IsAlignStack;
if (CB.isConvergent())
Flags |= InlineAsm::Extra_I... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, (%rax)
movq 0x18(%rsp), %rdi
callq 0x78bb80
movq %rax, %rdi
callq 0x13a83d0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2e3bff0
testb $0x1, %al
jne 0x3bbd025
jmp 0x3bbd031
movq 0x8(%rsp), %rax
movl... | /CodeGen/GlobalISel/InlineAsmLowering.cpp |
void llvm::SmallVectorTemplateBase<llvm::LegalityPredicates::TypePairAndMemDesc, true>::uninitialized_copy<llvm::LegalityPredicates::TypePairAndMemDesc const, llvm::LegalityPredicates::TypePairAndMemDesc>(llvm::LegalityPredicates::TypePairAndMemDesc const*, llvm::LegalityPredicates::TypePairAndMemDesc const*, llvm::Leg... | static void uninitialized_copy(
T1 *I, T1 *E, T2 *Dest,
std::enable_if_t<std::is_same<std::remove_const_t<T1>, T2>::value> * =
nullptr) {
// Use memcpy for PODs iterated by pointers (which includes SmallVector
// iterators): std::uninitialized_copy optimizes to memmove, but we can
// u... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0x3bc3d68
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rax
subq %rax, %rdx
sarq $0x5, %rdx
shlq $0x5, %rdx
callq 0x348690
addq $0x... | /llvm/ADT/SmallVector.h |
llvm::LegalizerHelper::widenScalarMulo(llvm::MachineInstr&, unsigned int, llvm::LLT) | LegalizerHelper::LegalizeResult
LegalizerHelper::widenScalarMulo(MachineInstr &MI, unsigned TypeIdx,
LLT WideTy) {
if (TypeIdx == 1) {
Observer.changingInstr(MI);
widenScalarDst(MI, WideTy, 1);
Observer.changedInstr(MI);
return Legalized;
}
bool IsSigned = MI.getO... | subq $0x5c8, %rsp # imm = 0x5C8
movq %rcx, 0x5b8(%rsp)
movq %rdi, 0x5b0(%rsp)
movq %rsi, 0x5a8(%rsp)
movl %edx, 0x5a4(%rsp)
movq 0x5b0(%rsp), %rax
movq %rax, 0x78(%rsp)
cmpl $0x1, 0x5a4(%rsp)
jne 0x3bf3e60
movq 0x78(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x5a8(%rsp), %rsi
movq (%rdi), %rax
callq *0x20(%rax)
m... | /CodeGen/GlobalISel/LegalizerHelper.cpp |
llvm::LegalizerHelper::lowerBswap(llvm::MachineInstr&) | LegalizerHelper::LegalizeResult LegalizerHelper::lowerBswap(MachineInstr &MI) {
auto [Dst, Src] = MI.getFirst2Regs();
const LLT Ty = MRI.getType(Src);
unsigned SizeInBytes = (Ty.getScalarSizeInBits() + 7) / 8;
unsigned BaseShiftAmt = (SizeInBytes - 1) * 8;
// Swap most and least significant byte, set remaini... | subq $0x4d8, %rsp # imm = 0x4D8
movq %rdi, 0x4d0(%rsp)
movq %rsi, 0x4c8(%rsp)
movq 0x4d0(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x4c8(%rsp), %rsi
leaq 0x4c0(%rsp), %rdi
callq 0x3b53e30
leaq 0x4c0(%rsp), %rdi
callq 0x3b53eb0
movq %rax, 0x4b8(%rsp)
leaq 0x4c0(%rsp), %rdi
callq 0x3b53ec0
movq %rax, %rcx
movq 0x... | /CodeGen/GlobalISel/LegalizerHelper.cpp |
llvm::RegBankSelect::repairReg(llvm::MachineOperand&, llvm::RegisterBankInfo::ValueMapping const&, llvm::RegBankSelect::RepairingPlacement&, llvm::iterator_range<llvm::Register const*> const&) | bool RegBankSelect::repairReg(
MachineOperand &MO, const RegisterBankInfo::ValueMapping &ValMapping,
RegBankSelect::RepairingPlacement &RepairPt,
const iterator_range<SmallVectorImpl<Register>::const_iterator> &NewVRegs) {
assert(ValMapping.NumBreakDowns == (unsigned)size(NewVRegs) &&
"need new ... | subq $0x148, %rsp # imm = 0x148
movq %rdi, 0x140(%rsp)
movq %rsi, 0x138(%rsp)
movq %rdx, 0x130(%rsp)
movq %rcx, 0x128(%rsp)
movq %r8, 0x120(%rsp)
movq 0x140(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x130(%rsp), %rax
cmpl $0x1, 0x8(%rax)
jne 0x3c4c2b1
movq 0x138(%rsp), %rdi
callq 0x72c500
movl %eax, 0x114(%rsp)... | /CodeGen/GlobalISel/RegBankSelect.cpp |
llvm::RegBankSelect::MappingCost::addNonLocalCost(unsigned long) | bool RegBankSelect::MappingCost::addNonLocalCost(uint64_t Cost) {
// Check if this overflows.
if (NonLocalCost + Cost < NonLocalCost) {
saturate();
return true;
}
NonLocalCost += Cost;
return isSaturated();
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x8(%rcx), %rax
addq 0x10(%rsp), %rax
cmpq 0x8(%rcx), %rax
jae 0x3c4dc48
movq 0x8(%rsp), %rdi
callq 0x3c4dbc0
movb $0x1, 0x27(%rsp)
jmp 0x3c4dc65
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
addq 0x8(%rdi), %rax
m... | /CodeGen/GlobalISel/RegBankSelect.cpp |
llvm::getFConstantVRegValWithLookThrough(llvm::Register, llvm::MachineRegisterInfo const&, bool) | std::optional<FPValueAndVReg> llvm::getFConstantVRegValWithLookThrough(
Register VReg, const MachineRegisterInfo &MRI, bool LookThroughInstrs) {
auto Reg =
getConstantVRegValWithLookThrough<isFConstant, getCImmOrFPImmAsAPInt>(
VReg, MRI, LookThroughInstrs);
if (!Reg)
return std::nullopt;
r... | subq $0x98, %rsp
movq %rdi, 0x8(%rsp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, 0x10(%rsp)
movq %rdi, 0x90(%rsp)
movl %esi, 0x8c(%rsp)
movq %rdx, 0x80(%rsp)
andb $0x1, %al
movb %al, 0x7f(%rsp)
movl 0x8c(%rsp), %eax
movl %eax, 0x54(%rsp)
movq 0x80(%rsp), %rdx
movb 0x7f(%rsp), %al
movl 0x54(%rsp), %esi
leaq 0x58(%rsp), %r... | /CodeGen/GlobalISel/Utils.cpp |
llvm::getIConstantSplatSExtVal(llvm::Register, llvm::MachineRegisterInfo const&) | std::optional<int64_t>
llvm::getIConstantSplatSExtVal(const Register Reg,
const MachineRegisterInfo &MRI) {
if (auto SplatValAndReg =
getAnyConstantSplat(Reg, MRI, /* AllowUndef */ false))
return getIConstantVRegSExtVal(SplatValAndReg->VReg, MRI);
return std::nullopt;
} | subq $0x58, %rsp
movl %edi, 0x44(%rsp)
movq %rsi, 0x38(%rsp)
movl 0x44(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x38(%rsp), %rdx
movl 0x14(%rsp), %esi
leaq 0x18(%rsp), %rdi
xorl %ecx, %ecx
callq 0x3c5b4e0
leaq 0x18(%rsp), %rdi
callq 0x806c10
testb $0x1, %al
jne 0x3c5b9ea
jmp 0x3c5ba1c
leaq 0x18(%rsp), %rdi
callq 0x806c30... | /CodeGen/GlobalISel/Utils.cpp |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::AssertingVH<llvm::Function>, std::vector<llvm::MCSymbol*, std::allocator<llvm::MCSymbol*>>, llvm::DenseMapInfo<llvm::AssertingVH<llvm::Function>, void>, llvm::detail::DenseMapPair<llvm::AssertingVH<llvm::Function>, std::vector<llvm::MCSymbol*, std::allocator<llvm::MCSymbol*>... | 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... | subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq %rdx, 0x68(%rsp)
movq 0x78(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x3c7fba0
movq 0x28(%rsp), %rdi
movq %rax, 0x60(%rsp)
callq 0x3c77cd0
movl %eax, 0x5c(%rsp)
cmpl $0x0, 0x5c(%rsp)
jne 0x3c7fa18
movq 0x68(%rsp), %rax
movq $0x0, (%rax)
movb $0x0, 0x87(%rs... | /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::GCStrategy*, std::unique_ptr<llvm::GCMetadataPrinter, std::default_delete<llvm::GCMetadataPrinter>>, llvm::DenseMapInfo<llvm::GCStrategy*, void>, llvm::detail::DenseMapPair<llvm::GCStrategy*, std::unique_ptr<llvm::GCMetadataPrinter, std::default_delete<llvm::GCMetadataPrinte... | 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... | subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x68(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x3c8cd70
movq 0x18(%rsp), %rdi
movq %rax, 0x50(%rsp)
callq 0x3c81eb0
movl %eax, 0x4c(%rsp)
cmpl $0x0, 0x4c(%rsp)
jne 0x3c8cc22
movq 0x58(%rsp), %rax
movq $0x0, (%rax)
movb $0x0, 0x77(%rs... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::MachineInstr const*, llvm::MCSymbol*, llvm::DenseMapInfo<llvm::MachineInstr const*, void>, llvm::detail::DenseMapPair<llvm::MachineInstr const*, llvm::MCSymbol*>>, llvm::MachineInstr const*, llvm::MCSymbol*, llvm::DenseMapInfo<llvm::MachineInstr const*, void>, llvm::detail::Dense... | void clear() {
incrementEpoch();
if (getNumEntries() == 0 && getNumTombstones() == 0) return;
// If the capacity of the array is huge, and the # elements used is small,
// shrink the array.
if (getNumEntries() * 4 < getNumBuckets() && getNumBuckets() > 64) {
shrink_and_clear();
return;
... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x548460
movq 0x18(%rsp), %rdi
callq 0x3c96ba0
cmpl $0x0, %eax
jne 0x3c94cbb
movq 0x18(%rsp), %rdi
callq 0x3c96bd0
cmpl $0x0, %eax
jne 0x3c94cbb
jmp 0x3c94d80
movq 0x18(%rsp), %rdi
callq 0x3c96ba0
movq 0x18(%rsp), %rdi
shll $0x2, %... | /llvm/ADT/DenseMap.h |
llvm::DenseMapIterator<llvm::MachineInstr const*, llvm::MCSymbol*, llvm::DenseMapInfo<llvm::MachineInstr const*, void>, llvm::detail::DenseMapPair<llvm::MachineInstr const*, llvm::MCSymbol*>, false>::DenseMapIterator(llvm::detail::DenseMapPair<llvm::MachineInstr const*, llvm::MCSymbol*>*, llvm::detail::DenseMapPair<llv... | DenseMapIterator(pointer Pos, pointer E, const DebugEpochBase &Epoch,
bool NoAdvance = false)
: DebugEpochBase::HandleBase(&Epoch), Ptr(Pos), End(E) {
assert(isHandleInSync() && "invalid construction!");
if (NoAdvance) return;
if (shouldReverseIterate<KeyT>()) {
RetreatPastEm... | subq $0x38, %rsp
movb %r8b, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rsi
callq 0x5481a0
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rcx
m... | /llvm/ADT/DenseMap.h |
llvm::DIELabel::sizeOf(llvm::dwarf::FormParams const&, llvm::dwarf::Form) const | unsigned DIELabel::sizeOf(const dwarf::FormParams &FormParams,
dwarf::Form Form) const {
switch (Form) {
case dwarf::DW_FORM_data4:
return 4;
case dwarf::DW_FORM_data8:
return 8;
case dwarf::DW_FORM_sec_offset:
case dwarf::DW_FORM_strp:
return FormParams.getDwarfOffsetByt... | subq $0x28, %rsp
movw %dx, %ax
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movw %ax, 0xe(%rsp)
movzwl 0xe(%rsp), %eax
decl %eax
movq %rax, (%rsp)
movq (%rsp), %rax
leaq 0x46af260(%rip), %rcx # 0x8349e9c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x4, 0x24(%rsp)
jmp 0x3c9ac7b
movl $0x8, 0x24(%rsp)
jmp... | /CodeGen/AsmPrinter/DIE.cpp |
llvm::DwarfDebug::constructCallSiteEntryDIEs(llvm::DISubprogram const&, llvm::DwarfCompileUnit&, llvm::DIE&, llvm::MachineFunction const&) | void DwarfDebug::constructCallSiteEntryDIEs(const DISubprogram &SP,
DwarfCompileUnit &CU, DIE &ScopeDIE,
const MachineFunction &MF) {
// Add a call site-related attribute (DWARF5, Sec. 3.3.1.3). Do this only if
// the subprogram... | subq $0x298, %rsp # imm = 0x298
movq %rdi, 0x290(%rsp)
movq %rsi, 0x288(%rsp)
movq %rdx, 0x280(%rsp)
movq %rcx, 0x278(%rsp)
movq %r8, 0x270(%rsp)
movq 0x290(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x288(%rsp), %rdi
callq 0x318e810
testb $0x1, %al
jne 0x3ca218f
jmp 0x3ca21a0
movq 0x288(%rsp), %rdi
callq 0x14cf... | /CodeGen/AsmPrinter/DwarfDebug.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::DIStringType const*, unsigned int, llvm::DenseMapInfo<llvm::DIStringType const*, void>, llvm::detail::DenseMapPair<llvm::DIStringType const*, unsigned int>>, llvm::DIStringType const*, unsigned int, llvm::DenseMapInfo<llvm::DIStringType const*, void>, llvm::detail::DenseMapPair<l... | 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 + ... | subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x3cd9b5e
movl $0x0, 0x14(%rsp)
jmp 0x3cd9b7e
movl 0x4(%rsp), %eax
shll $0x2, %eax
movl $0x3, %ecx
xorl %edx, %edx
divl %ecx
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x5487c0
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::DIE const*, llvm::DwarfCompileUnit*, llvm::DenseMapInfo<llvm::DIE const*, void>, llvm::detail::DenseMapPair<llvm::DIE const*, llvm::DwarfCompileUnit*>>, llvm::DIE const*, llvm::DwarfCompileUnit*, llvm::DenseMapInfo<llvm::DIE const*, void>, llvm::detail::DenseMapPair<llvm::DIE con... | iterator makeIterator(BucketT *P, BucketT *E,
DebugEpochBase &Epoch,
bool NoAdvance=false) {
if (shouldReverseIterate<KeyT>()) {
BucketT *B = P == getBucketsEnd() ? getBuckets() : P + 1;
return iterator(B, E, Epoch, NoAdvance);
}
return iterator(P,... | subq $0x58, %rsp
movb %r8b, %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x3cdbfe0
testb $0x1, %al
jne 0x3cdbf36
jmp 0x3cdbfa2
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x8(%... | /llvm/ADT/DenseMap.h |
std::pair<llvm::DenseMapIterator<llvm::DISubprogram const*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::DISubprogram const*, void>, llvm::detail::DenseSetPair<llvm::DISubprogram const*>, false>, bool> llvm::DenseMapBase<llvm::DenseMap<llvm::DISubprogram const*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<... | 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()
... | subq $0x88, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, 0x28(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movq %rcx, 0x70(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x30(%rsp)
movq 0x78(%rsp), %rsi
leaq 0x68(%rsp), %rdx
callq 0x3ce7e80
testb $0x1, %al
jne 0x3ce7d25
jmp 0x3ce7d9f
movq 0x68(%rsp), %rax
movq %rax, 0x18(%rsp)
c... | /llvm/ADT/DenseMap.h |
llvm::DenseMapIterator<llvm::DwarfCompileUnit*, std::vector<ArangeSpan, std::allocator<ArangeSpan>>, llvm::DenseMapInfo<llvm::DwarfCompileUnit*, void>, llvm::detail::DenseMapPair<llvm::DwarfCompileUnit*, std::vector<ArangeSpan, std::allocator<ArangeSpan>>>, false>::RetreatPastEmptyBuckets() | void RetreatPastEmptyBuckets() {
assert(Ptr >= End);
const KeyT Empty = KeyInfoT::getEmptyKey();
const KeyT Tombstone = KeyInfoT::getTombstoneKey();
while (Ptr != End && (KeyInfoT::isEqual(Ptr[-1].getFirst(), Empty) ||
KeyInfoT::isEqual(Ptr[-1].getFirst(), Tombstone)))
-... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x3cebf90
movq %rax, 0x18(%rsp)
callq 0x3cec140
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdx
movq (%rdx), %rcx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, 0x7(%rsp)
je 0x3ced5e0
movq 0x8(%rsp), %rax
movq (%rax), %rdi
addq $-0x20, %... | /llvm/ADT/DenseMap.h |
std::pair<std::unique_ptr<llvm::DwarfTypeUnit, std::default_delete<llvm::DwarfTypeUnit>>, llvm::DICompositeType const*>& llvm::SmallVectorTemplateBase<std::pair<std::unique_ptr<llvm::DwarfTypeUnit, std::default_delete<llvm::DwarfTypeUnit>>, llvm::DICompositeType const*>, false>::growAndEmplaceBack<std::unique_ptr<llvm:... | T &growAndEmplaceBack(ArgTypes &&... Args) {
// Grow manually in case one of Args is an internal reference.
size_t NewCapacity;
T *NewElts = mallocForGrow(0, NewCapacity);
::new ((void *)(NewElts + this->size())) T(std::forward<ArgTypes>(Args)...);
moveElementsForGrow(NewElts);
takeAllocationFor... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorl %eax, %eax
movl %eax, %esi
leaq 0x18(%rsp), %rdx
callq 0x3cf0590
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
callq 0x3a8dca0
movq (%rsp), %rdi
shlq $0... | /llvm/ADT/SmallVector.h |
void llvm::DwarfUnit::addAttribute<llvm::DIEInteger>(llvm::DIEValueList&, llvm::dwarf::Attribute, llvm::dwarf::Form, llvm::DIEInteger&&) | void addAttribute(DIEValueList &Die, dwarf::Attribute Attribute,
dwarf::Form Form, T &&Value) {
// For strict DWARF mode, only generate attributes available to current
// DWARF version.
// Attribute 0 is used when emitting form-encoded values in blocks, which
// don't have attributes... | subq $0x58, %rsp
movw %cx, %ax
movw %dx, %cx
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movw %cx, 0x46(%rsp)
movw %ax, 0x44(%rsp)
movq %r8, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
movzwl 0x46(%rsp), %eax
cmpl $0x0, %eax
je 0x3cfd93c
movq 0x18(%rsp), %rax
movq 0xb8(%rax), %rax
movq 0x38(%rax), %rax
movw ... | /CodeGen/AsmPrinter/DwarfUnit.h |
llvm::DenseMapBase<llvm::DenseMap<llvm::DIE*, llvm::DINode const*, llvm::DenseMapInfo<llvm::DIE*, void>, llvm::detail::DenseMapPair<llvm::DIE*, llvm::DINode const*>>, llvm::DIE*, llvm::DINode const*, llvm::DenseMapInfo<llvm::DIE*, void>, llvm::detail::DenseMapPair<llvm::DIE*, llvm::DINode const*>>::destroyAll() | void destroyAll() {
if (getNumBuckets() == 0) // Nothing to do.
return;
const KeyT EmptyKey = getEmptyKey(), TombstoneKey = getTombstoneKey();
for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) {
if (!KeyInfoT::isEqual(P->getFirst(), EmptyKey) &&
!KeyInfoT::isEqual(P->... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x3d0a8e0
cmpl $0x0, %eax
jne 0x3d0ac42
jmp 0x3d0acda
callq 0x3d0a800
movq %rax, 0x28(%rsp)
callq 0x3d0ace0
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
callq 0x3d0a810
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x3d0a820
movq %... | /llvm/ADT/DenseMap.h |
llvm::DIScope const* const* llvm::SmallVectorTemplateCommon<llvm::DIScope const*, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<llvm::DIScope const*, true>>(llvm::SmallVectorTemplateBase<llvm::DIScope const*, true>*, llvm::DIScope const* 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... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rdi
callq 0x3a8dca0
addq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0x3a8dab0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
ja 0x3d0c0f4
movq 0x3... | /llvm/ADT/SmallVector.h |
llvm::EHStreamer::computePadMap(llvm::SmallVectorImpl<llvm::LandingPadInfo const*> const&, llvm::DenseMap<llvm::MCSymbol*, llvm::EHStreamer::PadRange, llvm::DenseMapInfo<llvm::MCSymbol*, void>, llvm::detail::DenseMapPair<llvm::MCSymbol*, llvm::EHStreamer::PadRange>>&) | void EHStreamer::computePadMap(
const SmallVectorImpl<const LandingPadInfo *> &LandingPads,
RangeMapType &PadMap) {
// Invokes and nounwind calls have entries in PadMap (due to being bracketed
// by try-range labels when lowered). Ordinary calls do not, so appropriate
// try-ranges for them need be deduc... | subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x38(%rsp), %rdi
callq 0x3a8dca0
movl %eax, 0x28(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x28(%rsp), %eax
je 0x3d0d816
movq 0x38(%rsp), %rdi
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0x3d0d820
movq (%rax), %rax
movq... | /CodeGen/AsmPrinter/EHStreamer.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::MCSymbol*, llvm::EHStreamer::PadRange, llvm::DenseMapInfo<llvm::MCSymbol*, void>, llvm::detail::DenseMapPair<llvm::MCSymbol*, llvm::EHStreamer::PadRange>>, llvm::MCSymbol*, llvm::EHStreamer::PadRange, llvm::DenseMapInfo<llvm::MCSymbol*, void>, llvm::detail::DenseMapPair<llvm::MCS... | iterator find(const_arg_type_t<KeyT> Val) {
BucketT *TheBucket;
if (LookupBucketFor(Val, TheBucket))
return makeIterator(TheBucket,
shouldReverseIterate<KeyT>() ? getBuckets()
: getBucketsEnd(),
*thi... | subq $0x48, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
leaq 0x28(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x3d12220
testb $0x1, %al
jne 0x3d0e13d
jmp 0x3d0e19b
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x19f5e60
testb $0x1, %al
jne 0x3d0e152
jmp 0x3d0e163
movq 0x... | /llvm/ADT/DenseMap.h |
llvm::WinException::emitCSpecificHandlerTable(llvm::MachineFunction const*) | void WinException::emitCSpecificHandlerTable(const MachineFunction *MF) {
auto &OS = *Asm->OutStreamer;
MCContext &Ctx = Asm->OutContext;
const WinEHFuncInfo &FuncInfo = *MF->getWinEHFuncInfo();
bool VerboseAsm = OS.isVerboseAsm();
auto AddComment = [&](const Twine &Comment) {
if (VerboseAsm)
OS.Ad... | subq $0x318, %rsp # imm = 0x318
movq %rdi, 0x310(%rsp)
movq %rsi, 0x308(%rsp)
movq 0x310(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x8(%rax), %rdi
addq $0x50, %rdi
callq 0x72a0c0
movq %rax, %rcx
movq 0x58(%rsp), %rax
movq %rcx, 0x300(%rsp)
movq 0x8(%rax), %rax
movq 0x48(%rax), %rax
movq %rax, 0x2f8(%rsp)
movq 0... | /CodeGen/AsmPrinter/WinException.cpp |
llvm::WinException::getFrameIndexOffset(int, llvm::WinEHFuncInfo const&) | int WinException::getFrameIndexOffset(int FrameIndex,
const WinEHFuncInfo &FuncInfo) {
const TargetFrameLowering &TFI = *Asm->MF->getSubtarget().getFrameLowering();
Register UnusedReg;
if (Asm->MAI->usesWindowsCFI()) {
StackOffset Offset =
TFI.getFrameIndexReferen... | subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movl %esi, 0x54(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rax), %rax
movq 0x58(%rax), %rdi
callq 0x73c170
movq %rax, %rdi
movq (%rdi), %rax
callq *0x88(%rax)
movq %rax, 0x40(%rsp)
leaq 0x3c(%rsp), %rdi
xorl %esi, %esi
callq 0x72e210
movq (%rsp),... | /CodeGen/AsmPrinter/WinException.cpp |
llvm::CodeViewDebug::getTypeIndex(llvm::DIType const*, llvm::DIType const*) | TypeIndex CodeViewDebug::getTypeIndex(const DIType *Ty, const DIType *ClassTy) {
// The null DIType is the void type. Don't try to hash it.
if (!Ty)
return TypeIndex::Void();
// Check if we've already translated this type. Don't try to do a
// get-or-create style insertion that caches the hash lookup acros... | subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x60(%rsp)
jne 0x3d21523
callq 0x3d2dc20
movl %eax, 0x74(%rsp)
jmp 0x3d215f8
movq 0x10(%rsp), %rax
addq $0x450, %rax # imm = 0x450
movq %rax, 0x8(%rsp)
leaq 0x38(%rsp), %r... | /CodeGen/AsmPrinter/CodeViewDebug.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.