name string | code string | asm string | file string |
|---|---|---|---|
llvm::CodeViewDebug::beginModule(llvm::Module*) | void CodeViewDebug::beginModule(Module *M) {
// If module doesn't have named metadata anchors or COFF debug section
// is not available, skip any debug info related stuff.
if (!MMI->hasDebugInfo() ||
!Asm->getObjFileLowering().getCOFFDebugSymbolsSection()) {
Asm = nullptr;
return;
}
TheCPU = ma... | subq $0xe8, %rsp
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq 0xe0(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x10(%rax), %rdi
callq 0x194f7e0
testb $0x1, %al
jne 0x3d227f3
jmp 0x3d2280f
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x3c61820
movq %rax, %rdi
callq 0x3d22970
cmpq $0x0, %rax
jne 0x3d22821
movq 0x20(%r... | /CodeGen/AsmPrinter/CodeViewDebug.cpp |
llvm::CodeViewDebug::createDefRangeMem(unsigned short, int) | CodeViewDebug::LocalVarDef
CodeViewDebug::createDefRangeMem(uint16_t CVRegister, int Offset) {
LocalVarDef DR;
DR.InMemory = -1;
DR.DataOffset = Offset;
assert(DR.DataOffset == Offset && "truncation");
DR.IsSubfield = 0;
DR.StructOffset = 0;
DR.CVRegister = CVRegister;
return DR;
} | movw %di, %ax
movw %ax, -0xa(%rsp)
movl %esi, -0x10(%rsp)
movl -0x8(%rsp), %eax
andl $-0x2, %eax
orl $0x1, %eax
movl %eax, -0x8(%rsp)
movl -0x10(%rsp), %ecx
movl -0x8(%rsp), %eax
andl $0x7fffffff, %ecx # imm = 0x7FFFFFFF
shll %ecx
andl $0x1, %eax
orl %ecx, %eax
movl %eax, -0x8(%rsp)
movw -0x4(%rsp), %ax
andw $-0x... | /CodeGen/AsmPrinter/CodeViewDebug.cpp |
llvm::CodeViewDebug::calculateRanges(llvm::CodeViewDebug::LocalVariable&, llvm::SmallVector<llvm::DbgValueHistoryMap::Entry, 4u> const&) | void CodeViewDebug::calculateRanges(
LocalVariable &Var, const DbgValueHistoryMap::Entries &Entries) {
const TargetRegisterInfo *TRI = Asm->MF->getSubtarget().getRegisterInfo();
// Calculate the definition ranges.
for (auto I = Entries.begin(), E = Entries.end(); I != E; ++I) {
const auto &Entry = *I;
... | subq $0x128, %rsp # imm = 0x128
movq %rdi, 0x120(%rsp)
movq %rsi, 0x118(%rsp)
movq %rdx, 0x110(%rsp)
movq 0x120(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x8(%rax), %rax
movq 0x58(%rax), %rdi
callq 0x73c170
movq %rax, %rdi
movq (%rdi), %rax
callq *0xc8(%rax)
movq %rax, 0x108(%rsp)
movq 0x110(%rsp), %rdi
callq 0... | /CodeGen/AsmPrinter/CodeViewDebug.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::Function const*, unsigned int, llvm::DenseMapInfo<llvm::Function const*, void>, llvm::detail::DenseMapPair<llvm::Function const*, unsigned int>>, llvm::Function const*, unsigned int, llvm::DenseMapInfo<llvm::Function const*, void>, llvm::detail::DenseMapPair<llvm::Function const*... | 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 0x3d36740
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x3d36760
callq 0x3d36780
movq (%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x3d36790
movq (%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x3d367a0
movq %rax, 0x8(%rsp)
movq 0x10(... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<std::pair<llvm::DINode const*, llvm::DIType const*>, llvm::codeview::TypeIndex, llvm::DenseMapInfo<std::pair<llvm::DINode const*, llvm::DIType const*>, void>, llvm::detail::DenseMapPair<std::pair<llvm::DINode const*, llvm::DIType const*>, llvm::codeview::TypeIndex>>, std::pair<llvm::DI... | 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 $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x3d476e0
callq 0x3d45ff0
movq %rax, 0x50(%rsp)
movq %rdx, 0x58(%rsp)
callq 0x3d46020
movq %rax, 0x40(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x60(%rs... | /llvm/ADT/DenseMap.h |
llvm::CodeViewDebug::LocalVariable& llvm::SmallVectorTemplateBase<llvm::CodeViewDebug::LocalVariable, false>::growAndEmplaceBack<llvm::CodeViewDebug::LocalVariable>(llvm::CodeViewDebug::LocalVariable&&) | 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 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
xorl %eax, %eax
movl %eax, %esi
leaq 0x20(%rsp), %rdx
callq 0x3d37db0
movq 0x10(%rsp), %rdi
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x3a8dca0
movq 0x8(%rsp), %rdi
imulq $0x50, %rax, %r... | /llvm/ADT/SmallVector.h |
llvm::DenseMapIterator<llvm::MCSymbol const*, llvm::AddressPool::AddressPoolEntry, llvm::DenseMapInfo<llvm::MCSymbol const*, void>, llvm::detail::DenseMapPair<llvm::MCSymbol const*, llvm::AddressPool::AddressPoolEntry>, 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 0x1dffb20
movq %rax, 0x18(%rsp)
callq 0x1dffbc0
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdx
movq (%rdx), %rcx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, 0x7(%rsp)
je 0x3d77db8
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x3cb89f... | /llvm/ADT/DenseMap.h |
void llvm::SmallVectorImpl<llvm::MCExpr const*>::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 $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x3a8dca0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jne 0x3d78209
jmp 0x3d782a9
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
callq 0x3a8dc... | /llvm/ADT/SmallVector.h |
llvm::SmallVectorImpl<llvm::DbgValueHistoryMap::Entry>::assignRemote(llvm::SmallVectorImpl<llvm::DbgValueHistoryMap::Entry>&&) | 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();
} | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x3c960c0
movq 0x10(%rsp), %rdi
movq %rax, 0x8(%rsp)
callq 0x3c960d0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x3c960b0
movq 0x10(%rsp), %rdi
callq 0x3c96150
testb $0x1, %al
jne 0x3d83689
movq 0x10(%rsp), %r... | /llvm/ADT/SmallVector.h |
llvm::DIEHash::addULEB128(unsigned long) | void DIEHash::addULEB128(uint64_t Value) {
LLVM_DEBUG(dbgs() << "Adding ULEB128 " << Value << " to hash.\n");
do {
uint8_t Byte = Value & 0x7f;
Value >>= 7;
if (Value != 0)
Byte |= 0x80; // Mark this byte to show that more bytes will follow.
Hash.update(Byte);
} while (Value != 0);
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x3d8612a
jmp 0x3d8612c
movq 0x28(%rsp), %rax
andq $0x7f, %rax
movb %al, 0x27(%rsp)
movq 0x28(%rsp), %rax
shrq $0x7, %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x3d8615d
movzbl 0x27(%rsp), %eax
orl $0x80... | /CodeGen/AsmPrinter/DIEHash.cpp |
llvm::DIEHash::hashShallowTypeReference(llvm::dwarf::Attribute, llvm::DIE const&, llvm::StringRef) | void DIEHash::hashShallowTypeReference(dwarf::Attribute Attribute,
const DIE &Entry, StringRef Name) {
// append the letter 'N'
addULEB128('N');
// the DWARF attribute code (DW_AT_type or DW_AT_friend),
addULEB128(Attribute);
// the context of the tag,
if (const DIE ... | subq $0x48, %rsp
movw %si, %ax
movq %rcx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %rdi, 0x30(%rsp)
movw %ax, 0x2e(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
movl $0x4e, %esi
callq 0x3d86110
movq (%rsp), %rdi
movzwl 0x2e(%rsp), %eax
movl %eax, %esi
callq 0x3d86110
movq 0x20(%rsp), %rdi
callq 0x3c99... | /CodeGen/AsmPrinter/DIEHash.cpp |
llvm::DwarfCompileUnit::attachRangesOrLowHighPC(llvm::DIE&, llvm::SmallVectorImpl<std::pair<llvm::MachineInstr const*, llvm::MachineInstr const*>> const&) | void DwarfCompileUnit::attachRangesOrLowHighPC(
DIE &Die, const SmallVectorImpl<InsnRange> &Ranges) {
SmallVector<RangeSpan, 2> List;
List.reserve(Ranges.size());
for (const InsnRange &R : Ranges) {
auto *BeginLabel = DD->getLabelBeforeInsn(R.first);
auto *EndLabel = DD->getLabelAfterInsn(R.second);
... | subq $0x128, %rsp # imm = 0x128
movq %rdi, 0x120(%rsp)
movq %rsi, 0x118(%rsp)
movq %rdx, 0x110(%rsp)
movq 0x120(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0xe0(%rsp), %rdi
callq 0x3d8ae90
movq 0x110(%rsp), %rdi
callq 0x3a8dca0
movq %rax, %rsi
leaq 0xe0(%rsp), %rdi
callq 0x3d8f1c0
movq 0x110(%rsp), %rax
movq %rax... | /CodeGen/AsmPrinter/DwarfCompileUnit.cpp |
llvm::DenseMapIterator<llvm::DILocalVariable const*, llvm::DbgVariable*, llvm::DenseMapInfo<llvm::DILocalVariable const*, void>, llvm::detail::DenseMapPair<llvm::DILocalVariable const*, llvm::DbgVariable*>, 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 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 0x3d966b8
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x3d957e... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::DAGCombiner::visitSINT_TO_FP(llvm::SDNode*) | SDValue DAGCombiner::visitSINT_TO_FP(SDNode *N) {
SDValue N0 = N->getOperand(0);
EVT VT = N->getValueType(0);
EVT OpVT = N0.getValueType();
// [us]itofp(undef) = 0, because the result value is bounded.
if (N0.isUndef())
return DAG.getConstantFP(0.0, SDLoc(N), VT);
// fold (sint_to_fp c1) -> c1fp
if ... | subq $0x398, %rsp # imm = 0x398
movq %rdi, 0x380(%rsp)
movq %rsi, 0x378(%rsp)
movq 0x380(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x378(%rsp), %rdi
xorl %esi, %esi
callq 0x981ab0
movq (%rax), %rcx
movq %rcx, 0x368(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x370(%rsp)
movq 0x378(%rsp), %rdi
xorl %esi, %esi
callq 0x... | /CodeGen/SelectionDAG/DAGCombiner.cpp |
(anonymous namespace)::DAGCombiner::visitUINT_TO_FP(llvm::SDNode*) | SDValue DAGCombiner::visitUINT_TO_FP(SDNode *N) {
SDValue N0 = N->getOperand(0);
EVT VT = N->getValueType(0);
EVT OpVT = N0.getValueType();
// [us]itofp(undef) = 0, because the result value is bounded.
if (N0.isUndef())
return DAG.getConstantFP(0.0, SDLoc(N), VT);
// fold (uint_to_fp c1) -> c1fp
if ... | subq $0x298, %rsp # imm = 0x298
movq %rdi, 0x280(%rsp)
movq %rsi, 0x278(%rsp)
movq 0x280(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x278(%rsp), %rdi
xorl %esi, %esi
callq 0x981ab0
movq (%rax), %rcx
movq %rcx, 0x268(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x270(%rsp)
movq 0x278(%rsp), %rdi
xorl %esi, %esi
callq 0x... | /CodeGen/SelectionDAG/DAGCombiner.cpp |
isConstantSplatVectorMaskForType(llvm::SDNode*, llvm::EVT) | static bool isConstantSplatVectorMaskForType(SDNode *N, EVT ScalarTy) {
if (!ScalarTy.isSimple())
return false;
uint64_t MaskForTy = 0ULL;
switch (ScalarTy.getSimpleVT().SimpleTy) {
case MVT::i8:
MaskForTy = 0xFFULL;
break;
case MVT::i16:
MaskForTy = 0xFFFFULL;
break;
case MVT::i32:
... | subq $0x48, %rsp
movb %sil, %al
movb %al, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movq %rdi, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x792fe0
testb $0x1, %al
jne 0x3e38dfd
movb $0x0, 0x47(%rsp)
jmp 0x3e38ebf
movq $0x0, 0x20(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x793000
movb %al, 0x1f(%rsp)
movzbl 0x1f(%rsp), %eax
movl %eax, (%rsp... | /CodeGen/SelectionDAG/DAGCombiner.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::SDNode*, std::pair<llvm::SDNode*, unsigned int>, llvm::DenseMapInfo<llvm::SDNode*, void>, llvm::detail::DenseMapPair<llvm::SDNode*, std::pair<llvm::SDNode*, unsigned int>>>, llvm::SDNode*, std::pair<llvm::SDNode*, unsigned int>, llvm::DenseMapInfo<llvm::SDNode*, void>, llvm::deta... | 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 0x3e97ed0
testb $0x1, %al
jne 0x3e97d6d
jmp 0x3e97dcb
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x16a0220
testb $0x1, %al
jne 0x3e97d82
jmp 0x3e97d93
movq 0x... | /llvm/ADT/DenseMap.h |
narrowExtractedVectorLoad(llvm::SDNode*, llvm::SelectionDAG&) | static SDValue narrowExtractedVectorLoad(SDNode *Extract, SelectionDAG &DAG) {
// TODO: Add support for big-endian. The offset calculation must be adjusted.
if (DAG.getDataLayout().isBigEndian())
return SDValue();
auto *Ld = dyn_cast<LoadSDNode>(Extract->getOperand(0));
if (!Ld || Ld->getExtensionType() ||... | subq $0x228, %rsp # imm = 0x228
movq %rdi, 0x210(%rsp)
movq %rsi, 0x208(%rsp)
movq 0x208(%rsp), %rdi
callq 0x9819b0
movq %rax, %rdi
callq 0x9e2fb0
testb $0x1, %al
jne 0x3eb19b2
jmp 0x3eb19d8
leaq 0x218(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x348990
leaq 0x218(%rsp), %rdi
callq 0x98b9c0
jmp 0x3eb... | /CodeGen/SelectionDAG/DAGCombiner.cpp |
llvm::FastISel::selectCall(llvm::User const*) | bool FastISel::selectCall(const User *I) {
const CallInst *Call = cast<CallInst>(I);
// Handle simple inline asms.
if (const InlineAsm *IA = dyn_cast<InlineAsm>(Call->getCalledOperand())) {
// Don't attempt to handle constraints.
if (!IA->getConstraintString().empty())
return false;
unsigned E... | subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x70(%rsp), %rdi
callq 0x3ed6f90
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rdi
callq 0x78bb80
movq %rax, %rdi
callq 0x2e3be80
movq %rax, 0x60(%rsp)
cmpq $0x0, 0x60(%rsp)
je 0x3ed6f28
movq 0x60(%rsp), %rdi
callq 0... | /CodeGen/SelectionDAG/FastISel.cpp |
(anonymous namespace)::SelectionDAGLegalize::ExpandFCOPYSIGN(llvm::SDNode*) const | SDValue SelectionDAGLegalize::ExpandFCOPYSIGN(SDNode *Node) const {
SDLoc DL(Node);
SDValue Mag = Node->getOperand(0);
SDValue Sign = Node->getOperand(1);
// Get sign bit into an integer value.
FloatSignAsInt SignAsInt;
getSignAsIntValue(SignAsInt, DL, Sign);
EVT IntVT = SignAsInt.IntValue.getValueType(... | subq $0x788, %rsp # imm = 0x788
movq %rdi, 0x770(%rsp)
movq %rsi, 0x768(%rsp)
movq 0x770(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq 0x768(%rsp), %rsi
leaq 0x758(%rsp), %rdi
movq %rdi, 0xb0(%rsp)
callq 0x9817d0
movq 0x768(%rsp), %rdi
xorl %esi, %esi
movl %esi, 0xac(%rsp)
callq 0x981ab0
movups (%rax), %xmm0
movaps... | /CodeGen/SelectionDAG/LegalizeDAG.cpp |
(anonymous namespace)::SelectionDAGLegalize::ExpandConstantFP(llvm::ConstantFPSDNode*, bool) | SDValue
SelectionDAGLegalize::ExpandConstantFP(ConstantFPSDNode *CFP, bool UseCP) {
bool Extend = false;
SDLoc dl(CFP);
// If a FP immediate is precise when represented as a float and if the
// target can do an extending load from float to double, we put it into
// the constant pool as a float, even if it's ... | subq $0x3b8, %rsp # imm = 0x3B8
movb %dl, %al
movq %rdi, 0x3a0(%rsp)
movq %rsi, 0x398(%rsp)
andb $0x1, %al
movb %al, 0x397(%rsp)
movq 0x3a0(%rsp), %rax
movq %rax, 0xc8(%rsp)
movb $0x0, 0x396(%rsp)
movq 0x398(%rsp), %rsi
leaq 0x380(%rsp), %rdi
callq 0x9817d0
movq 0x398(%rsp), %rdi
xorl %esi, %esi
callq 0x97c3... | /CodeGen/SelectionDAG/LegalizeDAG.cpp |
(anonymous namespace)::SelectionDAGLegalize::PromoteLegalINT_TO_FP(llvm::SDNode*, llvm::SDLoc const&, llvm::SmallVectorImpl<llvm::SDValue>&) | void SelectionDAGLegalize::PromoteLegalINT_TO_FP(
SDNode *N, const SDLoc &dl, SmallVectorImpl<SDValue> &Results) {
bool IsStrict = N->isStrictFPOpcode();
bool IsSigned = N->getOpcode() == ISD::SINT_TO_FP ||
N->getOpcode() == ISD::STRICT_SINT_TO_FP;
EVT DestVT = N->getValueType(0);
SDValue ... | subq $0x288, %rsp # imm = 0x288
movq %rdi, 0x280(%rsp)
movq %rsi, 0x278(%rsp)
movq %rdx, 0x270(%rsp)
movq %rcx, 0x268(%rsp)
movq 0x280(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x278(%rsp), %rdi
callq 0x9c2ef0
andb $0x1, %al
movb %al, 0x267(%rsp)
movq 0x278(%rsp), %rdi
callq 0x97c400
movl %eax, %ecx
movb $0x1, ... | /CodeGen/SelectionDAG/LegalizeDAG.cpp |
getCopyToParts(llvm::SelectionDAG&, llvm::SDLoc const&, llvm::SDValue, llvm::SDValue*, unsigned int, llvm::MVT, llvm::Value const*, std::optional<unsigned int>, llvm::ISD::NodeType) | static void
getCopyToParts(SelectionDAG &DAG, const SDLoc &DL, SDValue Val, SDValue *Parts,
unsigned NumParts, MVT PartVT, const Value *V,
std::optional<CallingConv::ID> CallConv = std::nullopt,
ISD::NodeType ExtendKind = ISD::ANY_EXTEND) {
// Let the target split the part... | pushq %rbx
subq $0x850, %rsp # imm = 0x850
movl %ecx, 0x12c(%rsp)
movq %rdx, %r10
movl 0x12c(%rsp), %edx
movl 0x878(%rsp), %eax
movq 0x870(%rsp), %rax
movq 0x868(%rsp), %rcx
movb 0x860(%rsp), %cl
movq %r10, 0x840(%rsp)
movl %edx, 0x848(%rsp)
movb %cl, 0x83f(%rsp)
movq %rax, 0x834(%rsp)
movq %rdi, 0x828(%rsp)... | /CodeGen/SelectionDAG/SelectionDAGBuilder.cpp |
llvm::SelectionDAGBuilder::visitPtrToInt(llvm::User const&) | void SelectionDAGBuilder::visitPtrToInt(const User &I) {
// What to do depends on the size of the integer and the size of the pointer.
// We can either truncate, zero extend, or no-op, accordingly.
SDValue N = getValue(I.getOperand(0));
auto &TLI = DAG.getTargetLoweringInfo();
EVT DestVT = DAG.getTargetLoweri... | subq $0x158, %rsp # imm = 0x158
movq %rdi, 0x150(%rsp)
movq %rsi, 0x148(%rsp)
movq 0x150(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x148(%rsp), %rdi
xorl %esi, %esi
movl %esi, 0x24(%rsp)
callq 0x78d3d0
movq 0x48(%rsp), %rdi
movq %rax, %rsi
callq 0x3f41670
movq %rax, %rcx
movq 0x48(%rsp), %rax
movl %edx, 0x130(%... | /CodeGen/SelectionDAG/SelectionDAGBuilder.cpp |
llvm::SelectionDAGBuilder::getValueImpl(llvm::Value const*) | SDValue SelectionDAGBuilder::getValueImpl(const Value *V) {
const TargetLowering &TLI = DAG.getTargetLoweringInfo();
if (const Constant *C = dyn_cast<Constant>(V)) {
EVT VT = TLI.getValueType(DAG.getDataLayout(), V->getType(), true);
if (const ConstantInt *CI = dyn_cast<ConstantInt>(C))
return DAG.g... | subq $0xdc8, %rsp # imm = 0xDC8
movq %rdi, 0xdb0(%rsp)
movq %rsi, 0xda8(%rsp)
movq 0xdb0(%rsp), %rax
movq %rax, 0x248(%rsp)
movq 0x340(%rax), %rdi
callq 0x9be570
movq %rax, 0xda0(%rsp)
movq 0xda8(%rsp), %rdi
callq 0x78d4d0
movq %rax, 0xd98(%rsp)
cmpq $0x0, 0xd98(%rsp)
je 0x3f433f1
movq 0x248(%rsp), %rax
movq... | /CodeGen/SelectionDAG/SelectionDAGBuilder.cpp |
llvm::SelectionDAGBuilder::addSuccessorWithProb(llvm::MachineBasicBlock*, llvm::MachineBasicBlock*, llvm::BranchProbability) | void SelectionDAGBuilder::addSuccessorWithProb(MachineBasicBlock *Src,
MachineBasicBlock *Dst,
BranchProbability Prob) {
if (!FuncInfo.BPI)
Src->addSuccessorWithoutProb(Dst);
else {
if (Prob.isUnknown())
Prob... | subq $0x38, %rsp
movl %ecx, 0x34(%rsp)
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x398(%rax), %rax
cmpq $0x0, 0x20(%rax)
jne 0x3f43f70
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x3373a40
jmp 0x3f43fbb
leaq 0x34(%rsp), %rdi
callq 0x13bda50
t... | /CodeGen/SelectionDAG/SelectionDAGBuilder.cpp |
llvm::detail::DenseMapPair<llvm::AllocaInst const*, findArgumentCopyElisionCandidates(llvm::DataLayout const&, llvm::FunctionLoweringInfo*, llvm::DenseMap<llvm::Argument const*, std::pair<llvm::AllocaInst const*, llvm::StoreInst const*>, llvm::DenseMapInfo<llvm::Argument const*, void>, llvm::detail::DenseMapPair<llvm::... | 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 0x3f98dd0
movq 0x10(%rsp), %rdi
addl $0x1, %eax
movl %eax, 0x24(%rsp)
callq 0x3f986a0
movl %eax, 0x20(%rsp)
movl 0x24(%rsp), %ea... | /llvm/ADT/DenseMap.h |
llvm::DenseMapIterator<llvm::Argument const*, std::pair<llvm::AllocaInst const*, llvm::StoreInst const*>, llvm::DenseMapInfo<llvm::Argument const*, void>, llvm::detail::DenseMapPair<llvm::Argument const*, std::pair<llvm::AllocaInst const*, llvm::StoreInst const*>>, false>::DenseMapIterator(llvm::detail::DenseMapPair<ll... | 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::DenseMapBase<llvm::SmallDenseMap<llvm::AllocaInst const*, findArgumentCopyElisionCandidates(llvm::DataLayout const&, llvm::FunctionLoweringInfo*, llvm::DenseMap<llvm::Argument const*, std::pair<llvm::AllocaInst const*, llvm::StoreInst const*>, llvm::DenseMapInfo<llvm::Argument const*, void>, llvm::detail::DenseMa... | 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 0x3f986a0
cmpl $0x0, %eax
jne 0x3f9a2d2
jmp 0x3f9a36a
callq 0x3f98570
movq %rax, 0x28(%rsp)
callq 0x3f98a10
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
callq 0x3f98580
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x3f98590
movq %... | /llvm/ADT/DenseMap.h |
llvm::SDDbgInfo::erase(llvm::SDNode const*) | void SDDbgInfo::erase(const SDNode *Node) {
DbgValMapType::iterator I = DbgValMap.find(Node);
if (I == DbgValMap.end())
return;
for (auto &Val: I->second)
Val->setIsInvalidated();
DbgValMap.erase(I);
} | subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x2b0, %rdi # imm = 0x2B0
movq 0x58(%rsp), %rsi
callq 0x3faf160
movq (%rsp), %rdi
movq %rax, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
addq $0x2b0, %rdi # imm = 0x2B0
callq 0x3faf230
movq %rax, 0x38(%... | /CodeGen/SelectionDAG/SelectionDAG.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::SDNode const*, llvm::SmallVector<llvm::SDDbgValue*, 2u>, llvm::DenseMapInfo<llvm::SDNode const*, void>, llvm::detail::DenseMapPair<llvm::SDNode const*, llvm::SmallVector<llvm::SDDbgValue*, 2u>>>, llvm::SDNode const*, llvm::SmallVector<llvm::SDDbgValue*, 2u>, llvm::DenseMapInfo<ll... | 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 0x400dbb0
testb $0x1, %al
jne 0x3faf18d
jmp 0x3faf1eb
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x400ac30
testb $0x1, %al
jne 0x3faf1a2
jmp 0x3faf1b3
movq 0x... | /llvm/ADT/DenseMap.h |
llvm::SelectionDAG::FindModifiedNodeSlot(llvm::SDNode*, llvm::ArrayRef<llvm::SDValue>, void*&) | SDNode *SelectionDAG::FindModifiedNodeSlot(SDNode *N, ArrayRef<SDValue> Ops,
void *&InsertPos) {
if (doNotCSE(N))
return nullptr;
FoldingSetNodeID ID;
AddNodeIDNode(ID, N->getOpcode(), N->getVTList(), Ops);
AddNodeIDCustom(ID, N);
SDNode *Node = FindNodeOrInsert... | subq $0x128, %rsp # imm = 0x128
movq %rdx, 0x110(%rsp)
movq %rcx, 0x118(%rsp)
movq %rdi, 0x108(%rsp)
movq %rsi, 0x100(%rsp)
movq %r8, 0xf8(%rsp)
movq 0x108(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x100(%rsp), %rdi
callq 0x3faf950
testb $0x1, %al
jne 0x3fb17ff
jmp 0x3fb1810
movq $0x0, 0x120(%rsp)
jmp 0x3fb191f... | /CodeGen/SelectionDAG/SelectionDAG.cpp |
llvm::SelectionDAG::getFPExtendOrRound(llvm::SDValue, llvm::SDLoc const&, llvm::EVT) | SDValue SelectionDAG::getFPExtendOrRound(SDValue Op, const SDLoc &DL, EVT VT) {
return VT.bitsGT(Op.getValueType())
? getNode(ISD::FP_EXTEND, DL, VT, Op)
: getNode(ISD::FP_ROUND, DL, VT, Op,
getIntPtrConstant(0, DL, /*isTarget=*/true));
} | subq $0x108, %rsp # imm = 0x108
movb %r8b, %al
movq %rsi, 0xe8(%rsp)
movl %edx, 0xf0(%rsp)
movb %al, 0xd8(%rsp)
movq %r9, 0xe0(%rsp)
movq %rdi, 0xd0(%rsp)
movq %rcx, 0xc8(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0xe8(%rsp), %rdi
callq 0x98a410
movb %al, 0xb8(%rsp)
movq %rdx, 0xc0(%rsp)
movb 0xb... | /CodeGen/SelectionDAG/SelectionDAG.cpp |
llvm::SelectionDAG::getVPZeroExtendInReg(llvm::SDValue, llvm::SDValue, llvm::SDValue, llvm::SDLoc const&, llvm::EVT) | SDValue SelectionDAG::getVPZeroExtendInReg(SDValue Op, SDValue Mask,
SDValue EVL, const SDLoc &DL,
EVT VT) {
EVT OpVT = Op.getValueType();
assert(VT.isInteger() && OpVT.isInteger() &&
"Cannot getVPZeroExtendInReg FP types... | subq $0x168, %rsp # imm = 0x168
leaq 0x180(%rsp), %rax
movq %rax, 0x68(%rsp)
leaq 0x170(%rsp), %rax
movq %rax, 0x58(%rsp)
movq %rsi, 0x148(%rsp)
movl %edx, 0x150(%rsp)
movq %rcx, 0x138(%rsp)
movl %r8d, 0x140(%rsp)
movq %rdi, 0x130(%rsp)
movq %r9, 0x128(%rsp)
movq 0x130(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq ... | /CodeGen/SelectionDAG/SelectionDAG.cpp |
llvm::SelectionDAG::getCondCode(llvm::ISD::CondCode) | SDValue SelectionDAG::getCondCode(ISD::CondCode Cond) {
if ((unsigned)Cond >= CondCodeNodes.size())
CondCodeNodes.resize(Cond+1);
if (!CondCodeNodes[Cond]) {
auto *N = newSDNode<CondCodeSDNode>(Cond);
CondCodeNodes[Cond] = N;
InsertNode(N);
}
return SDValue(CondCodeNodes[Cond], 0);
} | subq $0x48, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl 0x2c(%rsp), %eax
movq %rax, 0x18(%rsp)
addq $0x2b8, %rdi # imm = 0x2B8
callq 0x3fb9130
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jb 0x3fb9084
movq 0x10(%rsp), %rdi
addq $0x2b8, %rdi ... | /CodeGen/SelectionDAG/SelectionDAG.cpp |
llvm::SelectionDAG::isSplatValue(llvm::SDValue, bool) const | bool SelectionDAG::isSplatValue(SDValue V, bool AllowUndefs) const {
EVT VT = V.getValueType();
assert(VT.isVector() && "Vector type expected");
APInt UndefElts;
// Since the number of lanes in a scalable vector is unknown at compile time,
// we track one bit which is implicitly broadcast to all lanes. This... | subq $0x78, %rsp
movb %cl, %al
movq %rsi, 0x68(%rsp)
movl %edx, 0x70(%rsp)
movq %rdi, 0x60(%rsp)
andb $0x1, %al
movb %al, 0x5f(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x98a410
movb %al, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x40b580
leaq 0x48(%rsp), %rdi
call... | /CodeGen/SelectionDAG/SelectionDAG.cpp |
llvm::SelectionDAG::isEqualTo(llvm::SDValue, llvm::SDValue) const | bool SelectionDAG::isEqualTo(SDValue A, SDValue B) const {
// Check the obvious case.
if (A == B) return true;
// For negative and positive zero.
if (const ConstantFPSDNode *CA = dyn_cast<ConstantFPSDNode>(A))
if (const ConstantFPSDNode *CB = dyn_cast<ConstantFPSDNode>(B))
if (CA->isZero() && CB->isZ... | subq $0x48, %rsp
movq %rsi, 0x30(%rsp)
movl %edx, 0x38(%rsp)
movq %rcx, 0x20(%rsp)
movl %r8d, 0x28(%rsp)
movq %rdi, 0x18(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x990580
testb $0x1, %al
jne 0x3fd2391
jmp 0x3fd2398
movb $0x1, 0x47(%rsp)
jmp 0x3fd23f6
leaq 0x30(%rsp), %rdi
callq 0x9a1e90
movq %rax, 0x10(%... | /CodeGen/SelectionDAG/SelectionDAG.cpp |
llvm::SelectionDAG::ReplaceAllUsesOfValueWith(llvm::SDValue, llvm::SDValue) | void SelectionDAG::ReplaceAllUsesOfValueWith(SDValue From, SDValue To){
// Handle the really simple, really trivial case efficiently.
if (From == To) return;
// Handle the simple, trivial, case efficiently.
if (From.getNode()->getNumValues() == 1) {
ReplaceAllUsesWith(From, To);
return;
}
// Prese... | subq $0xf8, %rsp
movq %rsi, 0xe8(%rsp)
movl %edx, 0xf0(%rsp)
movq %rcx, 0xd8(%rsp)
movl %r8d, 0xe0(%rsp)
movq %rdi, 0xd0(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0xe8(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
callq 0x990580
testb $0x1, %al
jne 0x3ff9b16
jmp 0x3ff9b1b
jmp 0x3ff9e71
leaq 0xe8(%rsp), %rdi
callq 0x98... | /CodeGen/SelectionDAG/SelectionDAG.cpp |
llvm::SelectionDAG::UnrollVectorOp(llvm::SDNode*, unsigned int) | SDValue SelectionDAG::UnrollVectorOp(SDNode *N, unsigned ResNE) {
EVT VT = N->getValueType(0);
EVT EltVT = VT.getVectorElementType();
unsigned NE = VT.getVectorNumElements();
SDLoc dl(N);
// If ResNE is 0, fully unroll the vector op.
if (ResNE == 0)
ResNE = NE;
else if (NE > ResNE)
NE = ResNE;
... | subq $0x838, %rsp # imm = 0x838
movq %rdi, 0x820(%rsp)
movq %rsi, 0x818(%rsp)
movl %edx, 0x814(%rsp)
movq 0x820(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x818(%rsp), %rdi
xorl %esi, %esi
callq 0x97c3d0
movb %al, 0x800(%rsp)
movq %rdx, 0x808(%rsp)
leaq 0x800(%rsp), %rdi
callq 0x7afe50
movb %al, 0x7f0(%rsp)
movq... | /CodeGen/SelectionDAG/SelectionDAG.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::MCSymbol*, llvm::SDNode*, llvm::DenseMapInfo<llvm::MCSymbol*, void>, llvm::detail::DenseMapPair<llvm::MCSymbol*, llvm::SDNode*>>, llvm::MCSymbol*, llvm::SDNode*, llvm::DenseMapInfo<llvm::MCSymbol*, void>, llvm::detail::DenseMapPair<llvm::MCSymbol*, llvm::SDNode*>>::moveFromOldBuc... | 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 0x4010440
callq 0x400f740
movq %rax, 0x48(%rsp)
callq 0x400f500
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::MCSymbolSDNode* llvm::Recycler<llvm::SDNode, 112ul, 8ul>::Allocate<llvm::MCSymbolSDNode, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul, 128ul>>(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul, 128ul>&) | SubClass *Allocate(AllocatorType &Allocator) {
static_assert(alignof(SubClass) <= Align,
"Recycler allocation alignment is less than object align!");
static_assert(sizeof(SubClass) <= Size,
"Recycler allocation size is less than object size!");
return FreeList ? reinterpr... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, (%rax)
je 0x401352f
movq 0x10(%rsp), %rdi
callq 0x4010e60
movq %rax, 0x8(%rsp)
jmp 0x4013548
movq 0x18(%rsp), %rdi
movl $0x70, %esi
movl $0x8, %edx
callq 0x6f1470
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax... | /llvm/Support/Recycler.h |
llvm::AtomicSDNode* llvm::Recycler<llvm::SDNode, 112ul, 8ul>::Allocate<llvm::AtomicSDNode, llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul, 128ul>>(llvm::BumpPtrAllocatorImpl<llvm::MallocAllocator, 4096ul, 4096ul, 128ul>&) | SubClass *Allocate(AllocatorType &Allocator) {
static_assert(alignof(SubClass) <= Align,
"Recycler allocation alignment is less than object align!");
static_assert(sizeof(SubClass) <= Size,
"Recycler allocation size is less than object size!");
return FreeList ? reinterpr... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, (%rax)
je 0x4017ddf
movq 0x10(%rsp), %rdi
callq 0x4010e60
movq %rax, 0x8(%rsp)
jmp 0x4017df8
movq 0x18(%rsp), %rdi
movl $0x70, %esi
movl $0x8, %edx
callq 0x6f1470
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax... | /llvm/Support/Recycler.h |
llvm::TargetLowering::buildLegalVectorShuffle(llvm::EVT, llvm::SDLoc const&, llvm::SDValue, llvm::SDValue, llvm::MutableArrayRef<int>, llvm::SelectionDAG&) const | SDValue
TargetLowering::buildLegalVectorShuffle(EVT VT, const SDLoc &DL, SDValue N0,
SDValue N1, MutableArrayRef<int> Mask,
SelectionDAG &DAG) const {
bool LegalMask = isShuffleMaskLegal(Mask, VT);
if (!LegalMask) {
std::swap(N0, N1... | subq $0x128, %rsp # imm = 0x128
movq 0x150(%rsp), %rax
leaq 0x140(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x130(%rsp), %r10
movq %r10, 0x30(%rsp)
movb %sil, 0x108(%rsp)
movq %rdx, 0x110(%rsp)
movq %r8, 0xf8(%rsp)
movl %r9d, 0x100(%rsp)
movq %rdi, 0xf0(%rsp)
movq %rcx, 0xe8(%rsp)
movq 0xf0(%rsp), %rdi
movq %rd... | /CodeGen/SelectionDAG/TargetLowering.cpp |
llvm::DenseMapIterator<unsigned int, llvm::SDValue, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::SDValue>, 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, 0x10(%rsp)
callq 0x5479c0
movl %eax, 0x1c(%rsp)
callq 0x5480c0
movl %eax, 0x18(%rsp)
movq 0x10(%rsp), %rdx
movq (%rdx), %rcx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, 0xf(%rsp)
je 0x40e39a6
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0xac5fa... | /llvm/ADT/DenseMap.h |
llvm::SmallDenseMap<llvm::SDValue, unsigned int, 8u, llvm::DenseMapInfo<llvm::SDValue, void>, llvm::detail::DenseMapPair<llvm::SDValue, unsigned int>>::grow(unsigned int) | void grow(unsigned AtLeast) {
if (AtLeast > InlineBuckets)
AtLeast = std::max<unsigned>(64, NextPowerOf2(AtLeast-1));
if (Small) {
// First move the inline buckets into a temporary storage.
AlignedCharArrayUnion<BucketT[InlineBuckets]> TmpStorage;
BucketT *TmpBegin = reinterpret_cast<Bu... | subq $0x178, %rsp # imm = 0x178
movq %rdi, 0x170(%rsp)
movl %esi, 0x16c(%rsp)
movq 0x170(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpl $0x8, 0x16c(%rsp)
jbe 0x40e4500
movl $0x40, 0x168(%rsp)
movl 0x16c(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x5487c0
movl %eax, 0x164(%rsp)
leaq 0x168(%rsp)... | /llvm/ADT/DenseMap.h |
std::pair<llvm::DenseMapIterator<llvm::SDValue, llvm::SDValue, llvm::DenseMapInfo<llvm::SDValue, void>, llvm::detail::DenseMapPair<llvm::SDValue, llvm::SDValue>, false>, bool> llvm::DenseMapBase<llvm::SmallDenseMap<llvm::SDValue, llvm::SDValue, 64u, llvm::DenseMapInfo<llvm::SDValue, void>, llvm::detail::DenseMapPair<ll... | std::pair<iterator, bool> try_emplace(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 0x40f57a0
testb $0x1, %al
jne 0x40f6425
jmp 0x40f649f
movq 0x68(%rsp), %rax
movq %rax, 0x18(%rsp)
c... | /llvm/ADT/DenseMap.h |
llvm::SmallDenseMap<llvm::SDValue, llvm::SDValue, 64u, llvm::DenseMapInfo<llvm::SDValue, void>, llvm::detail::DenseMapPair<llvm::SDValue, llvm::SDValue>>::grow(unsigned int) | void grow(unsigned AtLeast) {
if (AtLeast > InlineBuckets)
AtLeast = std::max<unsigned>(64, NextPowerOf2(AtLeast-1));
if (Small) {
// First move the inline buckets into a temporary storage.
AlignedCharArrayUnion<BucketT[InlineBuckets]> TmpStorage;
BucketT *TmpBegin = reinterpret_cast<Bu... | subq $0x8b8, %rsp # imm = 0x8B8
movq %rdi, 0x8b0(%rsp)
movl %esi, 0x8ac(%rsp)
movq 0x8b0(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpl $0x40, 0x8ac(%rsp)
jbe 0x40f6890
movl $0x40, 0x8a8(%rsp)
movl 0x8ac(%rsp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x5487c0
movl %eax, 0x8a4(%rsp)
leaq 0x8a8(%rsp... | /llvm/ADT/DenseMap.h |
llvm::DAGTypeLegalizer::ScalarizeVecRes_VecInregOp(llvm::SDNode*) | SDValue DAGTypeLegalizer::ScalarizeVecRes_VecInregOp(SDNode *N) {
SDLoc DL(N);
SDValue Op = N->getOperand(0);
EVT OpVT = Op.getValueType();
EVT OpEltVT = OpVT.getVectorElementType();
EVT EltVT = N->getValueType(0).getVectorElementType();
if (getTypeAction(OpVT) == TargetLowering::TypeScalarizeVector) {
... | subq $0x208, %rsp # imm = 0x208
movq %rdi, 0x1f0(%rsp)
movq %rsi, 0x1e8(%rsp)
movq 0x1f0(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x1e8(%rsp), %rsi
leaq 0x1d8(%rsp), %rdi
callq 0x9817d0
movq 0x1e8(%rsp), %rdi
xorl %esi, %esi
callq 0x981ab0
movq (%rax), %rcx
movq %rcx, 0x1c8(%rsp)
movq 0x8(%rax), %rax
movq %rax... | /CodeGen/SelectionDAG/LegalizeVectorTypes.cpp |
llvm::DAGTypeLegalizer::ScalarizeVecRes_ADDRSPACECAST(llvm::SDNode*) | SDValue DAGTypeLegalizer::ScalarizeVecRes_ADDRSPACECAST(SDNode *N) {
EVT DestVT = N->getValueType(0).getVectorElementType();
SDValue Op = N->getOperand(0);
EVT OpVT = Op.getValueType();
SDLoc DL(N);
// The result needs scalarizing, but it's not a given that the source does.
// This is a workaround for targe... | subq $0x1a8, %rsp # imm = 0x1A8
movq %rdi, 0x190(%rsp)
movq %rsi, 0x188(%rsp)
movq 0x190(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x188(%rsp), %rdi
xorl %esi, %esi
callq 0x97c3d0
movb %al, 0x168(%rsp)
movq %rdx, 0x170(%rsp)
leaq 0x168(%rsp), %rdi
callq 0x7afe50
movb %al, 0x178(%rsp)
movq %rdx, 0x180(%rsp)
movq... | /CodeGen/SelectionDAG/LegalizeVectorTypes.cpp |
llvm::DAGTypeLegalizer::SplitVecRes_CONCAT_VECTORS(llvm::SDNode*, llvm::SDValue&, llvm::SDValue&) | void DAGTypeLegalizer::SplitVecRes_CONCAT_VECTORS(SDNode *N, SDValue &Lo,
SDValue &Hi) {
assert(!(N->getNumOperands() & 1) && "Unsupported CONCAT_VECTORS");
SDLoc dl(N);
unsigned NumSubvectors = N->getNumOperands() / 2;
if (NumSubvectors == 1) {
Lo = N->getO... | subq $0x2b8, %rsp # imm = 0x2B8
movq %rdi, 0x2b0(%rsp)
movq %rsi, 0x2a8(%rsp)
movq %rdx, 0x2a0(%rsp)
movq %rcx, 0x298(%rsp)
movq 0x2b0(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x2a8(%rsp), %rsi
leaq 0x288(%rsp), %rdi
callq 0x9817d0
movq 0x2a8(%rsp), %rdi
callq 0x988ce0
shrl %eax
movl %eax, 0x284(%rsp)
cmpl $0x... | /CodeGen/SelectionDAG/LegalizeVectorTypes.cpp |
llvm::DAGTypeLegalizer::WidenVectorResult(llvm::SDNode*, unsigned int) | void DAGTypeLegalizer::WidenVectorResult(SDNode *N, unsigned ResNo) {
LLVM_DEBUG(dbgs() << "Widen node result " << ResNo << ": "; N->dump(&DAG));
// See if the target wants to custom widen this node.
if (CustomWidenLowerNode(N, N->getValueType(ResNo)))
return;
SDValue Res = SDValue();
auto unrollExpand... | subq $0x578, %rsp # imm = 0x578
movq %rdi, 0x570(%rsp)
movq %rsi, 0x568(%rsp)
movl %edx, 0x564(%rsp)
movq 0x570(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x412d1cd
movq 0x568(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x568(%rsp), %rdi
movl 0x564(%rsp), %esi
callq 0x97c3d0
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi... | /CodeGen/SelectionDAG/LegalizeVectorTypes.cpp |
llvm::DAGTypeLegalizer::WidenVecRes_BITCAST(llvm::SDNode*) | SDValue DAGTypeLegalizer::WidenVecRes_BITCAST(SDNode *N) {
SDValue InOp = N->getOperand(0);
EVT InVT = InOp.getValueType();
EVT VT = N->getValueType(0);
EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
SDLoc dl(N);
switch (getTypeAction(InVT)) {
case TargetLowering::TypeLegal:
break;
... | subq $0x868, %rsp # imm = 0x868
movq %rdi, 0x850(%rsp)
movq %rsi, 0x848(%rsp)
movq 0x850(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0x848(%rsp), %rdi
xorl %esi, %esi
movl %esi, 0xa4(%rsp)
callq 0x981ab0
movups (%rax), %xmm0
movaps %xmm0, 0x830(%rsp)
leaq 0x830(%rsp), %rdi
callq 0x98a410
movl 0xa4(%rsp), %esi
mov... | /CodeGen/SelectionDAG/LegalizeVectorTypes.cpp |
llvm::DAGTypeLegalizer::WidenVecRes_CONCAT_VECTORS(llvm::SDNode*) | SDValue DAGTypeLegalizer::WidenVecRes_CONCAT_VECTORS(SDNode *N) {
EVT InVT = N->getOperand(0).getValueType();
EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
SDLoc dl(N);
unsigned NumOperands = N->getNumOperands();
bool InputWidened = false; // Indicates we need to widen the in... | subq $0x608, %rsp # imm = 0x608
movq %rdi, 0x5f0(%rsp)
movq %rsi, 0x5e8(%rsp)
movq 0x5f0(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x5e8(%rsp), %rdi
xorl %esi, %esi
callq 0x981ab0
movq %rax, %rdi
callq 0x98a410
movb %al, %cl
movq 0x78(%rsp), %rax
movb %cl, 0x5d8(%rsp)
movq %rdx, 0x5e0(%rsp)
movq (%rax), %rcx
mo... | /CodeGen/SelectionDAG/LegalizeVectorTypes.cpp |
llvm::DAGTypeLegalizer::WidenVecRes_VECTOR_SHUFFLE(llvm::ShuffleVectorSDNode*) | SDValue DAGTypeLegalizer::WidenVecRes_VECTOR_SHUFFLE(ShuffleVectorSDNode *N) {
EVT VT = N->getValueType(0);
SDLoc dl(N);
EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
unsigned NumElts = VT.getVectorNumElements();
unsigned WidenNumElts = WidenVT.getVectorNumElements();
SDValue InOp1 = GetW... | subq $0x1d8, %rsp # imm = 0x1D8
movq %rdi, 0x1c0(%rsp)
movq %rsi, 0x1b8(%rsp)
movq 0x1c0(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x1b8(%rsp), %rdi
xorl %esi, %esi
movl %esi, 0x44(%rsp)
callq 0x97c3d0
movb %al, 0x1a8(%rsp)
movq %rdx, 0x1b0(%rsp)
movq 0x1b8(%rsp), %rsi
leaq 0x198(%rsp), %rdi
callq 0x9817d0
movq... | /CodeGen/SelectionDAG/LegalizeVectorTypes.cpp |
llvm::DAGTypeLegalizer::WidenVecRes_VP_LOAD(llvm::VPLoadSDNode*) | SDValue DAGTypeLegalizer::WidenVecRes_VP_LOAD(VPLoadSDNode *N) {
EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
SDValue Mask = N->getMask();
SDValue EVL = N->getVectorLength();
ISD::LoadExtType ExtType = N->getExtensionType();
SDLoc dl(N);
// The mask should be widened as we... | subq $0x218, %rsp # imm = 0x218
movq %rdi, 0x200(%rsp)
movq %rsi, 0x1f8(%rsp)
movq 0x200(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq (%rax), %rcx
movq %rcx, 0x70(%rsp)
movq 0x8(%rax), %rdi
callq 0x995030
movq %rax, 0x78(%rsp)
movq 0x1f8(%rsp), %rdi
xorl %esi, %esi
callq 0x97c3d0
movq 0x70(%rsp), %rdi
movq 0x78(%r... | /CodeGen/SelectionDAG/LegalizeVectorTypes.cpp |
llvm::DAGTypeLegalizer::WidenVecRes_VP_STRIDED_LOAD(llvm::VPStridedLoadSDNode*) | SDValue DAGTypeLegalizer::WidenVecRes_VP_STRIDED_LOAD(VPStridedLoadSDNode *N) {
SDLoc DL(N);
// The mask should be widened as well
SDValue Mask = N->getMask();
assert(getTypeAction(Mask.getValueType()) ==
TargetLowering::TypeWidenVector &&
"Unable to widen VP strided load");
Mask = GetW... | subq $0x218, %rsp # imm = 0x218
movq %rdi, 0x200(%rsp)
movq %rsi, 0x1f8(%rsp)
movq 0x200(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0x1f8(%rsp), %rsi
leaq 0x1e8(%rsp), %rdi
movq %rdi, 0xb8(%rsp)
callq 0x9817d0
movq 0x1f8(%rsp), %rdi
callq 0x1d4a4d0
movq 0xb0(%rsp), %rdi
movups (%rax), %xmm0
movaps %xmm0, 0x1d0(%... | /CodeGen/SelectionDAG/LegalizeVectorTypes.cpp |
llvm::DAGTypeLegalizer::WidenVecRes_BinaryCanTrap(llvm::SDNode*) | SDValue DAGTypeLegalizer::WidenVecRes_BinaryCanTrap(SDNode *N) {
// Binary op widening for operations that can trap.
unsigned Opcode = N->getOpcode();
SDLoc dl(N);
EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
EVT WidenEltVT = WidenVT.getVectorElementType();
EVT VT = WidenVT... | subq $0x698, %rsp # imm = 0x698
movq %rdi, 0x680(%rsp)
movq %rsi, 0x678(%rsp)
movq 0x680(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0x678(%rsp), %rdi
callq 0x97c400
movl %eax, 0x674(%rsp)
movq 0x678(%rsp), %rsi
leaq 0x660(%rsp), %rdi
callq 0x9817d0
movq 0xa8(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0xb0(%rsp)
mo... | /CodeGen/SelectionDAG/LegalizeVectorTypes.cpp |
llvm::DAGTypeLegalizer::WidenVecRes_Unary(llvm::SDNode*) | SDValue DAGTypeLegalizer::WidenVecRes_Unary(SDNode *N) {
// Unary op widening.
EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
SDValue InOp = GetWidenedVector(N->getOperand(0));
if (N->getNumOperands() == 1)
return DAG.getNode(N->getOpcode(), SDLoc(N), WidenVT, InOp, N->getFla... | subq $0x1e8, %rsp # imm = 0x1E8
movq %rdi, 0x1d0(%rsp)
movq %rsi, 0x1c8(%rsp)
movq 0x1d0(%rsp), %rax
movq %rax, 0x58(%rsp)
movq (%rax), %rcx
movq %rcx, 0x40(%rsp)
movq 0x8(%rax), %rdi
callq 0x995030
movq %rax, 0x48(%rsp)
movq 0x1c8(%rsp), %rdi
xorl %esi, %esi
movl %esi, 0x54(%rsp)
callq 0x97c3d0
movq 0x40(%r... | /CodeGen/SelectionDAG/LegalizeVectorTypes.cpp |
llvm::DAGTypeLegalizer::WidenVecRes_Convert_StrictFP(llvm::SDNode*) | SDValue DAGTypeLegalizer::WidenVecRes_Convert_StrictFP(SDNode *N) {
SDValue InOp = N->getOperand(1);
SDLoc DL(N);
SmallVector<SDValue, 4> NewOps(N->op_begin(), N->op_end());
EVT WidenVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
unsigned WidenNumElts = WidenVT.getVectorNumElements();
... | subq $0x698, %rsp # imm = 0x698
movq %rdi, 0x680(%rsp)
movq %rsi, 0x678(%rsp)
movq 0x680(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0x678(%rsp), %rdi
movl $0x1, %esi
movl %esi, 0xac(%rsp)
callq 0x981ab0
movups (%rax), %xmm0
movaps %xmm0, 0x660(%rsp)
movq 0x678(%rsp), %rsi
leaq 0x650(%rsp), %rdi
callq 0x9817d0
mo... | /CodeGen/SelectionDAG/LegalizeVectorTypes.cpp |
llvm::DAGTypeLegalizer::GenWidenVectorLoads(llvm::SmallVectorImpl<llvm::SDValue>&, llvm::LoadSDNode*) | SDValue DAGTypeLegalizer::GenWidenVectorLoads(SmallVectorImpl<SDValue> &LdChain,
LoadSDNode *LD) {
// The strategy assumes that we can efficiently load power-of-two widths.
// The routine chops the vector into the largest vector loads with the same
// element type or ... | subq $0xe88, %rsp # imm = 0xE88
movq %rdi, 0xe70(%rsp)
movq %rsi, 0xe68(%rsp)
movq %rdx, 0xe60(%rsp)
movq 0xe70(%rsp), %rax
movq %rax, 0x128(%rsp)
movq (%rax), %rcx
movq %rcx, 0x130(%rsp)
movq 0x8(%rax), %rdi
callq 0x995030
movq %rax, 0x138(%rsp)
movq 0xe60(%rsp), %rdi
xorl %esi, %esi
callq 0x97c3d0
movq 0x1... | /CodeGen/SelectionDAG/LegalizeVectorTypes.cpp |
llvm::DAGTypeLegalizer::WidenVecOp_VP_SCATTER(llvm::SDNode*, unsigned int) | SDValue DAGTypeLegalizer::WidenVecOp_VP_SCATTER(SDNode *N, unsigned OpNo) {
VPScatterSDNode *VPSC = cast<VPScatterSDNode>(N);
SDValue DataOp = VPSC->getValue();
SDValue Mask = VPSC->getMask();
SDValue Index = VPSC->getIndex();
SDValue Scale = VPSC->getScale();
EVT WideMemVT = VPSC->getMemoryVT();
if (OpN... | subq $0x2c8, %rsp # imm = 0x2C8
movq %rdi, 0x2b0(%rsp)
movq %rsi, 0x2a8(%rsp)
movl %edx, 0x2a4(%rsp)
movq 0x2b0(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x2a8(%rsp), %rdi
callq 0x1d6a3e0
movq %rax, 0x298(%rsp)
movq 0x298(%rsp), %rdi
callq 0x1d4a6e0
movq (%rax), %rcx
movq %rcx, 0x288(%rsp)
movq 0x8(%rax), %rax
... | /CodeGen/SelectionDAG/LegalizeVectorTypes.cpp |
llvm::DAGTypeLegalizer::WidenVecOp_SETCC(llvm::SDNode*) | SDValue DAGTypeLegalizer::WidenVecOp_SETCC(SDNode *N) {
SDValue InOp0 = GetWidenedVector(N->getOperand(0));
SDValue InOp1 = GetWidenedVector(N->getOperand(1));
SDLoc dl(N);
EVT VT = N->getValueType(0);
// WARNING: In this code we widen the compare instruction with garbage.
// This garbage may contain denor... | subq $0x2e8, %rsp # imm = 0x2E8
movq %rdi, 0x2d0(%rsp)
movq %rsi, 0x2c8(%rsp)
movq 0x2d0(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x2c8(%rsp), %rdi
xorl %esi, %esi
callq 0x981ab0
movq 0x68(%rsp), %rdi
movups (%rax), %xmm0
movaps %xmm0, 0x2a0(%rsp)
movq 0x2a0(%rsp), %rsi
movl 0x2a8(%rsp), %edx
callq 0x413d0f0
m... | /CodeGen/SelectionDAG/LegalizeVectorTypes.cpp |
llvm::DAGTypeLegalizer::WidenVecOp_IS_FPCLASS(llvm::SDNode*) | SDValue DAGTypeLegalizer::WidenVecOp_IS_FPCLASS(SDNode *N) {
SDLoc DL(N);
EVT ResultVT = N->getValueType(0);
SDValue Test = N->getOperand(1);
SDValue WideArg = GetWidenedVector(N->getOperand(0));
// Process this node similarly to SETCC.
EVT WideResultVT = getSetCCResultType(WideArg.getValueType());
if (R... | subq $0x2a8, %rsp # imm = 0x2A8
movq %rdi, 0x290(%rsp)
movq %rsi, 0x288(%rsp)
movq 0x290(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x288(%rsp), %rsi
leaq 0x278(%rsp), %rdi
callq 0x9817d0
movq 0x288(%rsp), %rdi
xorl %esi, %esi
movl %esi, 0x54(%rsp)
callq 0x97c3d0
movb %al, 0x268(%rsp)
movq %rdx, 0x270(%rsp)
movq... | /CodeGen/SelectionDAG/LegalizeVectorTypes.cpp |
llvm::DAGTypeLegalizer::WidenVecOp_EXTEND(llvm::SDNode*) | SDValue DAGTypeLegalizer::WidenVecOp_EXTEND(SDNode *N) {
SDLoc DL(N);
EVT VT = N->getValueType(0);
SDValue InOp = N->getOperand(0);
assert(getTypeAction(InOp.getValueType()) ==
TargetLowering::TypeWidenVector &&
"Unexpected type action");
InOp = GetWidenedVector(InOp);
assert(VT.getVe... | subq $0x3f8, %rsp # imm = 0x3F8
movq %rdi, 0x3e0(%rsp)
movq %rsi, 0x3d8(%rsp)
movq 0x3e0(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x3d8(%rsp), %rsi
leaq 0x3c8(%rsp), %rdi
callq 0x9817d0
movq 0x3d8(%rsp), %rdi
xorl %esi, %esi
movl %esi, 0x64(%rsp)
callq 0x97c3d0
movl 0x64(%rsp), %esi
movb %al, 0x3b8(%rsp)
movq ... | /CodeGen/SelectionDAG/LegalizeVectorTypes.cpp |
findMemType(llvm::SelectionDAG&, llvm::TargetLowering const&, unsigned int, llvm::EVT, unsigned int, unsigned int) | static std::optional<EVT> findMemType(SelectionDAG &DAG,
const TargetLowering &TLI, unsigned Width,
EVT WidenVT, unsigned Align = 0,
unsigned WidenEx = 0) {
EVT WidenEltVT = WidenVT.getVectorElementType()... | subq $0x238, %rsp # imm = 0x238
movq %rdi, 0x28(%rsp)
movb %r8b, %al
movq %rdi, 0x30(%rsp)
movl 0x248(%rsp), %edi
movl 0x240(%rsp), %edi
movb %al, 0x228(%rsp)
movq %r9, 0x230(%rsp)
movq %rsi, 0x220(%rsp)
movq %rdx, 0x218(%rsp)
movl %ecx, 0x214(%rsp)
leaq 0x228(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x7afe50... | /CodeGen/SelectionDAG/LegalizeVectorTypes.cpp |
llvm::detail::DenseMapPair<std::pair<llvm::SDValue, llvm::SDValue>, unsigned int>* llvm::DenseMapBase<llvm::DenseMap<std::pair<llvm::SDValue, llvm::SDValue>, unsigned int, llvm::DenseMapInfo<std::pair<llvm::SDValue, llvm::SDValue>, void>, llvm::detail::DenseMapPair<std::pair<llvm::SDValue, llvm::SDValue>, unsigned int>... | 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 $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x548460
movq 0x8(%rsp), %rdi
callq 0x4151090
movq 0x8(%rsp), %rdi
addl $0x1, %eax
movl %eax, 0x34(%rsp)
callq 0x4150340
movl %eax, 0x30(%rsp)
movl 0x34(%rsp), %eax
s... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<std::pair<llvm::SDValue, llvm::SDValue>, unsigned int, llvm::DenseMapInfo<std::pair<llvm::SDValue, llvm::SDValue>, void>, llvm::detail::DenseMapPair<std::pair<llvm::SDValue, llvm::SDValue>, unsigned int>>, std::pair<llvm::SDValue, llvm::SDValue>, unsigned int, llvm::DenseMapInfo<std::p... | 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 $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x90(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x4150120
leaq 0x60(%rsp), %rdi
callq 0x4150200
leaq 0x40(%rsp), %rdi
callq 0x4150b90
movq 0x88(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rs... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::ScheduleDAGFast::InsertCopiesAndMoveSuccs(llvm::SUnit*, unsigned int, llvm::TargetRegisterClass const*, llvm::TargetRegisterClass const*, llvm::SmallVectorImpl<llvm::SUnit*>&) | void ScheduleDAGFast::InsertCopiesAndMoveSuccs(SUnit *SU, unsigned Reg,
const TargetRegisterClass *DestRC,
const TargetRegisterClass *SrcRC,
SmallVectorImpl<SUnit*> &Copies) {
SUni... | subq $0x138, %rsp # imm = 0x138
movq %rdi, 0x130(%rsp)
movq %rsi, 0x128(%rsp)
movl %edx, 0x124(%rsp)
movq %rcx, 0x118(%rsp)
movq %r8, 0x110(%rsp)
movq %r9, 0x108(%rsp)
movq 0x130(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0x4168e40
movq 0x8(%rsp), %rdi
movq %rax, 0x100(%rsp)
movq ... | /CodeGen/SelectionDAG/ScheduleDAGFast.cpp |
(anonymous namespace)::ScheduleDAGRRList::EmitNode(llvm::SUnit*) | void ScheduleDAGRRList::EmitNode(SUnit *SU) {
if (!HazardRec->isEnabled())
return;
// Check for phys reg copy.
if (!SU->getNode())
return;
switch (SU->getNode()->getOpcode()) {
default:
assert(SU->getNode()->isMachineOpcode() &&
"This target-independent node should not be scheduled.")... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x2a0(%rax), %rdi
callq 0x34c5e20
testb $0x1, %al
jne 0x416200d
jmp 0x41620e1
movq 0x18(%rsp), %rdi
callq 0x1bd9610
cmpq $0x0, %rax
jne 0x4162022
jmp 0x41620e1
movq 0x18(%rsp), %rdi
callq 0x1bd9610
movq %rax, %... | /CodeGen/SelectionDAG/ScheduleDAGRRList.cpp |
hasOnlyLiveInOpers(llvm::SUnit const*) | static bool hasOnlyLiveInOpers(const SUnit *SU) {
bool RetVal = false;
for (const SDep &Pred : SU->Preds) {
if (Pred.isCtrl()) continue;
const SUnit *PredSU = Pred.getSUnit();
if (PredSU->getNode() &&
PredSU->getNode()->getOpcode() == ISD::CopyFromReg) {
Register Reg =
cast<Regis... | subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movb $0x0, 0x37(%rsp)
movq 0x38(%rsp), %rax
addq $0x28, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0xc997a0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0xc997b0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
je 0x416648d
movq 0x20(%rsp), %rax
m... | /CodeGen/SelectionDAG/ScheduleDAGRRList.cpp |
llvm::SUnit* (anonymous namespace)::popFromQueueImpl<(anonymous namespace)::src_ls_rr_sort>(std::vector<llvm::SUnit*, std::allocator<llvm::SUnit*>>&, (anonymous namespace)::src_ls_rr_sort&) | static SUnit *popFromQueueImpl(std::vector<SUnit *> &Q, SF &Picker) {
unsigned BestIdx = 0;
// Only compute the cost for the first 1000 items in the queue, to avoid
// excessive compile-times for very large queues.
for (unsigned I = 1, E = std::min(Q.size(), (decltype(Q.size()))1000); I != E;
I++)
if... | subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl $0x0, 0x44(%rsp)
movl $0x1, 0x40(%rsp)
movq 0x50(%rsp), %rdi
callq 0xe79de0
movq %rax, 0x30(%rsp)
movq $0x3e8, 0x28(%rsp) # imm = 0x3E8
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x3f9480
movq (%rax), %rax
movl %eax, 0x3c(%rsp)
movl 0x40(%rsp... | /CodeGen/SelectionDAG/ScheduleDAGRRList.cpp |
llvm::cl::opt<int, false, llvm::cl::parser<int>>::opt<char [26], llvm::cl::OptionHidden, llvm::cl::initializer<int>, llvm::cl::desc>(char const (&) [26], llvm::cl::OptionHidden const&, llvm::cl::initializer<int> const&, llvm::cl::desc const&) | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
xorl %edx, %edx
movl %edx, %esi
callq 0x3f6a60
movq (%rsp), %rdi
addq $0x80, %rdi
callq 0x77c040
movq (%rsp), %rsi
leaq 0x557633e(%rip), %rax # 0x96df04... | /llvm/Support/CommandLine.h |
llvm::ScheduleDAGSDNodes::ClusterNeighboringLoads(llvm::SDNode*) | void ScheduleDAGSDNodes::ClusterNeighboringLoads(SDNode *Node) {
SDValue Chain;
unsigned NumOps = Node->getNumOperands();
if (Node->getOperand(NumOps-1).getValueType() == MVT::Other)
Chain = Node->getOperand(NumOps-1);
if (!Chain)
return;
// Skip any load instruction that has a tied input. There may ... | subq $0x308, %rsp # imm = 0x308
movq %rdi, 0x300(%rsp)
movq %rsi, 0x2f8(%rsp)
movq 0x300(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x2e8(%rsp), %rdi
callq 0x98b9c0
movq 0x2f8(%rsp), %rdi
callq 0x988ce0
movl %eax, 0x2e4(%rsp)
movq 0x2f8(%rsp), %rdi
movl 0x2e4(%rsp), %esi
subl $0x1, %esi
callq 0x981ab0
movq %rax,... | /CodeGen/SelectionDAG/ScheduleDAGSDNodes.cpp |
llvm::ScheduleDAGSDNodes::computeLatency(llvm::SUnit*) | void ScheduleDAGSDNodes::computeLatency(SUnit *SU) {
SDNode *N = SU->getNode();
// TokenFactor operands are considered zero latency, and some schedulers
// (e.g. Top-Down list) may rely on the fact that operand latency is nonzero
// whenever node latency is nonzero.
if (N && N->getOpcode() == ISD::TokenFacto... | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1bd9610
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x416b661
movq 0x20(%rsp), %rdi
callq 0x97c400
cmpl $0x2, %eax
jne 0x416b661
movq 0x28(%rsp), %rax
movw $0x0, 0xfc(%rax)
jmp 0x416... | /CodeGen/SelectionDAG/ScheduleDAGSDNodes.cpp |
ProcessSDDbgValues(llvm::SDNode*, llvm::SelectionDAG*, llvm::InstrEmitter&, llvm::SmallVectorImpl<std::pair<unsigned int, llvm::MachineInstr*>>&, llvm::DenseMap<llvm::SDValue, llvm::Register, llvm::DenseMapInfo<llvm::SDValue, void>, llvm::detail::DenseMapPair<llvm::SDValue, llvm::Register>>&, unsigned int) | static void
ProcessSDDbgValues(SDNode *N, SelectionDAG *DAG, InstrEmitter &Emitter,
SmallVectorImpl<std::pair<unsigned, MachineInstr*> > &Orders,
DenseMap<SDValue, Register> &VRBaseMap, unsigned Order) {
if (!N->getHasDebugValue())
return;
/// Returns true if \p DV has any... | subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq %rcx, 0x98(%rsp)
movq %r8, 0x90(%rsp)
movl %r9d, 0x8c(%rsp)
movq 0xb0(%rsp), %rdi
callq 0x3ffc370
testb $0x1, %al
jne 0x416e0bd
jmp 0x416e252
movq 0x90(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0xa0(%rsp), %rdi
callq 0x415b650
movq %ra... | /CodeGen/SelectionDAG/ScheduleDAGSDNodes.cpp |
void llvm::sort<long*>(long*, long*) | 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 $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x416f910
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| /llvm/ADT/STLExtras.h |
llvm::detail::DenseMapPair<llvm::SUnit*, llvm::Register>* llvm::DenseMapBase<llvm::DenseMap<llvm::SUnit*, llvm::Register, llvm::DenseMapInfo<llvm::SUnit*, void>, llvm::detail::DenseMapPair<llvm::SUnit*, llvm::Register>>, llvm::SUnit*, llvm::Register, llvm::DenseMapInfo<llvm::SUnit*, void>, llvm::detail::DenseMapPair<ll... | 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 0x41706b0
movq 0x10(%rsp), %rdi
addl $0x1, %eax
movl %eax, 0x24(%rsp)
callq 0x416fea0
movl %eax, 0x20(%rsp)
movl 0x24(%rsp), %ea... | /llvm/ADT/DenseMap.h |
llvm::DAGTypeLegalizer::SoftenFloatRes_EXTRACT_ELEMENT(llvm::SDNode*) | SDValue DAGTypeLegalizer::SoftenFloatRes_EXTRACT_ELEMENT(SDNode *N) {
SDValue Src = N->getOperand(0);
assert(Src.getValueType() == MVT::ppcf128 &&
"In floats only ppcf128 can be extracted by element!");
return DAG.getNode(ISD::EXTRACT_ELEMENT, SDLoc(N),
N->getValueType(0).changeTypeT... | subq $0x118, %rsp # imm = 0x118
movq %rdi, 0x100(%rsp)
movq %rsi, 0xf8(%rsp)
movq 0x100(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0xf8(%rsp), %rdi
xorl %esi, %esi
movl %esi, 0x2c(%rsp)
callq 0x981ab0
movq %rax, %rcx
movq 0x30(%rsp), %rax
movups (%rcx), %xmm0
movaps %xmm0, 0xe0(%rsp)
movq 0x8(%rax), %rax
movq %r... | /CodeGen/SelectionDAG/LegalizeFloatTypes.cpp |
llvm::DAGTypeLegalizer::SoftenFloatRes_FP_EXTEND(llvm::SDNode*) | SDValue DAGTypeLegalizer::SoftenFloatRes_FP_EXTEND(SDNode *N) {
bool IsStrict = N->isStrictFPOpcode();
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
SDValue Op = N->getOperand(IsStrict ? 1 : 0);
SDValue Chain = IsStrict ? N->getOperand(0) : SDValue();
if (getTypeAction(Op.getVal... | subq $0x488, %rsp # imm = 0x488
movq %rdi, 0x470(%rsp)
movq %rsi, 0x468(%rsp)
movq 0x470(%rsp), %rax
movq %rax, 0x90(%rsp)
movq 0x468(%rsp), %rdi
callq 0x9c2ef0
movb %al, %cl
movq 0x90(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x467(%rsp)
movq (%rax), %rcx
movq %rcx, 0x98(%rsp)
movq 0x8(%rax), %rdi
callq 0x995030... | /CodeGen/SelectionDAG/LegalizeFloatTypes.cpp |
llvm::DAGTypeLegalizer::SoftenFloatRes_FPOW(llvm::SDNode*) | SDValue DAGTypeLegalizer::SoftenFloatRes_FPOW(SDNode *N) {
return SoftenFloatRes_Binary(N, GetFPLibCall(N->getValueType(0),
RTLIB::POW_F32,
RTLIB::POW_F64,
RTLIB::POW_F80,
... | subq $0x58, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
xorl %esi, %esi
callq 0x97c3d0
movb %al, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x30(%rsp), %rsi
movl 0x28(%rsp), %edi
movq %rsp, %rax
movl $0xd3, (%rax)
movl $0xcf, %edx
mo... | /CodeGen/SelectionDAG/LegalizeFloatTypes.cpp |
llvm::DAGTypeLegalizer::PromoteFloatOperand(llvm::SDNode*, unsigned int) | bool DAGTypeLegalizer::PromoteFloatOperand(SDNode *N, unsigned OpNo) {
LLVM_DEBUG(dbgs() << "Promote float operand " << OpNo << ": "; N->dump(&DAG));
SDValue R = SDValue();
if (CustomLowerNode(N, N->getOperand(OpNo).getValueType(), false)) {
LLVM_DEBUG(dbgs() << "Node has been custom lowered, done\n");
r... | subq $0x1b8, %rsp # imm = 0x1B8
movq %rdi, 0x1a8(%rsp)
movq %rsi, 0x1a0(%rsp)
movl %edx, 0x19c(%rsp)
movq 0x1a8(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x4194d5d
leaq 0x188(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x348990
leaq 0x188(%rsp), %rdi
callq 0x98b9c0
movq 0x1a0(%rsp), %rax
movq %rax, 0x8(%r... | /CodeGen/SelectionDAG/LegalizeFloatTypes.cpp |
llvm::DAGTypeLegalizer::PromoteFloatOp_FP_EXTEND(llvm::SDNode*, unsigned int) | SDValue DAGTypeLegalizer::PromoteFloatOp_FP_EXTEND(SDNode *N, unsigned OpNo) {
SDValue Op = GetPromotedFloat(N->getOperand(0));
EVT VT = N->getValueType(0);
// Desired VT is same as promoted type. Use promoted float directly.
if (VT == Op->getValueType(0))
return Op;
// Else, extend the promoted float ... | subq $0xe8, %rsp
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movl %edx, 0xc4(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0xc8(%rsp), %rdi
xorl %esi, %esi
callq 0x981ab0
movq 0x28(%rsp), %rdi
movups (%rax), %xmm0
movaps %xmm0, 0xa0(%rsp)
movq 0xa0(%rsp), %rsi
movl 0xa8(%rsp), %edx
callq 0x4189190
movl %edx, 0... | /CodeGen/SelectionDAG/LegalizeFloatTypes.cpp |
llvm::DAGTypeLegalizer::PromoteFloatRes_LOAD(llvm::SDNode*) | SDValue DAGTypeLegalizer::PromoteFloatRes_LOAD(SDNode *N) {
LoadSDNode *L = cast<LoadSDNode>(N);
EVT VT = N->getValueType(0);
// Load the value as an integer value with the same number of bits.
EVT IVT = EVT::getIntegerVT(*DAG.getContext(), VT.getSizeInBits());
SDValue newL = DAG.getLoad(
L->getAddress... | pushq %r14
pushq %rbx
subq $0x2b8, %rsp # imm = 0x2B8
movq %rdi, 0x2a0(%rsp)
movq %rsi, 0x298(%rsp)
movq 0x2a0(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0x298(%rsp), %rdi
callq 0x98b740
movq %rax, 0x290(%rsp)
movq 0x298(%rsp), %rdi
xorl %esi, %esi
callq 0x97c3d0
movb %al, %cl
movq 0xb0(%rsp), %rax
movb %cl, 0x2... | /CodeGen/SelectionDAG/LegalizeFloatTypes.cpp |
llvm::DAGTypeLegalizer::SoftPromoteHalfRes_FFREXP(llvm::SDNode*) | SDValue DAGTypeLegalizer::SoftPromoteHalfRes_FFREXP(SDNode *N) {
EVT OVT = N->getValueType(0);
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), OVT);
SDValue Op = GetSoftPromotedHalf(N->getOperand(0));
SDLoc dl(N);
// Promote to the larger FP type.
Op = DAG.getNode(GetPromotionOpcode(OVT, NVT), dl, NV... | subq $0x238, %rsp # imm = 0x238
movq %rdi, 0x220(%rsp)
movq %rsi, 0x218(%rsp)
movq 0x220(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x218(%rsp), %rdi
xorl %esi, %esi
movl %esi, 0x1c(%rsp)
callq 0x97c3d0
movb %al, %cl
movq 0x40(%rsp), %rax
movb %cl, 0x208(%rsp)
movq %rdx, 0x210(%rsp)
movq (%rax), %rcx
movq %rcx, ... | /CodeGen/SelectionDAG/LegalizeFloatTypes.cpp |
llvm::DAGTypeLegalizer::SoftPromoteHalfOp_FP_TO_XINT_SAT(llvm::SDNode*) | SDValue DAGTypeLegalizer::SoftPromoteHalfOp_FP_TO_XINT_SAT(SDNode *N) {
EVT RVT = N->getValueType(0);
SDValue Op = N->getOperand(0);
EVT SVT = Op.getValueType();
SDLoc dl(N);
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), Op.getValueType());
Op = GetSoftPromotedHalf(Op);
SDValue Res = DAG.getNod... | subq $0x1c8, %rsp # imm = 0x1C8
movq %rdi, 0x1b0(%rsp)
movq %rsi, 0x1a8(%rsp)
movq 0x1b0(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x1a8(%rsp), %rdi
xorl %esi, %esi
movl %esi, 0x54(%rsp)
callq 0x97c3d0
movl 0x54(%rsp), %esi
movb %al, 0x198(%rsp)
movq %rdx, 0x1a0(%rsp)
movq 0x1a8(%rsp), %rdi
callq 0x981ab0
movup... | /CodeGen/SelectionDAG/LegalizeFloatTypes.cpp |
llvm::DAGTypeLegalizer::PromoteIntRes_MLOAD(llvm::MaskedLoadSDNode*) | SDValue DAGTypeLegalizer::PromoteIntRes_MLOAD(MaskedLoadSDNode *N) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
SDValue ExtPassThru = GetPromotedInteger(N->getPassThru());
ISD::LoadExtType ExtType = N->getExtensionType();
if (ExtType == ISD::NON_EXTLOAD)
ExtType = ISD::EXTLO... | pushq %rbp
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movq %rdi, 0x1e0(%rsp)
movq %rsi, 0x1d8(%rsp)
movq 0x1e0(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq (%rax), %rcx
movq %rcx, 0x98(%rsp)
movq 0x8(%rax), %rdi
callq 0x995030
movq %rax, 0xa0(%rsp)
movq 0x1d8(%rsp), %rdi
xorl %esi, %esi
callq 0x97c3d0
movq 0x98(%r... | /CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp |
llvm::DAGTypeLegalizer::PromoteIntRes_INSERT_SUBVECTOR(llvm::SDNode*) | SDValue DAGTypeLegalizer::PromoteIntRes_INSERT_SUBVECTOR(SDNode *N) {
EVT OutVT = N->getValueType(0);
EVT NOutVT = TLI.getTypeToTransformTo(*DAG.getContext(), OutVT);
assert(NOutVT.isVector() && "This type must be promoted to a vector type");
SDLoc dl(N);
SDValue Vec = N->getOperand(0);
SDValue SubVec = N-... | subq $0x1f8, %rsp # imm = 0x1F8
movq %rdi, 0x1e0(%rsp)
movq %rsi, 0x1d8(%rsp)
movq 0x1e0(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x1d8(%rsp), %rdi
xorl %esi, %esi
movl %esi, 0x44(%rsp)
callq 0x97c3d0
movb %al, %cl
movq 0x50(%rsp), %rax
movb %cl, 0x1c8(%rsp)
movq %rdx, 0x1d0(%rsp)
movq (%rax), %rcx
movq %rcx, ... | /CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp |
llvm::DAGTypeLegalizer::PromoteIntRes_STEP_VECTOR(llvm::SDNode*) | SDValue DAGTypeLegalizer::PromoteIntRes_STEP_VECTOR(SDNode *N) {
SDLoc dl(N);
EVT OutVT = N->getValueType(0);
EVT NOutVT = TLI.getTypeToTransformTo(*DAG.getContext(), OutVT);
assert(NOutVT.isScalableVector() &&
"Type must be promoted to a scalable vector type");
const APInt &StepVal = N->getConstantO... | subq $0xe8, %rsp
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0xc8(%rsp), %rsi
leaq 0xb8(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x9817d0
movq 0xc8(%rsp), %rdi
xorl %esi, %esi
movl %esi, 0x14(%rsp)
callq 0x97c3d0
movb %al, %cl
movq 0x18(%rsp), %rax
movb %cl, 0xa8(%rsp)
mo... | /CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp |
llvm::DAGTypeLegalizer::ExpandIntRes_MUL(llvm::SDNode*, llvm::SDValue&, llvm::SDValue&) | void DAGTypeLegalizer::ExpandIntRes_MUL(SDNode *N,
SDValue &Lo, SDValue &Hi) {
EVT VT = N->getValueType(0);
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
SDLoc dl(N);
SDValue LL, LH, RL, RH;
GetExpandedInteger(N->getOperand(0), LL, LH);
GetExpandedIntege... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2f8, %rsp # imm = 0x2F8
movq %rdi, 0x2f0(%rsp)
movq %rsi, 0x2e8(%rsp)
movq %rdx, 0x2e0(%rsp)
movq %rcx, 0x2d8(%rsp)
movq 0x2f0(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x2e8(%rsp), %rdi
xorl %esi, %esi
callq 0x97c3d0
movb %al, %cl
movq 0x78(%rsp), %rax
movb %... | /CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp |
llvm::DAGTypeLegalizer::ExpandIntRes_SIGN_EXTEND(llvm::SDNode*, llvm::SDValue&, llvm::SDValue&) | void DAGTypeLegalizer::ExpandIntRes_SIGN_EXTEND(SDNode *N,
SDValue &Lo, SDValue &Hi) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
SDLoc dl(N);
SDValue Op = N->getOperand(0);
if (Op.getValueType().bitsLE(NVT)) {
// The low part i... | subq $0x318, %rsp # imm = 0x318
movq %rdi, 0x310(%rsp)
movq %rsi, 0x308(%rsp)
movq %rdx, 0x300(%rsp)
movq %rcx, 0x2f8(%rsp)
movq 0x310(%rsp), %rax
movq %rax, 0x68(%rsp)
movq (%rax), %rcx
movq %rcx, 0x70(%rsp)
movq 0x8(%rax), %rdi
callq 0x995030
movq %rax, 0x78(%rsp)
movq 0x308(%rsp), %rdi
xorl %esi, %esi
cal... | /CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp |
llvm::DAGTypeLegalizer::ExpandOp_SCALAR_TO_VECTOR(llvm::SDNode*) | SDValue DAGTypeLegalizer::ExpandOp_SCALAR_TO_VECTOR(SDNode *N) {
SDLoc dl(N);
EVT VT = N->getValueType(0);
assert(VT.getVectorElementType() == N->getOperand(0).getValueType() &&
"SCALAR_TO_VECTOR operand type doesn't match vector element type!");
unsigned NumElts = VT.getVectorNumElements();
SmallVec... | subq $0x218, %rsp # imm = 0x218
movq %rdi, 0x200(%rsp)
movq %rsi, 0x1f8(%rsp)
movq 0x200(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x1f8(%rsp), %rsi
leaq 0x1e8(%rsp), %rdi
callq 0x9817d0
movq 0x1f8(%rsp), %rdi
xorl %esi, %esi
movl %esi, 0x24(%rsp)
callq 0x97c3d0
movb %al, 0x1d8(%rsp)
movq %rdx, 0x1e0(%rsp)
leaq... | /CodeGen/SelectionDAG/LegalizeTypesGeneric.cpp |
llvm::AMDGPU::getRegBitWidth(unsigned int) | unsigned getRegBitWidth(unsigned RCID) {
switch (RCID) {
case AMDGPU::SGPR_LO16RegClassID:
case AMDGPU::AGPR_LO16RegClassID:
return 16;
case AMDGPU::SGPR_32RegClassID:
case AMDGPU::VGPR_32RegClassID:
case AMDGPU::VRegOrLds_32RegClassID:
case AMDGPU::AGPR_32RegClassID:
case AMDGPU::VS_32RegClassID:
... | movl %edi, -0x8(%rsp)
movl -0x8(%rsp), %eax
addl $-0xe, %eax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
leaq 0x41817a0(%rip), %rcx # 0x838e65c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x10, -0x4(%rsp)
jmp 0x420cf61
movl $0x20, -0x4(%rsp)
jmp 0x420cf61
movl $0x40, -0x4(%rsp)
jmp 0x420cf61
movl $0... | /Target/AMDGPU/Utils/AMDGPUBaseInfo.cpp |
llvm::AMDGPU::isInlinableLiteralFP16(short, bool) | bool isInlinableLiteralFP16(int16_t Literal, bool HasInv2Pi) {
if (!HasInv2Pi)
return false;
if (isInlinableIntLiteral(Literal))
return true;
uint16_t Val = static_cast<uint16_t>(Literal);
return Val == 0x3C00 || // 1.0
Val == 0xBC00 || // -1.0
Val == 0x3800 || // 0.5
Val == 0... | subq $0x18, %rsp
movb %sil, %al
movw %di, %cx
movw %cx, 0x14(%rsp)
andb $0x1, %al
movb %al, 0x13(%rsp)
testb $0x1, 0x13(%rsp)
jne 0x420d656
movb $0x0, 0x17(%rsp)
jmp 0x420d736
movswq 0x14(%rsp), %rdi
callq 0x53ee00
testb $0x1, %al
jne 0x420d667
jmp 0x420d671
movb $0x1, 0x17(%rsp)
jmp 0x420d736
movw 0x14(%rsp), %ax
movw... | /Target/AMDGPU/Utils/AMDGPUBaseInfo.cpp |
llvm::cl::opt<bool, false, llvm::cl::parser<bool>>::opt<char [18], llvm::cl::desc, llvm::cl::initializer<bool>, llvm::cl::cat>(char const (&) [18], llvm::cl::desc const&, llvm::cl::initializer<bool> const&, llvm::cl::cat 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 %r8, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
xorl %edx, %edx
movl %edx, %esi
callq 0x3f6a60
movq (%rsp), %rdi
addq $0x80, %rdi
callq 0x3f7700
movq (%rsp), %rsi
leaq 0x54b8176(%rip), %rax # 0x96df18... | /llvm/Support/CommandLine.h |
llvm::Region* const* llvm::SmallVectorTemplateCommon<llvm::Region*, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<llvm::Region*, true>>(llvm::SmallVectorTemplateBase<llvm::Region*, true>*, llvm::Region* 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 0x4237cd4
movq 0x3... | /llvm/ADT/SmallVector.h |
polly::IslAstAnalysis::Result& llvm::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>::getResult<polly::IslAstAnalysis>(polly::Scop&, polly::ScopStandardAnalysisResults&) | typename PassT::Result &getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs) {
assert(AnalysisPasses.count(PassT::ID()) &&
"This analysis pass was not registered prior to being queried");
ResultConceptT &ResultConcept =
getResultImpl(PassT::ID(), IR, ExtraArgs...);
using ResultModelT =
... | subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
callq 0x423e940
movq (%rsp), %rdi
movq %rax, %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x423e640
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x8, %rax
addq $0x28, %rsp
retq
nopw (%... | /llvm/IR/PassManager.h |
(anonymous namespace)::CodePreparation::runOnFunction(llvm::Function&) | bool CodePreparation::runOnFunction(Function &F) {
if (skipFunction(F))
return false;
LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
SE = &getAnalysis<ScalarEvolutionWrapperPass>().getSE();
splitEntryBlockForAlloca(&F.getEntryBlock(), this);
return true;
} | subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x10(%rsp), %rsi
callq 0x312ea30
testb $0x1, %al
jne 0x4262348
jmp 0x426234f
movb $0x0, 0x27(%rsp)
jmp 0x426239f
movq 0x8(%rsp), %rdi
callq 0x914e10
movq %rax, %rdi
callq 0x914e30
movq 0x8(%rsp), %rdi
movq %rax,... | /Transform/CodePreparation.cpp |
llvm::cl::opt<bool, false, llvm::cl::parser<bool>>::opt<char [23], llvm::cl::desc, llvm::cl::cat>(char const (&) [23], llvm::cl::desc const&, llvm::cl::cat 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 0x3f7700
movq 0x8(%rsp), %rsi
leaq 0x547a5c8(%rip), %rax # 0x96df180
addq $0x10... | /llvm/Support/CommandLine.h |
llvm::cl::opt<bool, false, llvm::cl::parser<bool>>::opt<char [22], llvm::cl::desc, llvm::cl::cat>(char const (&) [22], llvm::cl::desc const&, llvm::cl::cat 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 0x3f7700
movq 0x8(%rsp), %rsi
leaq 0x547a3a8(%rip), %rax # 0x96df180
addq $0x10... | /llvm/Support/CommandLine.h |
llvm::DenseMap<std::pair<llvm::Value*, polly::ScopStmt*>, (anonymous namespace)::ForwardingAction, llvm::DenseMapInfo<std::pair<llvm::Value*, polly::ScopStmt*>, void>, llvm::detail::DenseMapPair<std::pair<llvm::Value*, polly::ScopStmt*>, (anonymous namespace)::ForwardingAction>>::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 0x428b4c7
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movb $0x0, 0x27(%rsp)
jmp 0x428b4f0
movq 0x8(%rsp), %rax
movl 0x10(%rax), %eax
imulq $0x88, %rax,... | /llvm/ADT/DenseMap.h |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.