name string | code string | asm string | file string |
|---|---|---|---|
llvm::PPCInstPrinter::printTLSCall(llvm::MCInst const*, unsigned int, llvm::MCSubtargetInfo const&, llvm::raw_ostream&) | void PPCInstPrinter::printTLSCall(const MCInst *MI, unsigned OpNo,
const MCSubtargetInfo &STI, raw_ostream &O) {
// On PPC64, VariantKind is VK_None, but on PPC32, it's VK_PLT, and it must
// come at the _end_ of the expression.
const MCOperand &Op = MI->getOperand(OpNo);
const... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %rbx
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r15
movl %edx, %eax
movq 0x10(%rsi), %rcx
shlq $0x4, %rax
movq 0x8(%rcx,%rax), %r14
cmpb $0x0, (%r14)
je 0x1994702
movq $0x0, (%rsp)
jmp 0x199470e
movq 0x18(%r14), %rax
movq %rax... | /Target/PowerPC/MCTargetDesc/PPCInstPrinter.cpp |
llvm::PPCInstPrinter::printS34ImmOperand(llvm::MCInst const*, unsigned int, llvm::MCSubtargetInfo const&, llvm::raw_ostream&) | const MCOperand &getOperand(unsigned i) const { return Operands[i]; } | movl %edx, %eax
movq 0x10(%rsi), %rcx
shlq $0x4, %rax
cmpb $0x2, (%rcx,%rax)
jne 0x19940f0
addq %rax, %rcx
movq 0x8(%rcx), %rsi
movq %r8, %rdi
jmp 0x2b7d146
nop
| /llvm/MC/MCInst.h |
llvm::PPCInstPrinter::showRegistersWithPercentPrefix(char const*) const | bool PPCInstPrinter::showRegistersWithPercentPrefix(const char *RegName) const {
if ((!FullRegNamesWithPercent && !MAI.useFullRegisterNames()) ||
TT.getOS() == Triple::AIX)
return false;
switch (RegName[0]) {
default:
return false;
case 'r':
case 'f':
case 'q':
case 'v':
case 'c':
ret... | cmpb $0x0, 0x3fa4229(%rip) # 0x59397a8
je 0x1995589
cmpl $0x13, 0x6c(%rdi)
jne 0x199559e
jmp 0x19955b1
movq 0x10(%rdi), %rcx
xorl %eax, %eax
cmpb $0x1, 0xbd(%rcx)
jne 0x19955b3
cmpl $0x13, 0x6c(%rdi)
je 0x19955b3
movb (%rsi), %cl
addb $-0x63, %cl
cmpb $0x13, %cl
ja 0x19955b1
movl $0x8c009, %eax # imm = 0x8C0... | /Target/PowerPC/MCTargetDesc/PPCInstPrinter.cpp |
(anonymous namespace)::PPCTargetAsmStreamer::emitLocalEntry(llvm::MCSymbolELF*, llvm::MCExpr const*) | void emitLocalEntry(MCSymbolELF *S, const MCExpr *LocalOffset) override {
const MCAsmInfo *MAI = Streamer.getContext().getAsmInfo();
OS << "\t.localentry\t";
S->print(OS, MAI);
OS << ", ";
LocalOffset->print(OS, MAI);
OS << '\n';
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rdi
movq 0x8(%rax), %rax
movq 0x98(%rax), %r15
leaq 0x301702e(%rip), %rsi # 0x49b1145
movl $0xd, %edx
callq 0x7f9ba8
movq 0x10(%rbx), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq... | /Target/PowerPC/MCTargetDesc/PPCMCTargetDesc.cpp |
llvm::PPCMCCodeEmitter::getImm34Encoding(llvm::MCInst const&, unsigned int, llvm::SmallVectorImpl<llvm::MCFixup>&, llvm::MCSubtargetInfo const&, llvm::MCFixupKind) const | uint64_t PPCMCCodeEmitter::getImm34Encoding(const MCInst &MI, unsigned OpNo,
SmallVectorImpl<MCFixup> &Fixups,
const MCSubtargetInfo &STI,
MCFixupKind Fixup) const {
const MCOperand &MO ... | pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movl %edx, %eax
movq 0x10(%rsi), %rcx
shlq $0x4, %rax
leaq (%rcx,%rax), %rdx
cmpb $0x2, (%rcx,%rax)
jne 0x199a6aa
addq $0x20, %rsp
popq %rbx
jmp 0x199a3e0
movq 0x8(%rdx), %rax
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq %rax, (%rsi)
movl... | /Target/PowerPC/MCTargetDesc/PPCMCCodeEmitter.cpp |
llvm::PPCMCCodeEmitter::getDispRIX16Encoding(llvm::MCInst const&, unsigned int, llvm::SmallVectorImpl<llvm::MCFixup>&, llvm::MCSubtargetInfo const&) const | unsigned
PPCMCCodeEmitter::getDispRIX16Encoding(const MCInst &MI, unsigned OpNo,
SmallVectorImpl<MCFixup> &Fixups,
const MCSubtargetInfo &STI) const {
const MCOperand &MO = MI.getOperand(OpNo);
if (MO.isImm()) {
assert(!(MO.getImm() %... | pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movl %edx, %eax
movq 0x10(%rsi), %rcx
shlq $0x4, %rax
leaq (%rcx,%rax), %rdx
cmpb $0x2, (%rcx,%rax)
jne 0x199a84f
callq 0x199a3e0
shrl $0x4, %eax
andl $0xfff, %eax # imm = 0xFFF
jmp 0x199a8a6
movzbl 0x18(%rdi), %eax
xorl $0x1, %eax
addl %eax, %eax
movq 0x8(%rdx), %... | /Target/PowerPC/MCTargetDesc/PPCMCCodeEmitter.cpp |
llvm::PPCMCExpr::printImpl(llvm::raw_ostream&, llvm::MCAsmInfo const*) const | void PPCMCExpr::printImpl(raw_ostream &OS, const MCAsmInfo *MAI) const {
getSubExpr()->print(OS, MAI);
switch (Kind) {
default:
llvm_unreachable("Invalid kind!");
case VK_PPC_LO:
OS << "@l";
break;
case VK_PPC_HI:
OS << "@h";
break;
case VK_PPC_HA:
OS << "@ha";
break;
case VK_... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
xorl %ecx, %ecx
callq 0x28e14a4
movl 0x18(%r14), %eax
decl %eax
leaq 0x3048ec6(%rip), %rcx # 0x49e70b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x361f047(%rip), %rsi # 0x4fbd241
jmp 0x199e236
leaq 0x361f067(%rip... | /Target/PowerPC/MCTargetDesc/PPCMCExpr.cpp |
llvm::PPCELFStreamer::PPCELFStreamer(llvm::MCContext&, std::unique_ptr<llvm::MCAsmBackend, std::default_delete<llvm::MCAsmBackend>>, std::unique_ptr<llvm::MCObjectWriter, std::default_delete<llvm::MCObjectWriter>>, std::unique_ptr<llvm::MCCodeEmitter, std::default_delete<llvm::MCCodeEmitter>>) | PPCELFStreamer::PPCELFStreamer(MCContext &Context,
std::unique_ptr<MCAsmBackend> MAB,
std::unique_ptr<MCObjectWriter> OW,
std::unique_ptr<MCCodeEmitter> Emitter)
: MCELFStreamer(Context, std::move(MAB), std::move(OW), std::... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdx), %rdi
leaq 0x8(%rsp), %rax
movq %rdi, (%rax)
xorl %edi, %edi
movq %rdi, (%rdx)
movq (%rcx), %rdx
movq %rsp, %r9
movq %rdx, (%r9)
movq %rdi, (%rcx)
movq (%r8), %rcx
leaq 0x10(%rsp), %r14
movq %rcx, (%r14)
movq %rdi, (%r8)
movq %rbx, %rdi
movq %rax, %rdx
... | /Target/PowerPC/MCTargetDesc/PPCELFStreamer.cpp |
llvm::createPPCXCOFFStreamer(llvm::MCContext&, std::unique_ptr<llvm::MCAsmBackend, std::default_delete<llvm::MCAsmBackend>>, std::unique_ptr<llvm::MCObjectWriter, std::default_delete<llvm::MCObjectWriter>>, std::unique_ptr<llvm::MCCodeEmitter, std::default_delete<llvm::MCCodeEmitter>>) | MCXCOFFStreamer *
llvm::createPPCXCOFFStreamer(MCContext &Context,
std::unique_ptr<MCAsmBackend> MAB,
std::unique_ptr<MCObjectWriter> OW,
std::unique_ptr<MCCodeEmitter> Emitter) {
return new PPCXCOFFStreamer(Context, std::move(MAB)... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movl $0x1a8, %edi # imm = 0x1A8
callq 0x7808d0
movq %rax, %rbx
movq (%r12), %rax
leaq 0x10(%rsp), %rdx
movq %rax, (%rdx)
xorl %eax, %eax
movq %rax, (%r12)
movq (%r15), %rsi
... | /Target/PowerPC/MCTargetDesc/PPCXCOFFStreamer.cpp |
(anonymous namespace)::ELFPPCAsmBackend::~ELFPPCAsmBackend() | ELFPPCAsmBackend(const Target &T, const Triple &TT) : PPCAsmBackend(T, TT) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x3eb2f57(%rip), %rax # 0x5851fc0
movq %rax, (%rdi)
movq 0x10(%rdi), %rdi
leaq 0x20(%rbx), %rax
cmpq %rax, %rdi
je 0x199f084
movq (%rax), %rsi
incq %rsi
callq 0x7800d0
movq %rbx, %rdi
callq 0x28c9922
movl $0x48, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x7800d0
| /Target/PowerPC/MCTargetDesc/PPCAsmBackend.cpp |
llvm::RISCVInstPrinter::printBranchOperand(llvm::MCInst const*, unsigned long, unsigned int, llvm::MCSubtargetInfo const&, llvm::raw_ostream&) | void RISCVInstPrinter::printBranchOperand(const MCInst *MI, uint64_t Address,
unsigned OpNo,
const MCSubtargetInfo &STI,
raw_ostream &O) {
const MCOperand &MO = MI->getOperand(OpNo);
if (!MO... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl %ecx, %eax
movq 0x10(%rsi), %r15
shlq $0x4, %rax
cmpb $0x2, (%r15,%rax)
jne 0x19a8a96
addq %rax, %r15
cmpb $0x1, 0x38(%rbx)
jne 0x19a8aae
addq 0x8(%r15), %rdx
testb $0x4, 0xd8(%r8)
movl %edx, %r14d
cmovneq %rdx, %r14
movq %rsp, %r15
movq ... | /Target/RISCV/MCTargetDesc/RISCVInstPrinter.cpp |
createRISCVMCSubtargetInfo(llvm::Triple const&, llvm::StringRef, llvm::StringRef) | static MCSubtargetInfo *createRISCVMCSubtargetInfo(const Triple &TT,
StringRef CPU, StringRef FS) {
if (CPU.empty() || CPU == "generic")
CPU = TT.isArch64Bit() ? "generic-rv64" : "generic-rv32";
return createRISCVMCSubtargetInfoImpl(TT, CPU, /*TuneCPU*/ CPU, F... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %r8, %r12
movq %rcx, %r13
movq %rdi, %rbx
testq %rdx, %rdx
je 0x19aa6a7
movq %rdx, %r15
movq %rsi, %r14
cmpq $0x7, %rdx
jne 0x19aa6c9
leaq 0x2a816b3(%rip), %rsi # 0x442bd4b
movq %r14, %rdi
movq %r15, %rdx
callq 0x780c70
testl %eax, %eax
jne ... | /Target/RISCV/MCTargetDesc/RISCVMCTargetDesc.cpp |
(anonymous namespace)::RISCVMCInstrAnalysis::isBranchImpl(llvm::MCInst const&) | unsigned getOpcode() const { return Opcode; } | movl (%rdi), %eax
cmpl $0x30bc, %eax # imm = 0x30BC
je 0x19aace9
cmpl $0x3207, %eax # imm = 0x3207
je 0x19aacd7
cmpl $0x3206, %eax # imm = 0x3206
jne 0x19aace6
movq 0x10(%rdi), %rax
cmpl $0x2b, 0x8(%rax)
sete %al
retq
movq 0x10(%rdi), %rax
cmpl $0x2b, 0x8(%rax)
jne 0x19aace6
movl 0x18(%rax... | /llvm/MC/MCInst.h |
llvm::RISCVMatInt::Inst::getOpndKind() const | OpndKind Inst::getOpndKind() const {
switch (Opc) {
default:
llvm_unreachable("Unexpected opcode!");
case RISCV::LUI:
return RISCVMatInt::Imm;
case RISCV::ADD_UW:
return RISCVMatInt::RegX0;
case RISCV::SH1ADD:
case RISCV::SH2ADD:
case RISCV::SH3ADD:
case RISCV::PACK:
return RISCVMatInt::... | movl (%rdi), %ecx
cmpl $0x3255, %ecx # imm = 0x3255
jle 0x19abeb2
cmpl $0x329e, %ecx # imm = 0x329E
jg 0x19abecb
addl $0xffffcdaa, %ecx # imm = 0xFFFFCDAA
movabsq $0x2a000000000001, %rax # imm = 0x2A000000000001
btq %rcx, %rax
jae 0x19abef5
movl $0x2, %eax
retq
cmpl $0x2f3f, %ecx # i... | /Target/RISCV/MCTargetDesc/RISCVMatInt.cpp |
llvm::RISCVTargetELFStreamer::finishAttributeSection() | void RISCVTargetELFStreamer::finishAttributeSection() {
RISCVELFStreamer &S = getStreamer();
if (S.Contents.empty())
return;
S.emitAttributesSection(CurrentVendor, ".riscv.attributes",
ELF::SHT_RISCV_ATTRIBUTES, AttributeSection);
} | movq %rdi, %r9
movq 0x8(%rdi), %rdi
cmpl $0x0, 0x1b0(%rdi)
je 0x19ac8c9
subq $0x38, %rsp
leaq 0x1a8(%rdi), %rax
movq 0x18(%r9), %rsi
movq 0x20(%r9), %rdx
leaq 0x31e7137(%rip), %r8 # 0x4b939db
leaq 0x10(%rsp), %rcx
movq %r8, (%rcx)
movw $0x103, 0x20(%rcx) # imm = 0x103
addq $0x28, %r9
movq %rax, (%rsp)
movl $0x7... | /Target/RISCV/MCTargetDesc/RISCVELFStreamer.cpp |
llvm::DenseMapBase<llvm::DenseMap<llvm::MCSection const*, RISCVELFStreamer::ElfMappingSymbol, llvm::DenseMapInfo<llvm::MCSection const*, void>, llvm::detail::DenseMapPair<llvm::MCSection const*, RISCVELFStreamer::ElfMappingSymbol>>, llvm::MCSection const*, RISCVELFStreamer::ElfMappingSymbol, llvm::DenseMapInfo<llvm::MC... | unsigned getNumEntries() const {
return NumEntries;
} | movl 0x8(%rdi), %eax
testl %eax, %eax
jne 0x19ac99b
cmpl $0x0, 0xc(%rdi)
je 0x19aca74
shll $0x2, %eax
movl 0x10(%rdi), %ecx
cmpl %ecx, %eax
setae %al
cmpl $0x41, %ecx
setb %dl
orb %al, %dl
je 0x19ad01c
testq %rcx, %rcx
je 0x19aca6c
movq (%rdi), %rax
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
addq %rdx, ... | /llvm/ADT/DenseMap.h |
RISCVELFStreamer::changeSection(llvm::MCSection*, unsigned int) | void RISCVELFStreamer::changeSection(MCSection *Section, uint32_t Subsection) {
// We have to keep track of the mapping symbol state of any sections we
// use. Each one should start off as EMS_None, which is provided as the
// default constructor by DenseMap::lookup.
LastMappingSymbols[getPreviousSection().firs... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, 0x4(%rsp)
movq %rsi, %r14
movq %rdi, %r15
movl 0x19e8(%rdi), %ebx
leaq 0x19d0(%rdi), %r12
movl 0x80(%rdi), %eax
xorl %ebp, %ebp
testq %rax, %rax
je 0x19acb4b
movq 0x78(%r15), %rcx
shlq $0x5, %rax
movq -0x10(%rcx,%rax), %rax
jm... | /Target/RISCV/MCTargetDesc/RISCVELFStreamer.cpp |
llvm::DenseMap<llvm::MCSection const*, RISCVELFStreamer::ElfMappingSymbol, llvm::DenseMapInfo<llvm::MCSection const*, void>, llvm::detail::DenseMapPair<llvm::MCSection const*, RISCVELFStreamer::ElfMappingSymbol>>::grow(unsigned int) | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBu... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl 0x10(%rdi), %ebx
movq (%rdi), %r14
leal -0x1(%rsi), %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x8, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x10,... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::RISCVMCCodeEmitter::getImmOpValue(llvm::MCInst const&, unsigned int, llvm::SmallVectorImpl<llvm::MCFixup>&, llvm::MCSubtargetInfo const&) const | unsigned RISCVMCCodeEmitter::getImmOpValue(const MCInst &MI, unsigned OpNo,
SmallVectorImpl<MCFixup> &Fixups,
const MCSubtargetInfo &STI) const {
bool EnableRelax = STI.hasFeature(RISCV::FeatureRelax);
const MCOperand &MO = MI.get... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movl %edx, %eax
movq 0x10(%rsi), %rdx
shlq $0x4, %rax
leaq (%rdx,%rax), %rcx
cmpb $0x2, (%rdx,%rax)
jne 0x19b3ebc
movl 0x8(%rcx), %r12d
jmp 0x19b40af
movq %rsi, %r14
movq %rdi, %r15
movq 0xd8(%r8), %rax
movq 0x10(%rdi), %... | /Target/RISCV/MCTargetDesc/RISCVMCCodeEmitter.cpp |
llvm::SystemZInstPrinter::printOperand(llvm::MCOperand const&, llvm::MCAsmInfo const*, llvm::raw_ostream&) | void SystemZInstPrinter::printOperand(const MCOperand &MO, const MCAsmInfo *MAI,
raw_ostream &O) {
if (MO.isReg()) {
if (!MO.getReg())
O << '0';
else
printFormattedRegName(MAI, MO.getReg(), O);
}
else if (MO.isImm())
markup(O, Markup::Immediate) << MO.... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
movzbl (%rbx), %eax
cmpl $0x2, %eax
je 0x19ba18b
cmpl $0x1, %eax
jne 0x19ba1b9
movl 0x8(%rbx), %eax
testl %eax, %eax
je 0x19ba1ce
movq %rsi, %rdi
movq %rdx, %rsi
movl %eax, %edx
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x19ba1fa
leaq 0x8(%rsp), %r14... | /Target/SystemZ/MCTargetDesc/SystemZInstPrinter.cpp |
createSystemZMCInstrInfo() | static MCInstrInfo *createSystemZMCInstrInfo() {
MCInstrInfo *X = new MCInstrInfo();
InitSystemZMCInstrInfo(X);
return X;
} | pushq %rax
movl $0x30, %edi
callq 0x7808d0
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
leaq 0x32346bf(%rip), %rcx # 0x4bef320
movq %rcx, (%rax)
leaq 0x323c815(%rip), %rcx # 0x4bf7480
movq %rcx, 0x8(%rax)
leaq 0x3236e5a(%rip), %rcx # 0x4bf1ad0
movq %rcx, 0x10(%rax)
mov... | /Target/SystemZ/MCTargetDesc/SystemZMCTargetDesc.cpp |
unsigned long (anonymous namespace)::SystemZMCCodeEmitter::getImmOpValue<(llvm::SystemZ::FixupKind)133>(llvm::MCInst const&, unsigned int, llvm::SmallVectorImpl<llvm::MCFixup>&, llvm::MCSubtargetInfo const&) const | uint64_t SystemZMCCodeEmitter::getImmOpValue(const MCInst &MI, unsigned OpNum,
SmallVectorImpl<MCFixup> &Fixups,
const MCSubtargetInfo &STI) const {
const MCOperand &MO = MI.getOperand(OpNum);
if (MO.isImm())
return static... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movl %edx, %eax
movq 0x10(%rsi), %rcx
shlq $0x4, %rax
leaq (%rcx,%rax), %r15
cmpb $0x2, (%rcx,%rax)
jne 0x19c57fb
movq 0x8(%r15), %rax
jmp 0x19c5876
movq %rsi, %r14
movq 0x8(%rdi), %rax
movl (%rsi), %ecx
movq (%rax), %rax
shlq $0x5, %rcx
negq ... | /Target/SystemZ/MCTargetDesc/SystemZMCCodeEmitter.cpp |
unsigned long (anonymous namespace)::SystemZMCCodeEmitter::getImmOpValue<(llvm::SystemZ::FixupKind)137>(llvm::MCInst const&, unsigned int, llvm::SmallVectorImpl<llvm::MCFixup>&, llvm::MCSubtargetInfo const&) const | uint64_t SystemZMCCodeEmitter::getImmOpValue(const MCInst &MI, unsigned OpNum,
SmallVectorImpl<MCFixup> &Fixups,
const MCSubtargetInfo &STI) const {
const MCOperand &MO = MI.getOperand(OpNum);
if (MO.isImm())
return static... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movl %edx, %eax
movq 0x10(%rsi), %rcx
shlq $0x4, %rax
leaq (%rcx,%rax), %r15
cmpb $0x2, (%rcx,%rax)
jne 0x19c5cc1
movq 0x8(%r15), %rax
jmp 0x19c5d3d
movq %rsi, %r14
movq 0x8(%rdi), %rax
movl (%rsi), %ecx
movq (%rax), %rax
shlq $0x5, %rcx
negq ... | /Target/SystemZ/MCTargetDesc/SystemZMCCodeEmitter.cpp |
createVEMCAsmInfo(llvm::MCRegisterInfo const&, llvm::Triple const&, llvm::MCTargetOptions const&) | static MCAsmInfo *createVEMCAsmInfo(const MCRegisterInfo &MRI, const Triple &TT,
const MCTargetOptions &Options) {
MCAsmInfo *MAI = new VEELFMCAsmInfo(TT);
unsigned Reg = MRI.getDwarfRegNum(VE::SX11, true);
MCCFIInstruction Inst = MCCFIInstruction::cfiDefCfa(nullptr, Reg, 0);
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %r15
movl $0x1e8, %edi # imm = 0x1E8
callq 0x7808d0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x19c941e
movq %r15, %rdi
movl $0xc6, %esi
movl $0x1, %edx
callq 0x28f28d0
xorl %ecx, %ecx
leaq 0x60(%rsp), %r15
movq %rcx, -0... | /Target/VE/MCTargetDesc/VEMCTargetDesc.cpp |
(anonymous namespace)::VEAsmBackend::getFixupKindInfo(llvm::MCFixupKind) const | const MCFixupKindInfo &getFixupKindInfo(MCFixupKind Kind) const override {
const static MCFixupKindInfo Infos[VE::NumTargetFixupKinds] = {
// name, offset, bits, flags
{"fixup_ve_reflong", 0, 32, 0},
{"fixup_ve_srel32", 0, 32, MCFixupKindInfo::FKF_IsPCRel},
{"fixup_ve_hi32", 0, 32, 0... | cmpl $0x7f, %esi
jg 0x19c90a4
jmp 0x28c9cec
addl $-0x80, %esi
leaq (%rsi,%rsi,2), %rax
leaq 0x3ea31ae(%rip), %rcx # 0x586c260
leaq (%rcx,%rax,8), %rax
retq
nop
| /Target/VE/MCTargetDesc/VEAsmBackend.cpp |
llvm::WebAssembly::parseBlockType(llvm::StringRef) | WebAssembly::BlockType WebAssembly::parseBlockType(StringRef Type) {
// Multivalue block types are handled separately in parseSignature
return StringSwitch<WebAssembly::BlockType>(Type)
.Case("i32", WebAssembly::BlockType::I32)
.Case("i64", WebAssembly::BlockType::I64)
.Case("f32", WebAssembly::Bl... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movabsq $0x100000000, %r12 # imm = 0x100000000
cmpq $0x3, %rsi
jne 0x19cb5d4
leaq 0x34876e9(%rip), %rsi # 0x4e52ca3
movq %r15, %rdi
movq %r14, %rdx
callq 0x780c70
leaq 0x7f(%r12), %rcx
xorl %ebx, %ebx
testl %eax, %eax
cmoveq %... | /Target/WebAssembly/MCTargetDesc/WebAssemblyMCTypeUtilities.cpp |
llvm::WebAssemblyTargetAsmStreamer::emitImportModule(llvm::MCSymbolWasm const*, llvm::StringRef) | void WebAssemblyTargetAsmStreamer::emitImportModule(const MCSymbolWasm *Sym,
StringRef ImportModule) {
OS << "\t.import_module\t" << Sym->getName() << ", "
<< ImportModule << '\n';
} | pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq 0x10(%rdi), %rdi
leaq 0x331fc74(%rip), %rsi # 0x4ceba9d
movl $0x10, %edx
callq 0x7f9ba8
xorl %esi, %esi
testb $0x1, 0x8(%r15)
movl $0x0, %edx
je 0x19cbe4c
movq -0x8(%r15), %rsi
movq (%rsi), %rdx
addq $0x18, %rsi
movq %rax, %rdi
call... | /Target/WebAssembly/MCTargetDesc/WebAssemblyTargetStreamer.cpp |
llvm::WebAssemblyInstPrinter::printBrList(llvm::MCInst const*, unsigned int, llvm::raw_ostream&) | void WebAssemblyInstPrinter::printBrList(const MCInst *MI, unsigned OpNo,
raw_ostream &O) {
O << "{";
for (unsigned I = OpNo, E = MI->getNumOperands(); I != E; ++I) {
if (I != OpNo)
O << ", ";
O << MI->getOperand(I).getImm();
}
O << "}";
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %r14d
movq %rsi, %r15
leaq 0x2f3062a(%rip), %rsi # 0x48fd291
movl $0x1, %edx
movq %rcx, %rdi
callq 0x7f9ba8
movl 0x18(%r15), %ebp
subl %r14d, %ebp
je 0x19cccbf
xorl %r13d, %r13d
leaq 0x25b3946(%rip), %r12 # 0x3f8... | /Target/WebAssembly/MCTargetDesc/WebAssemblyInstPrinter.cpp |
getTargetSection(llvm::MCExpr const*) | static const MCSection *getTargetSection(const MCExpr *Expr) {
if (auto SyExp = dyn_cast<MCSymbolRefExpr>(Expr)) {
if (SyExp->getSymbol().isInSection())
return &SyExp->getSymbol().getSection();
return nullptr;
}
if (auto BinOp = dyn_cast<MCBinaryExpr>(Expr)) {
auto SectionLHS = getTargetSection... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb (%rbx), %bpl
cmpb $0x2, %bpl
jne 0x19cf247
movq 0x10(%rbx), %rdi
callq 0x8b6d66
testb %al, %al
je 0x19cf245
movq 0x10(%rbx), %rdi
movl $0x1, %esi
callq 0x858016
movq 0x8(%rax), %rax
jmp 0x19cf247
xorl %eax, %eax
cmpb $0x2, %bpl
je 0x19cf288
movb (%rbx), %bpl
testb %... | /Target/WebAssembly/MCTargetDesc/WebAssemblyWasmObjectWriter.cpp |
llvm::X86IntelInstPrinter::printU8Imm(llvm::MCInst const*, unsigned int, llvm::raw_ostream&) | void X86IntelInstPrinter::printU8Imm(const MCInst *MI, unsigned Op,
raw_ostream &O) {
if (MI->getOperand(Op).isExpr())
return MI->getOperand(Op).getExpr()->print(O, &MAI);
markup(O, Markup::Immediate) << formatImm(MI->getOperand(Op).getImm() & 0xff);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl %edx, %r12d
movq 0x10(%rsi), %rax
shlq $0x4, %r12
cmpb $0x5, (%rax,%r12)
jne 0x19d46ca
addq %r12, %rax
movq 0x8(%rax), %rdi
movq 0x10(%rbx), %rdx
movq %rcx, %rsi
xorl %ecx, %ecx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp... | /Target/X86/MCTargetDesc/X86IntelInstPrinter.cpp |
llvm::DecodeInsertElementMask(unsigned int, unsigned int, unsigned int, llvm::SmallVectorImpl<int>&) | void DecodeInsertElementMask(unsigned NumElts, unsigned Idx, unsigned Len,
SmallVectorImpl<int> &ShuffleMask) {
assert((Idx + Len) <= NumElts && "Insertion out of range");
for (unsigned i = 0; i != NumElts; ++i)
ShuffleMask.push_back(i);
for (unsigned i = 0; i != Len; ++i)
Sh... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movl %edx, %r14d
movl %esi, %ebx
movl %edi, %ebp
testl %edi, %edi
je 0x19dbfe6
xorl %r12d, %r12d
movq %r15, %rdi
movl %r12d, %esi
callq 0x930830
incl %r12d
cmpl %r12d, %ebp
jne 0x19dbfd3
testl %r14d, %r14d
je 0x19dbfff
movq (%r15), %rax
movl %r14d, ... | /Target/X86/MCTargetDesc/X86ShuffleDecode.cpp |
llvm::DecodeMOVLHPSMask(unsigned int, llvm::SmallVectorImpl<int>&) | void DecodeMOVLHPSMask(unsigned NElts, SmallVectorImpl<int> &ShuffleMask) {
for (unsigned i = 0; i != NElts / 2; ++i)
ShuffleMask.push_back(i);
for (unsigned i = 0; i != NElts / 2; ++i)
ShuffleMask.push_back(NElts + i);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movl %edi, %r15d
shrl %r15d
cmpl $0x2, %edi
jb 0x19dc07d
xorl %r14d, %r14d
movq %rbx, %rdi
movl %r14d, %esi
callq 0x930830
incl %r14d
cmpl %r14d, %r15d
jne 0x19dc06a
cmpl $0x2, %ebp
jb 0x19dc093
movq %rbx, %rdi
movl %ebp, %esi
callq ... | /Target/X86/MCTargetDesc/X86ShuffleDecode.cpp |
llvm::DecodePSWAPMask(unsigned int, llvm::SmallVectorImpl<int>&) | void DecodePSWAPMask(unsigned NumElts, SmallVectorImpl<int> &ShuffleMask) {
unsigned NumHalfElts = NumElts / 2;
for (unsigned l = 0; l != NumHalfElts; ++l)
ShuffleMask.push_back(l + NumHalfElts);
for (unsigned h = 0; h != NumHalfElts; ++h)
ShuffleMask.push_back(h);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movl %edi, %r14d
shrl %r14d
cmpl $0x2, %edi
jb 0x19dc42f
xorl %r15d, %r15d
leal (%r14,%r15), %esi
movq %rbx, %rdi
callq 0x930830
incl %r15d
cmpl %r15d, %r14d
jne 0x19dc41b
cmpl $0x2, %ebp
jb 0x19dc447
xorl %ebp, %ebp
movq %rbx, %rdi
... | /Target/X86/MCTargetDesc/X86ShuffleDecode.cpp |
llvm::X86_MC::is16BitMemOperand(llvm::MCInst const&, unsigned int, llvm::MCSubtargetInfo const&) | constexpr bool operator[](unsigned I) const {
uint64_t Mask = uint64_t(1) << (I % 64);
return (Bits[I / 64] & Mask) != 0;
} | cmpq $0x0, 0xe0(%rdx)
jns 0x19df324
movl %esi, %ecx
movq 0x10(%rdi), %rax
shlq $0x4, %rcx
addq %rax, %rcx
cmpb $0x1, (%rcx)
jne 0x19df324
cmpl $0x0, 0x8(%rcx)
jne 0x19df324
leal 0x2(%rsi), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
cmpb $0x1, (%rax)
jne 0x19df324
cmpl $0x0, 0x8(%rax)
je 0x19df32e
movl $0x7, %edx
jmp 0x19df33... | /llvm/TargetParser/SubtargetFeature.h |
isMemOperand(llvm::MCInst const&, unsigned int, unsigned int) | const MCOperand &getOperand(unsigned i) const { return Operands[i]; } | movl %esi, %eax
movq 0x10(%rdi), %rdi
shlq $0x4, %rax
movl %edx, %edx
shlq $0x5, %rdx
leaq 0x3e8dd88(%rip), %rcx # 0x586d0d0
addq %rdx, %rcx
cmpb $0x1, (%rdi,%rax)
jne 0x19df380
addq %rdi, %rax
movl 0x8(%rax), %edx
testq %rdx, %rdx
je 0x19df380
movl %edx, %eax
shrl $0x3, %eax
movzwl 0x16(%rcx), %r8d
cmpl %r8d, %eax
j... | /llvm/MC/MCInst.h |
createX86MCAsmInfo(llvm::MCRegisterInfo const&, llvm::Triple const&, llvm::MCTargetOptions const&) | static MCAsmInfo *createX86MCAsmInfo(const MCRegisterInfo &MRI,
const Triple &TheTriple,
const MCTargetOptions &Options) {
bool is64Bit = TheTriple.getArch() == Triple::x86_64;
MCAsmInfo *MAI;
if (TheTriple.isOSBinFormatMachO()) {
if (... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %r15
movq %rdi, 0x10(%rsp)
movl 0x20(%rsi), %ebp
movl 0x34(%rsi), %eax
cmpl $0x3, %eax
je 0x19e0ab2
cmpl $0x5, %eax
jne 0x19e0acf
movl $0x1e8, %edi # imm = 0x1E8
callq 0x7808d0
movq %rax, %rbx
movq %rax, %rdi
movq %... | /Target/X86/MCTargetDesc/X86MCTargetDesc.cpp |
llvm::X86ELFMCAsmInfo::X86ELFMCAsmInfo(llvm::Triple const&) | X86ELFMCAsmInfo::X86ELFMCAsmInfo(const Triple &T) {
bool is64Bit = T.getArch() == Triple::x86_64;
bool isX32 = T.isX32();
// For ELF, x86-64 pointer size depends on the ABI.
// For x86-64 without the x32 ABI, pointer size is 8. For x86 and for x86-64
// with the x32 ABI, pointer size remains the default 4.
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x28caab8
leaq 0x3e96240(%rip), %rax # 0x5877bd8
movq %rax, (%rbx)
movl 0x30(%r14), %eax
xorl %ecx, %ecx
cmpl $0x12, %eax
setne %cl
shll $0x2, %ecx
movl $0x4, %edx
addl %edx, %ecx
cmpl $0x9, %eax
cmovel %edx, %ecx
xorl %eax, %eax
cmpl $0x26, 0x20(... | /Target/X86/MCTargetDesc/X86MCAsmInfo.cpp |
llvm::X86MCAsmInfoGNUCOFF::X86MCAsmInfoGNUCOFF(llvm::Triple const&) | X86MCAsmInfoGNUCOFF::X86MCAsmInfoGNUCOFF(const Triple &Triple) {
assert((Triple.isOSWindows() || Triple.isUEFI()) &&
"Windows and UEFI are the only supported COFF targets");
if (Triple.getArch() == Triple::x86_64) {
PrivateGlobalPrefix = ".L";
PrivateLabelPrefix = ".L";
CodePointerSize = 8;
... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x28ca830
leaq 0x3e96210(%rip), %rax # 0x5877d40
movq %rax, (%rbx)
movl $0x1, %eax
cmpl $0x26, 0x20(%r14)
jne 0x19e1b71
leaq 0x1850488(%rip), %rax # 0x3231fce
movq %rax, 0x58(%rbx)
movl $0x2, %ecx
movq %rcx, 0x60(%rbx)
movq %rax, 0x68(%rbx)
movq... | /Target/X86/MCTargetDesc/X86MCAsmInfo.cpp |
llvm::cl::opt<unsigned int, false, llvm::cl::parser<unsigned int>>::opt<char [24], llvm::cl::initializer<int>, llvm::cl::desc>(char const (&) [24], 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();
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
xorl %esi, %esi
xorl %edx, %edx
callq 0x7fca88
movl $0x0, 0x80(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%rbx)
movb $0x0, 0x94(%rbx)
leaq 0x3d5a231(%rip), %rax # 0x57479d8
movq %rax, 0x88(%rbx)
lea... | /llvm/Support/CommandLine.h |
(anonymous namespace)::ELFX86_32AsmBackend::~ELFX86_32AsmBackend() | ELFX86_32AsmBackend(const Target &T, uint8_t OSABI,
const MCSubtargetInfo &STI)
: ELFX86AsmBackend(T, OSABI, STI) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x3e87623(%rip), %rax # 0x58786d8
movq %rax, (%rdi)
movq 0x38(%rdi), %rdi
leaq 0x48(%rbx), %rax
cmpq %rax, %rdi
je 0x19f10ca
callq 0x780910
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x19f10dd
movl $0x30, %esi
callq 0x7800d0
movq $0x0, 0x18(%rbx)
movq %rbx, %rdi
callq 0x28c9922
movl $0x... | /Target/X86/MCTargetDesc/X86AsmBackend.cpp |
llvm::XCoreInstPrinter::printRegName(llvm::raw_ostream&, llvm::MCRegister) const | void XCoreInstPrinter::printRegName(raw_ostream &OS, MCRegister Reg) const {
OS << StringRef(getRegisterName(Reg)).lower();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
decl %edx
leaq 0x3505671(%rip), %rax # 0x4ef8b00
movzbl (%rdx,%rax), %eax
leaq 0x3505626(%rip), %rdi # 0x4ef8ac0
addq %rax, %rdi
leaq 0x20(%rsp), %r14
movq %rdi, (%r14)
callq 0x7802c0
movq %rax, 0x8(%r14)
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %r... | /Target/XCore/MCTargetDesc/XCoreInstPrinter.cpp |
LLVMInitializeARMTargetInfo | LLVM_EXTERNAL_VISIBILITY void LLVMInitializeARMTargetInfo() {
RegisterTarget<Triple::arm, /*HasJIT=*/true> X(getTheARMLETarget(), "arm",
"ARM", "ARM");
RegisterTarget<Triple::armeb, /*HasJIT=*/true> Y(getTheARMBETarget(), "armeb",
... | pushq %rbx
callq 0x19f3e6c
leaq 0x3f47167(%rip), %rdi # 0x593b058
leaq 0x35aa484(%rip), %rsi # 0x4f9e37c
leaq 0x17ef2b8(%rip), %rbx # 0x31e31b7
leaq 0xa0(%rip), %r8 # 0x19f3fa6
movq %rbx, %rdx
movq %rbx, %rcx
movl $0x1, %r9d
callq 0x290994c
callq 0x19f3e8a
leaq 0x3f47235(%rip), %rdi # 0x593b158
leaq 0x3... | /Target/ARM/TargetInfo/ARMTargetInfo.cpp |
polly::parseFunctionPipeline(llvm::StringRef, llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>&, llvm::ArrayRef<llvm::PassBuilder::PipelineElement>) | static bool
parseFunctionPipeline(StringRef Name, FunctionPassManager &FPM,
ArrayRef<PassBuilder::PipelineElement> Pipeline) {
if (llvm::parseAnalysisUtilityPasses<OwningScopAnalysisManagerFunctionProxy>(
"polly-scop-analyses", Name, FPM))
return true;
#define FUNCTION_ANALYSIS(NA... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x350c3ed(%rip), %rdi # 0x4f0248b
movl $0x13, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x19f7700
movb $0x1, %bpl
testb %al, %al
jne 0x19f634f
leaq 0x350c3dc(%rip), %rdi # 0x4f0249f
movl... | /Support/RegisterPasses.cpp |
llvm::cl::opt<polly::OptimizerChoice, false, llvm::cl::parser<polly::OptimizerChoice>>::getValueExpectedFlagDefault() const | enum ValueExpected getValueExpectedFlagDefault() const {
// If there is an ArgStr specified, then we are of the form:
//
// -opt=O2 or -opt O2 or -optO2
//
// In which case, the value is required. Otherwise if an arg str has not
// been specified, we are of the form:
//
// -... | movq 0xa0(%rdi), %rcx
xorl %eax, %eax
cmpq $0x1, 0x18(%rcx)
adcl $0x2, %eax
retq
| /llvm/Support/CommandLine.h |
llvm::cl::opt<polly::CodeGenChoice, false, llvm::cl::parser<polly::CodeGenChoice>>::printOptionValue(unsigned long, bool) const | void printOptionValue(size_t GlobalWidth, bool Force) const override {
if (Force || !this->getDefault().compare(this->getValue())) {
cl::printOptionDiff<ParserClass>(*this, Parser, this->getValue(),
this->getDefault(), GlobalWidth);
}
} | movq %rsi, %r8
movq %rdi, %rsi
testl %edx, %edx
je 0x19f7228
subq $0x18, %rsp
leaq 0x98(%rsi), %rdi
movl 0x80(%rsi), %eax
leaq 0x88(%rsi), %rcx
leaq 0x3e828ad(%rip), %r9 # 0x5879ab8
addq $0x10, %r9
leaq 0x8(%rsp), %rdx
movq %r9, (%rdx)
movb $0x1, 0xc(%rdx)
movl %eax, 0x8(%rdx)
callq 0x2b24cf0
addq $0x18, %rsp
retq
c... | /llvm/Support/CommandLine.h |
std::enable_if<!std::is_same_v<polly::ScopViewer, llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>>, void>::type llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>::addPass<polly::ScopViewer>(polly::ScopViewer&&) | LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v<PassT, PassManager>>
addPass(PassT &&Pass) {
using PassModelT =
detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>;
// Do not use make_unique or emplace_back, they cause too many template
// instantiations, causing terrible co... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x20
popq %rdi
callq 0x7808d0
movups 0x8(%rbx), %xmm0
movups %xmm0, 0x10(%rax)
leaq 0x3e82343(%rip), %rcx # 0x5879e48
addq $0x10, %rcx
movq %rcx, (%rax)
leaq 0x3e857bd(%rip), %rcx # 0x587d2d0
addq $0x10, %rcx
movq %rcx, 0x8(%rax)
movq %rsp, %rb... | /llvm/IR/PassManager.h |
llvm::PreservedAnalyses llvm::InvalidateAnalysisPass<polly::OwningInnerAnalysisManagerProxy<llvm::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>, llvm::Function>>::run<llvm::Function, llvm::AnalysisManager<llvm::Function>>(llvm::Function&, llvm::AnalysisManager<llvm::Function>&) | PreservedAnalyses run(IRUnitT &Arg, AnalysisManagerT &AM, ExtraArgTs &&...) {
auto PA = PreservedAnalyses::all();
PA.abandon<AnalysisT>();
return PA;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x20(%rdi), %rax
movq %rax, (%rdi)
movq %rax, 0x8(%rdi)
movl $0x2, %eax
movq %rax, 0x10(%rdi)
xorl %ecx, %ecx
movl %ecx, 0x18(%rdi)
leaq 0x30(%rdi), %r14
leaq 0x50(%rdi), %rdx
movq %rdx, 0x30(%rdi)
movq %rdx, 0x38(%rdi)
movq %rax, 0x40(%rdi)
movl %e... | /llvm/IR/PassManager.h |
llvm::PreservedAnalyses llvm::InvalidateAnalysisPass<polly::ScopAnalysis>::run<llvm::Function, llvm::AnalysisManager<llvm::Function>>(llvm::Function&, llvm::AnalysisManager<llvm::Function>&) | PreservedAnalyses run(IRUnitT &Arg, AnalysisManagerT &AM, ExtraArgTs &&...) {
auto PA = PreservedAnalyses::all();
PA.abandon<AnalysisT>();
return PA;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x20(%rdi), %rax
movq %rax, (%rdi)
movq %rax, 0x8(%rdi)
movl $0x2, %eax
movq %rax, 0x10(%rdi)
xorl %ecx, %ecx
movl %ecx, 0x18(%rdi)
leaq 0x30(%rdi), %r14
leaq 0x50(%rdi), %rdx
movq %rdx, 0x30(%rdi)
movq %rdx, 0x38(%rdi)
movq %rax, 0x40(%rdi)
movl %e... | /llvm/IR/PassManager.h |
std::enable_if<!std::is_same_v<llvm::InvalidateAnalysisPass<polly::ScopInfoAnalysis>, llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>>, void>::type llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>::addPass<llvm::InvalidateAnalysisPass<polly::ScopInfoAnalysis>>(llvm::Inva... | LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v<PassT, PassManager>>
addPass(PassT &&Pass) {
using PassModelT =
detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>;
// Do not use make_unique or emplace_back, they cause too many template
// instantiations, causing terrible co... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x7808d0
leaq 0x3e8178a(%rip), %rcx # 0x5879cf0
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rsp, %r14
movq %rax, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xadff9e
movq (%r14), %rdi
testq %rdi, %rdi
je 0x19f858c
movq (%rdi), %rax
callq *0x8(... | /llvm/IR/PassManager.h |
polly::FunctionToScopPassAdaptor<llvm::PassManager<polly::Scop, llvm::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>, polly::ScopStandardAnalysisResults&, polly::SPMUpdater&>>::run(llvm::Function&, llvm::AnalysisManager<llvm::Function>&) | PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM) {
ScopDetection &SD = AM.getResult<ScopAnalysis>(F);
ScopInfo &SI = AM.getResult<ScopInfoAnalysis>(F);
if (SI.empty()) {
// With no scops having been detected, no IR changes have been made and
// therefore all analyses are preserved... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rcx, %rbp
movq %rdx, %r14
movq %rsi, 0x18(%rsp)
movq %rdi, %r13
leaq 0x3f468a2(%rip), %rsi # 0x5942b28
movq %rcx, %rdi
callq 0x2a8ddb2
movq %rax, 0x8(%rsp)
leaq 0x3f4701e(%rip), %rsi # 0x59432b8
movq %... | /polly/ScopPass.h |
llvm::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>::invalidate(polly::Scop&, llvm::PreservedAnalyses const&) | inline void AnalysisManager<IRUnitT, ExtraArgTs...>::invalidate(
IRUnitT &IR, const PreservedAnalyses &PA) {
// We're done if all analyses on this IR unit are preserved.
if (PA.allAnalysesInSetPreserved<AllAnalysesOn<IRUnitT>>())
return;
// Track whether each analysis's result is invalidated in
// IsRe... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x3f42458(%rip), %rsi # 0x593ebc8
movq %rdx, 0x48(%rsp)
movq %rdx, %rdi
callq 0x19fc9b8
testb %al, %al
jne 0x19fc956
leaq 0x60(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x17abf34
leaq 0x30(%... | /llvm/IR/PassManagerImpl.h |
llvm::DenseMapBase<llvm::SmallDenseMap<llvm::AnalysisKey*, bool, 8u, llvm::DenseMapInfo<llvm::AnalysisKey*, void>, llvm::detail::DenseMapPair<llvm::AnalysisKey*, bool>>, llvm::AnalysisKey*, bool, llvm::DenseMapInfo<llvm::AnalysisKey*, void>, llvm::detail::DenseMapPair<llvm::AnalysisKey*, bool>>::find(llvm::AnalysisKey ... | iterator find(const_arg_type_t<KeyT> Val) {
BucketT *TheBucket;
if (LookupBucketFor(Val, TheBucket))
return makeIterator(TheBucket,
shouldReverseIterate<KeyT>() ? getBuckets()
: getBucketsEnd(),
*thi... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
leaq 0x10(%rsp), %r14
movq %rax, %rsi
movq %r14, %rdx
callq 0x19fca24
testb $0x1, (%rbx)
leaq 0x8(%rbx), %rcx
cmoveq 0x8(%rbx), %rcx
movl $0x8, %edx
cmovel 0x10(%rbx), %edx
shlq $0x4, %rdx
addq %rcx, %rdx
testb %al, %al
movq (... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<std::pair<llvm::AnalysisKey*, polly::Scop*>, std::_List_iterator<std::pair<llvm::AnalysisKey*, std::unique_ptr<llvm::detail::AnalysisResultConcept<polly::Scop, llvm::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>::Invalidator>, std::default_delete<llvm::detail::Analy... | const_iterator find(const_arg_type_t<KeyT> Val) const {
const BucketT *TheBucket;
if (LookupBucketFor(Val, TheBucket))
return makeConstIterator(TheBucket,
shouldReverseIterate<KeyT>() ? getBuckets()
: getBucketsEnd(... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
callq 0x19fdc1c
testb %al, %al
je 0x19fdc05
movq 0x8(%rsp), %rax
movl 0x10(%rbx), %ecx
leaq (%rcx,%rcx,2), %rdx
shlq $0x3, %rdx
addq (%rbx), %rdx
jmp 0x19fdc16
movl 0x10(%rbx), %eax
leaq (%rax,%rax,2), %rax
shlq $0x3, %rax
addq (%rbx), %rax
movq %rax, %rd... | /llvm/ADT/DenseMap.h |
void llvm::cl::apply<llvm::cl::opt<bool, false, llvm::cl::parser<bool>>, char [16], llvm::cl::desc, llvm::cl::initializer<bool>, llvm::cl::cat>(llvm::cl::opt<bool, false, llvm::cl::parser<bool>>*, char const (&) [16], llvm::cl::desc const&, llvm::cl::initializer<bool> const&, llvm::cl::cat const&) | void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq %rsi, %rdi
callq 0x7802c0
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x2b1f336
movups (%r15), %xmm0
movups %xmm0, 0x20(%r13)
movq (%r14), %rax
movb (%rax), %cl
movb %cl, ... | /llvm/Support/CommandLine.h |
llvm::SmallVectorTemplateBase<std::pair<llvm::Region*, std::unique_ptr<polly::Scop, std::default_delete<polly::Scop>>>, false>::moveElementsForGrow(std::pair<llvm::Region*, std::unique_ptr<polly::Scop, std::default_delete<polly::Scop>>>*) | size_t size() const { return Size; } | pushq %r14
pushq %rbx
pushq %rax
movl 0x8(%rdi), %eax
movq %rax, %rbx
shlq $0x4, %rbx
testq %rax, %rax
je 0x1a019c7
movq (%rdi), %rcx
leaq (%rcx,%rbx), %rdx
xorl %r8d, %r8d
leaq (%rcx,%r8), %r9
addq $0x10, %r9
movq -0x10(%r9), %r10
movq %r10, (%rsi,%r8)
movq -0x8(%r9), %r10
movq %r10, 0x8(%rsi,%r8)
movq $0x0, -0x8(%r9)... | /llvm/ADT/SmallVector.h |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::AnalysisKey*, std::unique_ptr<llvm::detail::AnalysisPassConcept<polly::Scop, llvm::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>::Invalidator, polly::ScopStandardAnalysisResults&>, std::default_delete<llvm::detail::AnalysisPassConcept<polly::Scop, llvm::A... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x1a01e09
pushq %rbx
movq (%rdi), %rdi
movl (%rsi), %r8d
movl %r8d, %eax
shrl $0x4, %eax
shrl $0x9, %r8d
xorl %eax, %r8d
decl %ecx
andl %ecx, %r8d
movl $0x1, %r10d
xorl %r9d, %r9d
movl %r8d, %ebx
shlq $0x4, %rbx
leaq (%rdi,%rbx), %r11
movq (%rdi,%rbx), %rbx
cmpq %rbx, (%rsi)
jn... | /llvm/ADT/DenseMap.h |
llvm::SmallDenseMap<llvm::AnalysisKey*, llvm::TinyPtrVector<llvm::AnalysisKey*>, 2u, llvm::DenseMapInfo<llvm::AnalysisKey*, void>, llvm::detail::DenseMapPair<llvm::AnalysisKey*, llvm::TinyPtrVector<llvm::AnalysisKey*>>>::swap(llvm::SmallDenseMap<llvm::AnalysisKey*, llvm::TinyPtrVector<llvm::AnalysisKey*>, 2u, llvm::Den... | void swap(SmallDenseMap& RHS) {
unsigned TmpNumEntries = RHS.NumEntries;
RHS.NumEntries = NumEntries;
NumEntries = TmpNumEntries;
std::swap(NumTombstones, RHS.NumTombstones);
const KeyT EmptyKey = this->getEmptyKey();
const KeyT TombstoneKey = this->getTombstoneKey();
if (Small && RHS.Small... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl (%rsi), %eax
movl %eax, %ecx
andl $-0x2, %ecx
movl (%rdi), %edx
andl $-0x2, %edx
andl $0x1, %eax
orl %edx, %eax
movl %eax, (%rsi)
movl (%rdi), %eax
movl 0x4(%rdi), %edx
andl $0x1, %eax
orl %ecx, %eax
movl %eax, ... | /llvm/ADT/DenseMap.h |
llvm::DenseMapBase<llvm::DenseMap<polly::Scop*, std::__cxx11::list<std::pair<llvm::AnalysisKey*, std::unique_ptr<llvm::detail::AnalysisResultConcept<polly::Scop, llvm::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>::Invalidator>, std::default_delete<llvm::detail::AnalysisResultConcept<polly::Scop, ll... | 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;
... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %eax
testl %eax, %eax
jne 0x1a02ff1
cmpl $0x0, 0xc(%rbx)
je 0x1a0305c
shll $0x2, %eax
movl 0x10(%rbx), %r15d
cmpl %r15d, %eax
setae %al
cmpl $0x41, %r15d
setb %cl
orb %al, %cl
jne 0x1a03016
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1a030fc
testq... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<std::pair<llvm::AnalysisKey*, polly::Scop*>, std::_List_iterator<std::pair<llvm::AnalysisKey*, std::unique_ptr<llvm::detail::AnalysisResultConcept<polly::Scop, llvm::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>::Invalidator>, std::default_delete<llvm::detail::AnalysisResultConcept<po... | void shrink_and_clear() {
unsigned OldNumBuckets = NumBuckets;
unsigned OldNumEntries = NumEntries;
this->destroyAll();
// Reduce the number of buckets.
unsigned NewNumBuckets = 0;
if (OldNumEntries)
NewNumBuckets = std::max(64, 1 << (Log2_32_Ceil(OldNumEntries) + 1));
if (NewNumBucke... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
movl 0x10(%rdi), %eax
testl %ecx, %ecx
je 0x1a0307e
decl %ecx
je 0x1a03082
bsrl %ecx, %edx
xorl $0x1f, %edx
jmp 0x1a03087
xorl %ebp, %ebp
jmp 0x1a0309d
movl $0x20, %edx
movb $0x21, %cl
subb %dl, %cl
movl $0x1, %edx
shll %cl, %edx
cmpl $0x41, %edx
mov... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<polly::Scop*, std::__cxx11::list<std::pair<llvm::AnalysisKey*, std::unique_ptr<llvm::detail::AnalysisResultConcept<polly::Scop, llvm::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>::Invalidator>, std::default_delete<llvm::detail::AnalysisResultConcept<polly::Scop, llvm::AnalysisManager... | void shrink_and_clear() {
unsigned OldNumBuckets = NumBuckets;
unsigned OldNumEntries = NumEntries;
this->destroyAll();
// Reduce the number of buckets.
unsigned NewNumBuckets = 0;
if (OldNumEntries)
NewNumBuckets = std::max(64, 1 << (Log2_32_Ceil(OldNumEntries) + 1));
if (NewNumBucke... | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %ebp
movl 0x10(%rdi), %r14d
callq 0x1a03230
testl %ebp, %ebp
je 0x1a0311f
decl %ebp
je 0x1a03123
bsrl %ebp, %eax
xorl $0x1f, %eax
jmp 0x1a03128
xorl %ebp, %ebp
jmp 0x1a0313e
movl $0x20, %eax
movb $0x21, %cl
subb %al, %cl
movl $0x1, %eax
shll %cl, %eax
cmp... | /llvm/ADT/DenseMap.h |
polly::parseScopPass(llvm::StringRef, llvm::PassManager<polly::Scop, llvm::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>, polly::ScopStandardAnalysisResults&, polly::SPMUpdater&>&, llvm::PassInstrumentationCallbacks*) | static bool parseScopPass(StringRef Name, ScopPassManager &SPM,
PassInstrumentationCallbacks *PIC) {
#define SCOP_ANALYSIS(NAME, CREATE_PASS) \
if (llvm::parseAnalysisUtilityPasses< \
std::remove_reference... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x34fff5e(%rip), %rdi # 0x4f033d3
movl $0x14, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x1a039b5
movb $0x1, %bpl
testb %al, %al
jne 0x1a039a6
leaq 0x34fff4e(%rip), %rdi # 0x4... | /Support/RegisterPasses.cpp |
std::enable_if<!std::is_same_v<polly::MaximalStaticExpansionPrinterPass, llvm::PassManager<polly::Scop, llvm::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>, polly::ScopStandardAnalysisResults&, polly::SPMUpdater&>>, void>::type llvm::PassManager<polly::Scop, llvm::AnalysisManager<polly::Scop, polly:... | LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v<PassT, PassManager>>
addPass(PassT &&Pass) {
using PassModelT =
detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>;
// Do not use make_unique or emplace_back, they cause too many template
// instantiations, causing terrible co... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x10
popq %rdi
callq 0x7808d0
movq (%rbx), %rcx
leaq 0x3e76a2a(%rip), %rdx # 0x587a8d8
addq $0x10, %rdx
movq %rdx, (%rax)
movq %rcx, 0x8(%rax)
movq %rsp, %rbx
movq %rax, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x19fdf3a
movq (%rbx), %rdi
tes... | /llvm/IR/PassManager.h |
std::enable_if<!std::is_same_v<llvm::InvalidateAnalysisPass<llvm::PassInstrumentationAnalysis>, llvm::PassManager<polly::Scop, llvm::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>, polly::ScopStandardAnalysisResults&, polly::SPMUpdater&>>, void>::type llvm::PassManager<polly::Scop, llvm::AnalysisMana... | LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v<PassT, PassManager>>
addPass(PassT &&Pass) {
using PassModelT =
detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>;
// Do not use make_unique or emplace_back, they cause too many template
// instantiations, causing terrible co... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x7808d0
leaq 0x3e76722(%rip), %rcx # 0x587a618
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rsp, %r14
movq %rax, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x19fdf3a
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1a03f1c
movq (%rdi), %rax
callq *0x8... | /llvm/IR/PassManager.h |
std::enable_if<!std::is_same_v<llvm::RequireAnalysisPass<llvm::PassInstrumentationAnalysis, polly::Scop, llvm::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>, polly::ScopStandardAnalysisResults&, polly::SPMUpdater&>, llvm::PassManager<polly::Scop, llvm::AnalysisManager<polly::Scop, polly::ScopStandar... | LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v<PassT, PassManager>>
addPass(PassT &&Pass) {
using PassModelT =
detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>;
// Do not use make_unique or emplace_back, they cause too many template
// instantiations, causing terrible co... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x7808d0
leaq 0x3e7671e(%rip), %rcx # 0x587a658
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rsp, %r14
movq %rax, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x19fdf3a
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1a03f60
movq (%rdi), %rax
callq *0x8... | /llvm/IR/PassManager.h |
llvm::RequireAnalysisPass<llvm::PassInstrumentationAnalysis, polly::Scop, llvm::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>, polly::ScopStandardAnalysisResults&, polly::SPMUpdater&>::run(polly::Scop&, llvm::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>&, polly::ScopStandardAnal... | PreservedAnalyses run(Scop &L, ScopAnalysisManager &AM,
ScopStandardAnalysisResults &AR, SPMUpdater &) {
(void)AM.template getResult<AnalysisT>(L, AR);
return PreservedAnalyses::all();
} | pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x3fa2703(%rip), %rsi # 0x59a6888
movq %rcx, %rdi
movq %r8, %rcx
callq 0x19fe936
leaq 0x20(%rbx), %rax
movq %rax, (%rbx)
movq %rax, 0x8(%rbx)
movl $0x2, %eax
movq %rax, 0x10(%rbx)
xorl %ecx, %ecx
movl %ecx, 0x18(%rbx)
leaq 0x50(%rbx), %rdx
movq %rdx, 0x30(%rbx)
movq %r... | /polly/ScopPass.h |
llvm::InvalidateAnalysisPass<polly::IslAstAnalysis>::printPipeline(llvm::raw_ostream&, llvm::function_ref<llvm::StringRef (llvm::StringRef)>) | void printPipeline(raw_ostream &OS,
function_ref<StringRef(StringRef)> MapClassName2PassName) {
auto ClassName = AnalysisT::name();
auto PassName = MapClassName2PassName(ClassName);
OS << "invalidate<" << PassName << '>';
} | pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
callq 0x1a0243c
movq %rbx, %rdi
movq %rax, %rsi
callq *%r14
movq %rax, %rbx
movq %rdx, %r14
leaq 0x1a809c4(%rip), %rsi # 0x3484d55
movl $0xb, %edx
movq %r15, %rdi
callq 0x7f9ba8
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x7f9... | /llvm/IR/PassManager.h |
llvm::DenseMapBase<llvm::DenseMap<std::pair<llvm::Value*, llvm::Value*>, llvm::ReassociatePass::PairMapValue, llvm::DenseMapInfo<std::pair<llvm::Value*, llvm::Value*>, void>, llvm::detail::DenseMapPair<std::pair<llvm::Value*, llvm::Value*>, llvm::ReassociatePass::PairMapValue>>, std::pair<llvm::Value*, llvm::Value*>, l... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %eax
testq %rax, %rax
je 0x1a07a70
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rbx
leaq (%rax,%rax,8), %rax
leaq (%rbx,%rax,8), %r14
addq $0x28, %rbx
movq $-0x1000, %r15 # imm = 0xF000
movq $-0x2000, %r12 # imm = 0xE000
movq -0x28(%rbx), %rax
movq -0x20(%rbx),... | /llvm/ADT/DenseMap.h |
void llvm::cl::apply<llvm::cl::opt<bool, false, llvm::cl::parser<bool>>, char [18], llvm::cl::desc, llvm::cl::OptionHidden, llvm::cl::cat>(llvm::cl::opt<bool, false, llvm::cl::parser<bool>>*, char const (&) [18], llvm::cl::desc const&, llvm::cl::OptionHidden const&, llvm::cl::cat const&) | void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq %rsi, %rdi
callq 0x7802c0
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x2b1f336
movups (%r15), %xmm0
movups %xmm0, 0x20(%r13)
movl (%r14), %eax
movzwl 0xa(%r13), %ecx
shll... | /llvm/Support/CommandLine.h |
llvm::detail::PassModel<llvm::Function, llvm::ReassociatePass, llvm::AnalysisManager<llvm::Function>>::~PassModel() | explicit PassModel(PassT Pass) : Pass(std::move(Pass)) {} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x3e722c7(%rip), %rax # 0x587ad90
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x238(%rdi), %r14
xorl %r15d, %r15d
leaq (%r14,%r15), %rdi
callq 0x1a079b8
movq (%r14,%r15), %rdi
movl 0x10(%r14,%r15), %eax
shlq $0x3, %rax
leaq (%rax,%rax,8), %rsi
movl $0x8, %edx
callq 0x... | /llvm/IR/PassManagerInternal.h |
llvm::cl::list<int, bool, llvm::cl::parser<int>>::list<char [17], llvm::cl::desc, llvm::cl::OptionHidden, llvm::cl::MiscFlags, llvm::cl::cat>(char const (&) [17], llvm::cl::desc const&, llvm::cl::OptionHidden const&, llvm::cl::MiscFlags const&, llvm::cl::cat const&) | explicit list(const Mods &... Ms)
: Option(ZeroOrMore, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
movl $0x1, %esi
xorl %edx, %edx
callq 0x7fca88
xorps %xmm0, %xmm0
movups %xmm0, 0xa0(%r14)
movups %xmm0, 0x90(%r14)
movups %xmm0, 0x80(%r14)
movb $0x... | /llvm/Support/CommandLine.h |
runIslScheduleOptimizerUsingNPM(polly::Scop&, llvm::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>&, polly::ScopStandardAnalysisResults&, polly::SPMUpdater&, llvm::raw_ostream*) | static llvm::PreservedAnalyses
runIslScheduleOptimizerUsingNPM(Scop &S, ScopAnalysisManager &SAM,
ScopStandardAnalysisResults &SAR, SPMUpdater &U,
raw_ostream *OS) {
DependenceAnalysis::Result &Deps = SAM.getResult<DependenceAnalysis>(S, SAR);
auto Get... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, 0x20(%rsp)
movq %rcx, %r13
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x3f36ae5(%rip), %rsi # 0x59418c8
movq %rdx, %rdi
movq %r15, %rdx
callq 0x19fe936
movq %rax, %r12
addq $0x8, %r12
leaq 0x30(%rsp), %rbp
movq %r12, (%rbp)
movq 0x... | /Transform/ScheduleOptimizer.cpp |
polly::createIslScheduleOptimizerPrinterLegacyPass(llvm::raw_ostream&) | Pass *polly::createIslScheduleOptimizerPrinterLegacyPass(raw_ostream &OS) {
return new IslScheduleOptimizerPrinterLegacyPass(OS);
} | pushq %rbx
movq %rdi, %rbx
movl $0x30, %edi
callq 0x7808d0
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
leaq 0x3f3509b(%rip), %rdx # 0x5940051
movq %rdx, 0x10(%rax)
movl $0x0, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0x3e7019c(%rip), %rcx # 0x587b168
movq %rcx, (%rax)
movq %rbx, 0x28(%rax)
popq %rbx
retq
| /Transform/ScheduleOptimizer.cpp |
(anonymous namespace)::IslScheduleOptimizerWrapperPass::printScop(llvm::raw_ostream&, polly::Scop&) const | void IslScheduleOptimizerWrapperPass::printScop(raw_ostream &OS, Scop &) const {
runScheduleOptimizerPrinter(OS, LastSchedule);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
leaq 0x8(%rsp), %r15
movq $0x0, (%r15)
movq 0x38(%rdi), %rdi
callq 0x1b55ef1
movq %rax, %rbx
movq %rax, (%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x1a0dcd7
testq %rbx, %rbx
je 0x1a0b582
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jm... | /Transform/ScheduleOptimizer.cpp |
(anonymous namespace)::ScheduleTreeOptimizer::isProfitableSchedule(polly::Scop&, isl::schedule) | bool ScheduleTreeOptimizer::isProfitableSchedule(Scop &S,
isl::schedule NewSchedule) {
// To understand if the schedule has been optimized we check if the schedule
// has changed at all.
// TODO: We can improve this by tracking if any necessarily beneficial
// tr... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
movq (%rsi), %rdi
callq 0x1b563e1
movq %rax, %rbx
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1a54a92
movq (%r15), %rdi
movq %rbx, %rsi
callq 0x1b8f3dc
movl %eax, %ebp
leaq 0x8(%rsp), %r14
movq $0x0, (%r14)
movl $0x18, %edi
callq 0... | /Transform/ScheduleOptimizer.cpp |
isl::schedule_node_leaf isl::schedule_node::as<isl::schedule_node_leaf>() const | T schedule_node::as() const
{
if (isa<T>().is_false())
isl_die(ctx().get(), isl_error_invalid, "not an object of the requested subtype", return T());
return T(copy());
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x1a0d6b3
callq 0x1b57765
movl %eax, %ebp
movl $0x18, %edi
callq 0x7808d0
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x3e6d98a(%rip), %rcx # 0x587aff8
addq $0x10, %rcx
movq %rcx, (... | /External/isl/include/isl/isl-noexceptions.h |
void llvm::cl::apply<llvm::cl::opt<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, false, llvm::cl::parser<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, llvm::cl::desc, llvm::cl::OptionHidden, llvm::cl::initializer<char [3]>, llvm::cl::cat>(llvm::cl::o... | void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
} | pushq %r14
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rdi, %r14
movups (%rsi), %xmm0
movups %xmm0, 0x20(%rdi)
movl (%rdx), %eax
movzwl 0xa(%rdi), %edx
shll $0x5, %eax
andl $0x60, %eax
andl $-0x61, %edx
orl %eax, %edx
movw %dx, 0xa(%rdi)
movq %rcx, %rdi
movq %r14, %rsi
callq 0x1a0e408
movq (%rbx), %rsi
movq %r14, %rdi
a... | /llvm/Support/CommandLine.h |
llvm::SmallVectorTemplateBase<isl::schedule_node_band, false>::moveElementsForGrow(isl::schedule_node_band*) | void SmallVectorTemplateBase<T, TriviallyCopyable>::moveElementsForGrow(
T *NewElts) {
// Move the elements over.
this->uninitialized_move(this->begin(), this->end(), NewElts);
// Destroy the original elements.
destroy_range(this->begin(), this->end());
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %r15d
testq %r15, %r15
je 0x1a1324e
movq %rsi, %r14
movq (%rbx), %r12
shlq $0x3, %r15
xorl %r13d, %r13d
movq $0x0, (%r14,%r13)
movq (%r12,%r13), %rdi
callq 0x1b578ac
movq %rax, (%r14,%r13)
addq $0x8, %r13
cmpq %r13, %r15
jne 0x1a1323... | /llvm/ADT/SmallVector.h |
isl::union_set const* llvm::SmallVectorTemplateCommon<isl::union_set, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<isl::union_set, false>>(llvm::SmallVectorTemplateBase<isl::union_set, false>*, isl::union_set const&, unsigned long) | static const T *reserveForParamAndGetAddressImpl(U *This, const T &Elt,
size_t N) {
size_t NewSize = This->size() + N;
if (LLVM_LIKELY(NewSize <= This->capacity()))
return &Elt;
bool ReferencesStorage = false;
int64_t Index = -1;
if (!U::Take... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x8(%rdi), %ecx
movl 0xc(%rdi), %eax
addq %rcx, %rdx
cmpq %rax, %rdx
ja 0x1a135e4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
movq (%rdi), %rax
cmpq %rbx, %rax
setbe %sil
leaq (%rax,%rcx,8), %rcx... | /llvm/ADT/SmallVector.h |
llvm::SmallVectorTemplateBase<isl::union_set, false>::moveElementsForGrow(isl::union_set*) | void SmallVectorTemplateBase<T, TriviallyCopyable>::moveElementsForGrow(
T *NewElts) {
// Move the elements over.
this->uninitialized_move(this->begin(), this->end(), NewElts);
// Destroy the original elements.
destroy_range(this->begin(), this->end());
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %r15d
testq %r15, %r15
je 0x1a136cc
movq %rsi, %r14
movq (%rbx), %r12
shlq $0x3, %r15
xorl %r13d, %r13d
movq $0x0, (%r14,%r13)
movq (%r12,%r13), %rdi
callq 0x1b8cb99
movq %rax, (%r14,%r13)
addq $0x8, %r13
cmpq %r13, %r15
jne 0x1a136a... | /llvm/ADT/SmallVector.h |
(anonymous namespace)::printSchedule(llvm::raw_ostream&, isl::union_map const&, int) | void printSchedule(raw_ostream &OS, const isl::union_map &Schedule,
int indent) {
for (isl::map Map : Schedule.get_map_list())
OS.indent(indent) << Map << "\n";
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x1b8d36a
movq %rsp, %r12
movq %rax, (%r12)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x1a11702
movq (%r15), %rbp
movl 0x8(%r15), %r14d
cmpq %rbp, %r12
setne %al
testl %r14d, %r14d... | /Transform/FlattenSchedule.cpp |
llvm::Pass* llvm::callDefaultCtor<(anonymous namespace)::FlattenSchedulePrinterLegacyPass, true>() | Pass *callDefaultCtor() {
return new PassName();
} | pushq %rbx
movl $0x30, %edi
callq 0x7808d0
movq %rax, %rbx
callq 0x2b7e507
xorl %ecx, %ecx
movq %rcx, 0x8(%rbx)
leaq 0x3f2748b(%rip), %rdx # 0x594005d
movq %rdx, 0x10(%rbx)
movl $0x0, 0x18(%rbx)
movq %rcx, 0x20(%rbx)
leaq 0x3e62700(%rip), %rcx # 0x587b2e8
movq %rcx, (%rbx)
movq %rax, 0x28(%rbx)
movq %rbx, %rax
popq... | /llvm/PassSupport.h |
(anonymous namespace)::isDimBoundedByConstant(isl::set, unsigned int) | bool isDimBoundedByConstant(isl::set Set, unsigned dim) {
auto ParamDims = unsignedFromIslSize(Set.dim(isl::dim::param));
Set = Set.project_out(isl::dim::param, 0, ParamDims);
Set = Set.project_out(isl::dim::set, 0, dim);
auto SetDims = unsignedFromIslSize(Set.tuple_dim());
assert(SetDims >= 1);
Set = Set.p... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
movl $0x1, %esi
callq 0x1b0f2bb
movl %eax, %ebp
leaq 0x8(%rsp), %r14
movq $0x0, (%r14)
movl $0x18, %edi
callq 0x7808d0
movabsq $0x100000001, %r15 # imm = 0x100000001
movq %r15, 0x8(%rax)
leaq 0x3e60bad(%rip), ... | /Transform/FlattenAlgo.cpp |
llvm::cl::opt<unsigned int, false, llvm::cl::parser<unsigned int>>::opt<char [21], llvm::cl::desc, llvm::cl::initializer<int>, llvm::cl::cat, llvm::cl::OptionHidden>(char const (&) [21], llvm::cl::desc const&, llvm::cl::initializer<int> const&, llvm::cl::cat const&, llvm::cl::OptionHidden const&) | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r14
xorl %esi, %esi
xorl %edx, %edx
callq 0x7fca88
movl $0x0, 0x80(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%r14)
movb $0x0, 0x94(%r14)
leaq 0x3d2cb97... | /llvm/Support/CommandLine.h |
(anonymous namespace)::ForwardingAction::canForward(std::function<bool ()>, llvm::ArrayRef<std::pair<llvm::Value*, polly::ScopStmt*>>, bool) | static ForwardingAction canForward(std::function<bool()> Execute,
ArrayRef<KeyTy> Depends,
bool IsProfitable) {
ForwardingAction Result;
Result.Decision =
IsProfitable ? FD_CanForwardProfitably : FD_CanForwardLeaf;
Result.Exec... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x8(%rdi), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
leaq 0xbf(%rip), %rax # 0x1a1d8de
movq %rax, 0x20(%rbx)
leaq 0xb4(%rip), %rax # 0x1a1d8de
movq %rax, 0x18(%rbx)
leaq 0x28(%rbx), %r12
leaq ... | /Transform/ForwardOpTree.cpp |
llvm::DenseMapBase<llvm::DenseMap<std::pair<llvm::Value*, polly::ScopStmt*>, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<std::pair<llvm::Value*, polly::ScopStmt*>, void>, llvm::detail::DenseSetPair<std::pair<llvm::Value*, polly::ScopStmt*>>>, std::pair<llvm::Value*, polly::ScopStmt*>, llvm::detail::DenseSetEmpty, l... | void moveFromOldBuckets(BucketT *OldBucketsBegin, BucketT *OldBucketsEnd) {
initEmpty();
// Insert all the old elements.
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
for (BucketT *B = OldBucketsBegin, *E = OldBucketsEnd; B != E; ++B) {
if (!KeyInfoT::isEqu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq $0x0, 0x8(%rdi)
movl 0x10(%rdi), %eax
testq %rax, %rax
je 0x1a1fbf1
movq (%r15), %rcx
shlq $0x4, %rax
addq %rcx, %rax
movq $-0x1000, %rdx # imm = 0xF000
movq %rdx, (%rcx)
movq %rdx,... | /llvm/ADT/DenseMap.h |
void llvm::cl::apply<llvm::cl::opt<bool, false, llvm::cl::parser<bool>>, llvm::cl::desc, llvm::cl::cat, llvm::cl::initializer<bool>, llvm::cl::OptionHidden>(llvm::cl::opt<bool, false, llvm::cl::parser<bool>>*, llvm::cl::desc const&, llvm::cl::cat const&, llvm::cl::initializer<bool> const&, llvm::cl::OptionHidden const&... | void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
} | pushq %r15
pushq %r14
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdi, %r15
movups (%rsi), %xmm0
movups %xmm0, 0x20(%rdi)
movq (%rdx), %rsi
callq 0x2b1f3c8
movq (%r14), %rax
movb (%rax), %cl
movb %cl, 0x80(%r15)
movb $0x1, 0x91(%r15)
movb (%rax), %al
movb %al, 0x90(%r15)
movl (%rbx), %eax
movzwl 0xa(%r15), %ecx
shl... | /llvm/Support/CommandLine.h |
polly::createDeLICMPrinterLegacyPass(llvm::raw_ostream&) | llvm::Pass *polly::createDeLICMPrinterLegacyPass(llvm::raw_ostream &OS) {
return new DeLICMPrinterLegacyPass(OS);
} | pushq %rbx
movq %rdi, %rbx
movl $0x30, %edi
callq 0x7808d0
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
leaq 0x3f1fda6(%rip), %rdx # 0x59405b9
movq %rdx, 0x10(%rax)
movl $0x0, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0x3e5adbf(%rip), %rcx # 0x587b5e8
movq %rcx, (%rax)
movq %rbx, 0x28(%rax)
popq %rbx
retq
| /Transform/DeLICM.cpp |
polly::isConflicting(isl::union_set, isl::union_set, isl::union_map, isl::union_map, isl::union_set, isl::union_set, isl::union_map, isl::union_map, llvm::raw_ostream*, unsigned int) | bool polly::isConflicting(
isl::union_set ExistingOccupied, isl::union_set ExistingUnused,
isl::union_map ExistingKnown, isl::union_map ExistingWrites,
isl::union_set ProposedOccupied, isl::union_set ProposedUnused,
isl::union_map ProposedKnown, isl::union_map ProposedWrites,
llvm::raw_ostream *OS, ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r9, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movq %rcx, (%rsp)
movq %rdx, %rbp
movq %rsi, %r12
xorl %ebx, %ebx
leaq 0x30(%rsp), %r14
movq %rbx, (%r14)
movq (%rdi), %rdi
callq 0x1b8cb99
movq %rax, %r15
movq %rax, (%r14)
leaq 0x28(%rsp), %r14
... | /Transform/DeLICM.cpp |
polly::ZoneAlgorithm::ZoneAlgorithm(char const*, polly::Scop*, llvm::LoopInfo*) | ZoneAlgorithm::ZoneAlgorithm(const char *PassName, Scop *S, LoopInfo *LI)
: PassName(PassName), IslCtx(S->getSharedIslCtx()), S(S), LI(LI),
Schedule(S->getSchedule()) {
auto Domains = S->getDomains();
Schedule = Schedule.intersect_domain(Domains);
ParamSpace = Schedule.get_space();
ScatterSpace = get... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rdi, %rbx
movq %rsi, (%rdi)
movq (%rdx), %rax
movq %rax, 0x8(%rdi)
movq 0x8(%rdx), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
je 0x1a25ec3
movq 0x3ed5c23(%rip), %rdx # 0x58fbad8
cmpb $0x0, (%rdx)
je 0x1a25ebf
incl 0x8(%rax)... | /Transform/ZoneAlgo.cpp |
polly::ZoneAlgorithm::makeUnknownForDomain(polly::ScopStmt*) const | isl::map ZoneAlgorithm::makeUnknownForDomain(ScopStmt *Stmt) const {
return ::makeUnknownForDomain(getDomainFor(Stmt));
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x1a27e50
movq (%r14), %r14
movq %r14, %rdi
callq 0x1b10b72
movq %rax, %rdi
callq 0x1b15bba
movq %rax, (%rbx)
testq %r14, %r14
je 0x1a2737d
movq %r14, %rdi
callq 0x1b139c2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /Transform/ZoneAlgo.cpp |
polly::ZoneAlgorithm::getScalarReachingDefinition(polly::ScopStmt*) | isl::map ZoneAlgorithm::getScalarReachingDefinition(ScopStmt *Stmt) {
auto &Result = ScalarReachDefZone[Stmt];
if (!Result.is_null())
return Result;
auto Domain = getDomainFor(Stmt);
Result = computeScalarReachingDefinition(Schedule, Domain, false, true);
simplify(Result);
return Result;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x50(%rsp), %rsi
movq %rdx, (%rsi)
leaq 0x18(%r15), %rdi
callq 0x1a2a5fe
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x1a2751e
movq $0x0, (%rbx)
callq 0x1b10b80
movq %rax, (%rbx)
jmp 0x1a277bc
movq %rax,... | /Transform/ZoneAlgo.cpp |
polly::ZoneAlgorithm::getScalarReachingDefinition(isl::set) | isl::map ZoneAlgorithm::getScalarReachingDefinition(isl::set DomainDef) {
auto DomId = DomainDef.get_tuple_id();
auto *Stmt = static_cast<ScopStmt *>(isl_id_get_user(DomId.get()));
auto StmtResult = getScalarReachingDefinition(Stmt);
return StmtResult.intersect_range(DomainDef);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq (%rdx), %rdi
callq 0x1b10100
movq %rax, %r14
movq %rax, %rdi
callq 0x1aff14a
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x1a274dc
movq (%r15), %rdi
callq 0x1b10b72... | /Transform/ZoneAlgo.cpp |
polly::ZoneAlgorithm::isNormalized(isl::map) | isl::boolean ZoneAlgorithm::isNormalized(isl::map Map) {
isl::space Space = Map.get_space();
isl::space RangeSpace = Space.range();
isl::boolean IsWrapping = RangeSpace.is_wrapping();
if (!IsWrapping.is_true())
return !IsWrapping;
isl::space Unwrapped = RangeSpace.unwrap();
isl::id OutTupleId = Unwrap... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r13
movq %rdi, %rbx
movq (%rdx), %rdi
callq 0x1b0fb77
movq %rax, %r14
movq %rax, %rdi
callq 0x1b6fd4e
movq %rax, %rdi
callq 0x1b720d3
movq %rax, %r15
movq %rax, %rdi
callq 0x1b736f4
movl %eax, %ebp
movq $0x0, 0x20(%rsp)
movl ... | /Transform/ZoneAlgo.cpp |
llvm::SmallDenseMap<llvm::PHINode*, isl::union_map, 4u, llvm::DenseMapInfo<llvm::PHINode*, void>, llvm::detail::DenseMapPair<llvm::PHINode*, isl::union_map>>::init(unsigned int) | void init(unsigned InitBuckets) {
Small = true;
if (InitBuckets > InlineBuckets) {
Small = false;
new (getLargeRep()) LargeRep(allocateBuckets(InitBuckets));
}
this->BaseT::initEmpty();
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
movl %eax, %ecx
orl $0x1, %ecx
movl %ecx, (%rdi)
cmpl $0x5, %esi
jb 0x1a29cd6
movl %esi, %ebp
andl $-0x2, %eax
movl %eax, (%rbx)
movl %esi, %edi
shlq $0x4, %rdi
movl $0x8, %esi
callq 0x2b410ec
movq %rax, 0x8(%rbx)
movl %ebp, 0x10(%rbx)
leaq 0x8(%rbx), %... | /llvm/ADT/DenseMap.h |
llvm::SmallDenseMap<llvm::PHINode*, isl::union_map, 4u, llvm::DenseMapInfo<llvm::PHINode*, void>, llvm::detail::DenseMapPair<llvm::PHINode*, isl::union_map>>::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... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x5, %esi
jb 0x1a2a055
decl %ebp
movl %ebp, %eax
shrl %eax
orl %ebp, %eax
movl %eax, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x4, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x8, %ecx
orl %eax, %ecx
movl %... | /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::DenseMap<std::pair<polly::ScopStmt*, polly::ScopStmt*>, isl::map, llvm::DenseMapInfo<std::pair<polly::ScopStmt*, polly::ScopStmt*>, void>, llvm::detail::DenseMapPair<std::pair<polly::ScopStmt*, polly::ScopStmt*>, isl::map>>, std::pair<polly::ScopStmt*, polly::ScopStmt*>, isl::map, llvm::De... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x1a2a3d4
pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %rdi
movl (%rsi), %eax
movl 0x8(%rsi), %r8d
movl %eax, %r9d
shrl $0x4, %r9d
shrl $0x9, %eax
xorl %r9d, %eax
movl %r8d, %r9d
shrl $0x4, %r9d
shrl $0x9, %r8d
xorl %r9d, %r8d
shlq $0x20, %rax
orq %rax, %r8
movabsq $-0x40a7b89... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<std::pair<polly::ScopStmt*, polly::ScopStmt*>, isl::map, llvm::DenseMapInfo<std::pair<polly::ScopStmt*, polly::ScopStmt*>, void>, llvm::detail::DenseMapPair<std::pair<polly::ScopStmt*, polly::ScopStmt*>, isl::map>>::grow(unsigned int) | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBu... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x10(%rdi), %r15d
decl %esi
movl %esi, %eax
shrl %eax
orl %esi, %eax
movl %eax, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x4, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x8, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x10, %eax
orl %ecx, %eax
incl %ea... | /llvm/ADT/DenseMap.h |
llvm::SmallDenseMap<llvm::Value*, isl::set, 4u, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, isl::set>>::init(unsigned int) | void init(unsigned InitBuckets) {
Small = true;
if (InitBuckets > InlineBuckets) {
Small = false;
new (getLargeRep()) LargeRep(allocateBuckets(InitBuckets));
}
this->BaseT::initEmpty();
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %eax
movl %eax, %ecx
orl $0x1, %ecx
movl %ecx, (%rdi)
cmpl $0x5, %esi
jb 0x1a2dc2e
movl %esi, %ebp
andl $-0x2, %eax
movl %eax, (%rbx)
movl %esi, %edi
shlq $0x4, %rdi
movl $0x8, %esi
callq 0x2b410ec
movq %rax, 0x8(%rbx)
movl %ebp, 0x10(%rbx)
leaq 0x8(%rbx), %... | /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::SmallDenseMap<llvm::Value*, isl::set, 4u, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, isl::set>>, llvm::Value*, isl::set, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, isl::set>>::LookupBucketFor<llvm::Value*>(llvm::Va... | const BucketT *getBuckets() const {
return Small ? getInlineBuckets() : getLargeRep()->Buckets;
} | leaq 0x8(%rdi), %rcx
testb $0x1, (%rdi)
cmoveq 0x8(%rdi), %rcx
movl $0x4, %r8d
cmovel 0x10(%rdi), %r8d
testl %r8d, %r8d
je 0x1a2dde9
pushq %rbx
movl (%rsi), %edi
movl %edi, %eax
shrl $0x4, %eax
shrl $0x9, %edi
xorl %eax, %edi
decl %r8d
andl %r8d, %edi
movl $0x1, %r10d
xorl %r9d, %r9d
movl %edi, %ebx
shlq $0x4, %rbx
lea... | /llvm/ADT/DenseMap.h |
llvm::Pass* llvm::callDefaultCtor<(anonymous namespace)::SimplifyWrapperPass, true>() | Pass *callDefaultCtor() {
return new PassName();
} | pushq %rax
movl $0x68, %edi
callq 0x7808d0
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
leaq 0x3f11eb0(%rip), %rdx # 0x59405c4
movq %rdx, 0x10(%rax)
movl %ecx, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0x3e4cf82(%rip), %rdx # 0x587b6a8
movq %rdx, (%rax)
movl %ecx, 0x28(%rax)
movb $0x0, 0x60(%rax)
popq %rcx
retq
| /llvm/PassSupport.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.