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 MCSymbolRefExpr *RefExp = nullptr;
const MCExpr *Rhs = nullptr;
if (const MCBinaryExpr *BinExpr = dyn_cast<MCBinaryExpr>(Op.getExpr())) {
RefExp = cast<MCSymbolRefExpr>(BinExpr->getLHS());
Rhs = BinExpr->getRHS();
} else
RefExp = cast<MCSymbolRefExpr>(Op.getExpr());
O << RefExp->getSymbol().getName();
// The variant kind VK_PPC_NOTOC needs to be handled as a special case
// because we do not want the assembly to print out the @notoc at the
// end like __tls_get_addr(x@tlsgd)@notoc. Instead we want it to look
// like __tls_get_addr@notoc(x@tlsgd).
if (RefExp->getKind() == MCSymbolRefExpr::VK_PPC_NOTOC)
O << '@' << MCSymbolRefExpr::getVariantKindName(RefExp->getKind());
O << '(';
printOperand(MI, OpNo + 1, STI, O);
O << ')';
if (RefExp->getKind() != MCSymbolRefExpr::VK_None &&
RefExp->getKind() != MCSymbolRefExpr::VK_PPC_NOTOC)
O << '@' << MCSymbolRefExpr::getVariantKindName(RefExp->getKind());
if (Rhs) {
SmallString<0> Buf;
raw_svector_ostream Tmp(Buf);
Rhs->print(Tmp, &MAI);
if (isdigit(Buf[0]))
O << '+';
O << Buf;
}
}
|
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, (%rsp)
movq 0x10(%r14), %r14
movq 0x10(%r14), %rax
xorl %esi, %esi
testb $0x1, 0x8(%rax)
movl $0x0, %edx
je 0x199472a
movq -0x8(%rax), %rsi
movq (%rsi), %rdx
addq $0x18, %rsi
movq %rbx, %rdi
callq 0x7f9ba8
cmpw $0x7b, 0x1(%r14)
jne 0x1994779
movq 0x20(%rbx), %rax
cmpq 0x18(%rbx), %rax
jae 0x1994754
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%rbx)
movb $0x40, (%rax)
movq %rbx, %r13
jmp 0x1994764
movq %rbx, %rdi
movl $0x40, %esi
callq 0x2b7d68e
movq %rax, %r13
movzwl 0x1(%r14), %edi
callq 0x28e1c04
movq %r13, %rdi
movq %rax, %rsi
callq 0x7f9ba8
movq 0x20(%rbx), %rax
cmpq 0x18(%rbx), %rax
jae 0x1994790
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%rbx)
movb $0x28, (%rax)
jmp 0x199479d
movq %rbx, %rdi
movl $0x28, %esi
callq 0x2b7d68e
incl %ebp
movq %r15, %rdi
movq %r12, %rsi
movl %ebp, %edx
movq %rbx, %r8
callq 0x19940f0
movq 0x20(%rbx), %rax
cmpq 0x18(%rbx), %rax
jae 0x19947c6
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%rbx)
movb $0x29, (%rax)
jmp 0x19947d3
movq %rbx, %rdi
movl $0x29, %esi
callq 0x2b7d68e
movq (%rsp), %rbp
movzwl 0x1(%r14), %eax
testl %eax, %eax
je 0x1994824
cmpl $0x7b, %eax
je 0x1994824
movq 0x20(%rbx), %rax
cmpq 0x18(%rbx), %rax
jae 0x19947ff
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%rbx)
movb $0x40, (%rax)
movq %rbx, %r12
jmp 0x199480f
movq %rbx, %rdi
movl $0x40, %esi
callq 0x2b7d68e
movq %rax, %r12
movzwl 0x1(%r14), %edi
callq 0x28e1c04
movq %r12, %rdi
movq %rax, %rsi
callq 0x7f9ba8
testq %rbp, %rbp
je 0x19948fa
leaq 0x20(%rsp), %r14
movq %r14, -0x18(%r14)
xorps %xmm0, %xmm0
movups %xmm0, -0x10(%r14)
leaq 0x20(%rsp), %r12
movl $0x2, 0x8(%r12)
movb $0x0, 0x28(%r12)
movl $0x1, 0x2c(%r12)
movups %xmm0, 0x10(%r12)
movq $0x0, 0x20(%r12)
leaq 0x3f65787(%rip), %rax # 0x58f9ff8
addq $0x10, %rax
movq %rax, (%r12)
leaq 0x8(%rsp), %r13
movq %r13, 0x30(%r12)
movq %r12, %rdi
callq 0x7fa22e
movq 0x10(%r15), %rdx
movq %rbp, %rdi
movq %r12, %rsi
xorl %ecx, %ecx
callq 0x28e14a4
movq (%r13), %rax
movsbl (%rax), %eax
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0x19948cf
movq 0x20(%rbx), %rax
cmpq 0x18(%rbx), %rax
jae 0x19948c2
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%rbx)
movb $0x2b, (%rax)
jmp 0x19948cf
movq %rbx, %rdi
movl $0x2b, %esi
callq 0x2b7d68e
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x2b7d704
leaq 0x20(%rsp), %rdi
callq 0x2b7e98e
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x19948fa
callq 0x780910
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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':
return true;
}
}
|
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 = 0x8C009
shrl %cl, %eax
jmp 0x19955b3
xorl %eax, %eax
andb $0x1, %al
retq
|
/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 0x28faec8
movq 0x10(%rbx), %rdi
leaq 0x25e6492(%rip), %rsi # 0x3f805cd
movl $0x2, %edx
callq 0x7f9ba8
movq 0x10(%rbx), %rsi
movq %r14, %rdi
movq %r15, %rdx
xorl %ecx, %ecx
callq 0x28e14a4
movq 0x10(%rbx), %rdi
movq 0x20(%rdi), %rax
cmpq 0x18(%rdi), %rax
jae 0x199a17b
leaq 0x1(%rax), %rcx
movq %rcx, 0x20(%rdi)
movb $0xa, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movl $0xa, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2b7d68e
|
/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 = MI.getOperand(OpNo);
assert(!MO.isReg() && "Not expecting a register for this operand.");
if (MO.isImm())
return getMachineOpValue(MI, MO, Fixups, STI);
// Add a fixup for the immediate field.
Fixups.push_back(MCFixup::create(0, MO.getExpr(), Fixup));
return 0;
}
|
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 $0x0, 0x8(%rsi)
movl %r9d, 0xc(%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x18a7ff6
movq (%rbx), %rcx
movl 0x8(%rbx), %edx
leaq (%rdx,%rdx,2), %rdx
movq 0x10(%rax), %rsi
movq %rsi, 0x10(%rcx,%rdx,8)
movups (%rax), %xmm0
movups %xmm0, (%rcx,%rdx,8)
incl 0x8(%rbx)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
nop
|
/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() % 16) &&
"Expecting an immediate that is a multiple of 16");
return ((getMachineOpValue(MI, MO, Fixups, STI) >> 4) & 0xFFF);
}
// Otherwise add a fixup for the displacement field.
Fixups.push_back(MCFixup::create(IsLittleEndian ? 0 : 2, MO.getExpr(),
(MCFixupKind)PPC::fixup_ppc_half16dq));
return 0;
}
|
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), %rcx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq %rcx, (%rsi)
movl %eax, 0x8(%rsi)
movl $0x8a, 0xc(%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x18a7ff6
movq (%rbx), %rcx
movl 0x8(%rbx), %edx
leaq (%rdx,%rdx,2), %rdx
movq 0x10(%rax), %rsi
movq %rsi, 0x10(%rcx,%rdx,8)
movups (%rax), %xmm0
movups %xmm0, (%rcx,%rdx,8)
incl 0x8(%rbx)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
|
/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_PPC_HIGH:
OS << "@high";
break;
case VK_PPC_HIGHA:
OS << "@higha";
break;
case VK_PPC_HIGHER:
OS << "@higher";
break;
case VK_PPC_HIGHERA:
OS << "@highera";
break;
case VK_PPC_HIGHEST:
OS << "@highest";
break;
case VK_PPC_HIGHESTA:
OS << "@highesta";
break;
}
}
|
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), %rsi # 0x4fbd26a
movl $0x6, %edx
jmp 0x199e265
leaq 0x361f03c(%rip), %rsi # 0x4fbd24d
movl $0x3, %edx
jmp 0x199e265
leaq 0x361f03f(%rip), %rsi # 0x4fbd25e
movl $0x5, %edx
jmp 0x199e265
leaq 0x361f067(%rip), %rsi # 0x4fbd294
jmp 0x199e252
leaq 0x361f011(%rip), %rsi # 0x4fbd247
movl $0x2, %edx
jmp 0x199e265
leaq 0x361f033(%rip), %rsi # 0x4fbd277
movl $0x7, %edx
jmp 0x199e265
leaq 0x361f033(%rip), %rsi # 0x4fbd285
movl $0x8, %edx
jmp 0x199e265
leaq 0x361f043(%rip), %rsi # 0x4fbd2a3
movl $0x9, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7f9ba8
|
/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::move(Emitter)),
LastLabel(nullptr) {}
|
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
movq %r9, %rcx
movq %r14, %r8
callq 0x28dfacc
movq (%r14), %rdi
testq %rdi, %rdi
je 0x199e63b
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x10(%rsp)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x199e653
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rsp)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x199e66b
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
leaq 0x3eb2dbd(%rip), %rax # 0x5851438
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x19d0(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
|
/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), std::move(OW),
std::move(Emitter));
}
|
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
leaq 0x8(%rsp), %rcx
movq %rsi, (%rcx)
movq %rax, (%r15)
movq (%r14), %rsi
leaq 0x18(%rsp), %r15
movq %rsi, (%r15)
movq %rax, (%r14)
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %r8
callq 0x199eb00
movq (%r15), %rdi
testq %rdi, %rdi
je 0x199ec90
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x199eca9
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x199ecc2
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x10(%rsp)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/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.isImm())
return printOperand(MI, OpNo, STI, O);
if (PrintBranchImmAsAddress) {
uint64_t Target = Address + MO.getImm();
if (!STI.hasFeature(RISCV::Feature64Bit))
Target &= 0xffffffff;
markup(O, Markup::Target) << formatHex(Target);
} else {
markup(O, Markup::Target) << formatImm(MO.getImm());
}
}
|
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 %r15, %rdi
movq %rbx, %rsi
movq %r9, %rdx
movl $0x2, %ecx
callq 0x28e4bf6
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x28e4b7a
movq (%r15), %rdi
movq %r12, %rsi
callq 0x2b7d21a
movq %r15, %rdi
jmp 0x19a8ae6
movq %rbx, %rdi
movl %ecx, %edx
movq %r9, %r8
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x19a87be
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %r9, %rdx
movl $0x2, %ecx
callq 0x28e4bf6
movq 0x8(%r15), %rdx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x188cd0a
movq (%r14), %rdi
movq %r15, %rsi
callq 0x2b7d21a
movq %r14, %rdi
callq 0x28e4cbc
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/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, FS);
}
|
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 0x19aa6c9
movq %rbx, %rdi
callq 0x2b05414
leaq 0x2211aa0(%rip), %rcx # 0x3bbc156
leaq 0x2211aa6(%rip), %r14 # 0x3bbc163
testb %al, %al
cmovneq %rcx, %r14
movl $0xc, %r15d
movq %r13, 0x60(%rsp)
movq %r12, 0x68(%rsp)
movl $0x120, %edi # imm = 0x120
callq 0x7808d0
movq %rax, %r12
leaq 0x3eba0e9(%rip), %rax # 0x58647d0
movq %rax, 0x80(%rsp)
movq $0x1d, 0x88(%rsp)
leaq 0x3eb61ce(%rip), %rax # 0x58608d0
movq %rax, 0x70(%rsp)
movq $0xf3, 0x78(%rsp)
movups 0x80(%rsp), %xmm0
movups %xmm0, 0x20(%rsp)
movups 0x70(%rsp), %xmm0
movups %xmm0, 0x10(%rsp)
movups 0x60(%rsp), %xmm0
movups %xmm0, (%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rsp)
leaq 0x313cfb1(%rip), %rax # 0x4ae76f0
movq %rax, 0x40(%rsp)
leaq 0x313cb75(%rip), %rax # 0x4ae72c0
movq %rax, 0x38(%rsp)
leaq 0x313c259(%rip), %rax # 0x4ae69b0
movq %rax, 0x30(%rsp)
movq $0x0, 0x58(%rsp)
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r15, %rcx
movq %r14, %r8
movq %r15, %r9
callq 0x28fa010
leaq 0x3ebab3d(%rip), %rax # 0x58652c0
movq %rax, (%r12)
movq %r12, %rax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/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), %eax
jmp 0x19aacf0
xorl %eax, %eax
retq
movq 0x10(%rdi), %rax
movl 0x8(%rax), %eax
addl $-0x2c, %eax
testl $0xfffffffb, %eax # imm = 0xFFFFFFFB
setne %al
retq
|
/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::RegReg;
case RISCV::ADDI:
case RISCV::ADDIW:
case RISCV::XORI:
case RISCV::SLLI:
case RISCV::SRLI:
case RISCV::SLLI_UW:
case RISCV::RORI:
case RISCV::BSETI:
case RISCV::BCLRI:
case RISCV::TH_SRRI:
return RISCVMatInt::RegImm;
}
}
|
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 # imm = 0x2F3F
jg 0x19abee0
addl $0xffffd17c, %ecx # imm = 0xFFFFD17C
cmpl $0x2, %ecx
jb 0x19abef5
movl $0x3, %eax
retq
addl $0xffffcd61, %ecx # imm = 0xFFFFCD61
cmpl $0x12, %ecx
ja 0x19abef5
movl $0x40005, %eax # imm = 0x40005
btl %ecx, %eax
jmp 0x19abef5
cmpl $0x2f40, %ecx # imm = 0x2F40
je 0x19abef5
movl $0x1, %eax
cmpl $0x2f4d, %ecx # imm = 0x2F4D
jne 0x19abef7
xorl %eax, %eax
retq
|
/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 $0x70000003, %r8d # imm = 0x70000003
callq 0x28e0cf8
addq $0x38, %rsp
retq
|
/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::MCSection const*, void>, llvm::detail::DenseMapPair<llvm::MCSection const*, RISCVELFStreamer::ElfMappingSymbol>>::clear()
|
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, %rcx
andq %rcx, %rdx
andl $0x1, %ecx
negq %rcx
addq %rdx, %rcx
addq $0x2, %rcx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
addq $0x10, %rax
xorl %edx, %edx
movdqa 0x120862b(%rip), %xmm1 # 0x2bb5020
movdqa 0x1208633(%rip), %xmm2 # 0x2bb5030
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movq %rdx, %xmm4
pshufd $0x44, %xmm4, %xmm4 # xmm4 = xmm4[0,1,0,1]
por %xmm1, %xmm4
pxor %xmm2, %xmm4
movdqa %xmm4, %xmm5
pcmpgtd %xmm0, %xmm5
pcmpeqd %xmm0, %xmm4
pshufd $0xf5, %xmm4, %xmm6 # xmm6 = xmm4[1,1,3,3]
pand %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm4 # xmm4 = xmm5[1,1,3,3]
por %xmm6, %xmm4
movd %xmm4, %esi
notl %esi
testb $0x1, %sil
je 0x19aca49
movq $-0x1000, -0x10(%rax) # imm = 0xF000
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %esi
testb $0x1, %sil
je 0x19aca5f
movq $-0x1000, (%rax) # imm = 0xF000
addq $0x2, %rdx
addq $0x20, %rax
cmpq %rdx, %rcx
jne 0x19aca05
movq $0x0, 0x8(%rdi)
retq
nop
|
/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().first] = LastEMS;
LastEMS = LastMappingSymbols.lookup(Section);
MCELFStreamer::changeSection(Section, Subsection);
}
|
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
jmp 0x19acb4d
xorl %eax, %eax
leaq 0x10(%rsp), %r13
movq %rax, (%r13)
movq %r12, %rdi
movq %r13, %rsi
callq 0x19ad148
movl %ebx, 0x8(%rax)
movq %r14, (%r13)
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %r12, %rdi
callq 0x19ad196
testb %al, %al
je 0x19acb86
movq 0x8(%rsp), %rax
movl 0x8(%rax), %ebp
movl %ebp, 0x19e8(%r15)
movq %r15, %rdi
movq %r14, %rsi
movl 0x4(%rsp), %edx
callq 0x28dfd04
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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->moveFromOldBuckets(OldBuckets, OldBuckets+OldNumBuckets);
// Free the old table.
deallocate_buffer(OldBuckets, sizeof(BucketT) * OldNumBuckets,
alignof(BucketT));
}
|
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, %ecx
orl %eax, %ecx
incl %ecx
cmpl $0x41, %ecx
movl $0x40, %edi
cmovael %ecx, %edi
movl %edi, 0x10(%r15)
shlq $0x4, %rdi
movl $0x8, %esi
callq 0x2b410ec
movq %rax, (%r15)
testq %r14, %r14
je 0x19ad31c
shlq $0x4, %rbx
leaq (%r14,%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x19ad3e4
movl $0x8, %edx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x2b410f1
movq $0x0, 0x8(%r15)
movl 0x10(%r15), %ecx
testq %rcx, %rcx
je 0x19ad3dd
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x1, %ecx
negq %rcx
addq %rdx, %rcx
addq $0x2, %rcx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
addq $0x10, %rax
xorl %edx, %edx
movdqa 0x1207cba(%rip), %xmm1 # 0x2bb5020
movdqa 0x1207cc2(%rip), %xmm2 # 0x2bb5030
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movq %rdx, %xmm4
pshufd $0x44, %xmm4, %xmm4 # xmm4 = xmm4[0,1,0,1]
por %xmm1, %xmm4
pxor %xmm2, %xmm4
movdqa %xmm4, %xmm5
pcmpgtd %xmm0, %xmm5
pcmpeqd %xmm0, %xmm4
pshufd $0xf5, %xmm4, %xmm6 # xmm6 = xmm4[1,1,3,3]
pand %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm4 # xmm4 = xmm5[1,1,3,3]
por %xmm6, %xmm4
movd %xmm4, %esi
notl %esi
testb $0x1, %sil
je 0x19ad3ba
movq $-0x1000, -0x10(%rax) # imm = 0xF000
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %esi
testb $0x1, %sil
je 0x19ad3d0
movq $-0x1000, (%rax) # imm = 0xF000
addq $0x2, %rdx
addq $0x20, %rax
cmpq %rdx, %rcx
jne 0x19ad376
popq %rbx
popq %r14
popq %r15
retq
nop
|
/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.getOperand(OpNo);
MCInstrDesc const &Desc = MCII.get(MI.getOpcode());
unsigned MIFrm = RISCVII::getFormat(Desc.TSFlags);
// If the destination is an immediate, there is nothing to do.
if (MO.isImm())
return MO.getImm();
assert(MO.isExpr() &&
"getImmOpValue expects only expressions or immediates");
const MCExpr *Expr = MO.getExpr();
MCExpr::ExprKind Kind = Expr->getKind();
RISCV::Fixups FixupKind = RISCV::fixup_riscv_invalid;
bool RelaxCandidate = false;
if (Kind == MCExpr::Target) {
const RISCVMCExpr *RVExpr = cast<RISCVMCExpr>(Expr);
switch (RVExpr->getKind()) {
case RISCVMCExpr::VK_RISCV_None:
case RISCVMCExpr::VK_RISCV_Invalid:
case RISCVMCExpr::VK_RISCV_32_PCREL:
llvm_unreachable("Unhandled fixup kind!");
case RISCVMCExpr::VK_RISCV_TPREL_ADD:
// tprel_add is only used to indicate that a relocation should be emitted
// for an add instruction used in TP-relative addressing. It should not be
// expanded as if representing an actual instruction operand and so to
// encounter it here is an error.
llvm_unreachable(
"VK_RISCV_TPREL_ADD should not represent an instruction operand");
case RISCVMCExpr::VK_RISCV_LO:
if (MIFrm == RISCVII::InstFormatI)
FixupKind = RISCV::fixup_riscv_lo12_i;
else if (MIFrm == RISCVII::InstFormatS)
FixupKind = RISCV::fixup_riscv_lo12_s;
else
llvm_unreachable("VK_RISCV_LO used with unexpected instruction format");
RelaxCandidate = true;
break;
case RISCVMCExpr::VK_RISCV_HI:
FixupKind = RISCV::fixup_riscv_hi20;
RelaxCandidate = true;
break;
case RISCVMCExpr::VK_RISCV_PCREL_LO:
if (MIFrm == RISCVII::InstFormatI)
FixupKind = RISCV::fixup_riscv_pcrel_lo12_i;
else if (MIFrm == RISCVII::InstFormatS)
FixupKind = RISCV::fixup_riscv_pcrel_lo12_s;
else
llvm_unreachable(
"VK_RISCV_PCREL_LO used with unexpected instruction format");
RelaxCandidate = true;
break;
case RISCVMCExpr::VK_RISCV_PCREL_HI:
FixupKind = RISCV::fixup_riscv_pcrel_hi20;
RelaxCandidate = true;
break;
case RISCVMCExpr::VK_RISCV_GOT_HI:
FixupKind = RISCV::fixup_riscv_got_hi20;
break;
case RISCVMCExpr::VK_RISCV_TPREL_LO:
if (MIFrm == RISCVII::InstFormatI)
FixupKind = RISCV::fixup_riscv_tprel_lo12_i;
else if (MIFrm == RISCVII::InstFormatS)
FixupKind = RISCV::fixup_riscv_tprel_lo12_s;
else
llvm_unreachable(
"VK_RISCV_TPREL_LO used with unexpected instruction format");
RelaxCandidate = true;
break;
case RISCVMCExpr::VK_RISCV_TPREL_HI:
FixupKind = RISCV::fixup_riscv_tprel_hi20;
RelaxCandidate = true;
break;
case RISCVMCExpr::VK_RISCV_TLS_GOT_HI:
FixupKind = RISCV::fixup_riscv_tls_got_hi20;
break;
case RISCVMCExpr::VK_RISCV_TLS_GD_HI:
FixupKind = RISCV::fixup_riscv_tls_gd_hi20;
break;
case RISCVMCExpr::VK_RISCV_CALL:
FixupKind = RISCV::fixup_riscv_call;
RelaxCandidate = true;
break;
case RISCVMCExpr::VK_RISCV_CALL_PLT:
FixupKind = RISCV::fixup_riscv_call_plt;
RelaxCandidate = true;
break;
case RISCVMCExpr::VK_RISCV_TLSDESC_HI:
FixupKind = RISCV::fixup_riscv_tlsdesc_hi20;
break;
case RISCVMCExpr::VK_RISCV_TLSDESC_LOAD_LO:
FixupKind = RISCV::fixup_riscv_tlsdesc_load_lo12;
break;
case RISCVMCExpr::VK_RISCV_TLSDESC_ADD_LO:
FixupKind = RISCV::fixup_riscv_tlsdesc_add_lo12;
break;
case RISCVMCExpr::VK_RISCV_TLSDESC_CALL:
FixupKind = RISCV::fixup_riscv_tlsdesc_call;
break;
}
} else if ((Kind == MCExpr::SymbolRef &&
cast<MCSymbolRefExpr>(Expr)->getKind() ==
MCSymbolRefExpr::VK_None) ||
Kind == MCExpr::Binary) {
// FIXME: Sub kind binary exprs have chance of underflow.
if (MIFrm == RISCVII::InstFormatJ) {
FixupKind = RISCV::fixup_riscv_jal;
} else if (MIFrm == RISCVII::InstFormatB) {
FixupKind = RISCV::fixup_riscv_branch;
} else if (MIFrm == RISCVII::InstFormatCJ) {
FixupKind = RISCV::fixup_riscv_rvc_jump;
} else if (MIFrm == RISCVII::InstFormatCB) {
FixupKind = RISCV::fixup_riscv_rvc_branch;
} else if (MIFrm == RISCVII::InstFormatI) {
FixupKind = RISCV::fixup_riscv_12_i;
}
}
assert(FixupKind != RISCV::fixup_riscv_invalid && "Unhandled expression!");
Fixups.push_back(
MCFixup::create(0, Expr, MCFixupKind(FixupKind), MI.getLoc()));
++MCNumFixups;
// Ensure an R_RISCV_RELAX relocation will be emitted if linker relaxation is
// enabled and the current fixup will result in a relocation that may be
// relaxed.
if (EnableRelax && RelaxCandidate) {
const MCConstantExpr *Dummy = MCConstantExpr::create(0, Ctx);
Fixups.push_back(
MCFixup::create(0, Dummy, MCFixupKind(RISCV::fixup_riscv_relax),
MI.getLoc()));
++MCNumFixups;
}
return 0;
}
|
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), %rdx
movl (%rsi), %esi
movq (%rdx), %rdx
shlq $0x5, %rsi
subq %rsi, %rdx
movl 0x18(%rdx), %esi
andl $0x1f, %esi
movq 0x8(%rcx), %rcx
movzbl (%rcx), %edi
movl $0x9a, %edx
movb $0x1, %bpl
testl %edi, %edi
je 0x19b3f3d
cmpl $0x2, %edi
je 0x19b3f32
cmpl $0x4, %edi
jne 0x19b3ff9
movl 0x18(%rcx), %edi
decl %edi
cmpl $0x10, %edi
ja 0x19b3ff9
leaq 0x31e215b(%rip), %r8 # 0x4b96070
movslq (%r8,%rdi,4), %rdi
addq %r8, %rdi
jmpq *%rdi
xorl %edx, %edx
cmpl $0x3, %esi
setne %dl
leal 0x81(,%rdx,2), %edx
jmp 0x19b3ff7
cmpw $0x0, 0x1(%rcx)
jne 0x19b3ff9
cmpl $0x6, %esi
jle 0x19b3f5f
cmpl $0x7, %esi
je 0x19b3f77
cmpl $0xf, %esi
je 0x19b3f7e
cmpl $0x10, %esi
jne 0x19b3ff9
movl $0x90, %edx
jmp 0x19b3ff9
cmpl $0x3, %esi
je 0x19b3f85
cmpl $0x5, %esi
jne 0x19b3ff9
movl $0x8f, %edx
jmp 0x19b3ff9
movl $0x8e, %edx
jmp 0x19b3ff9
movl $0x91, %edx
jmp 0x19b3ff9
movl $0x82, %edx
jmp 0x19b3ff9
movl $0x98, %edx
jmp 0x19b3ff9
movl $0x93, %edx
jmp 0x19b3ff7
movl $0x97, %edx
jmp 0x19b3ff9
xorl %edx, %edx
cmpl $0x3, %esi
setne %dl
addl $0x85, %edx
jmp 0x19b3ff7
xorl %edx, %edx
cmpl $0x3, %esi
setne %dl
addl $0x89, %edx
jmp 0x19b3ff7
movl $0x96, %edx
jmp 0x19b3ff9
movl $0x80, %edx
jmp 0x19b3ff7
movl $0x88, %edx
jmp 0x19b3ff7
movl $0x8c, %edx
jmp 0x19b3ff9
movl $0x99, %edx
jmp 0x19b3ff9
movl $0x84, %edx
jmp 0x19b3ff7
movl $0x87, %edx
jmp 0x19b3ff9
movl $0x92, %edx
xorl %ebp, %ebp
btl $0x9, %eax
setae %r13b
movq 0x8(%r14), %rax
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %rcx, (%rsi)
movl $0x0, 0x8(%rsi)
movl %edx, 0xc(%rsi)
movq %rax, 0x10(%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x18a7ff6
movq (%rbx), %rcx
movl 0x8(%rbx), %edx
leaq (%rdx,%rdx,2), %rdx
movq 0x10(%rax), %rsi
movq %rsi, 0x10(%rcx,%rdx,8)
movups (%rax), %xmm0
movups %xmm0, (%rcx,%rdx,8)
incl 0x8(%rbx)
xorl %r12d, %r12d
orb %bpl, %r13b
jne 0x19b40af
movq 0x8(%r15), %rsi
xorl %r12d, %r12d
xorl %edi, %edi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x28e1cba
movq 0x8(%r14), %rcx
movq %rsp, %rsi
xorps %xmm0, %xmm0
movaps %xmm0, (%rsi)
movq %rax, (%rsi)
movabsq $0x9400000000, %rax # imm = 0x9400000000
movq %rax, 0x8(%rsi)
movq %rcx, 0x10(%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x18a7ff6
movq (%rbx), %rcx
movl 0x8(%rbx), %edx
leaq (%rdx,%rdx,2), %rdx
movq 0x10(%rax), %rsi
movq %rsi, 0x10(%rcx,%rdx,8)
movups (%rax), %xmm0
movups %xmm0, (%rcx,%rdx,8)
incl 0x8(%rbx)
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x8d, %edx
jmp 0x19b3ff9
nop
|
/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.getImm();
else if (MO.isExpr())
MO.getExpr()->print(O, MAI);
else
llvm_unreachable("Invalid operand");
}
|
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
movq %r14, %rdi
movq %rcx, %rdx
xorl %ecx, %ecx
callq 0x28e4bf6
movq 0x8(%rbx), %rsi
movq (%r14), %rdi
callq 0x2b7d122
movq %r14, %rdi
callq 0x28e4cbc
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%rbx), %rdi
movq %rcx, %rsi
xorl %ecx, %ecx
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x28e14a4
movq 0x20(%rcx), %rax
cmpq 0x18(%rcx), %rax
jae 0x19ba1e5
leaq 0x1(%rax), %rdx
movq %rdx, 0x20(%rcx)
movb $0x30, (%rax)
jmp 0x19ba1b1
movq %rcx, %rdi
movl $0x30, %esi
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x2b7d68e
nop
|
/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)
movups %xmm0, 0x18(%rax)
movl $0xc40, 0x28(%rax) # imm = 0xC40
popq %rcx
retq
|
/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_cast<uint64_t>(MO.getImm());
if (MO.isExpr()) {
unsigned MIBitSize = MCII.get(MI.getOpcode()).getSize() * 8;
uint32_t RawBitOffset = getOperandBitOffset(MI, OpNum, STI);
unsigned OpBitSize =
SystemZ::MCFixupKindInfos[Kind - FirstTargetFixupKind].TargetSize;
uint32_t BitOffset = MIBitSize - RawBitOffset - OpBitSize;
Fixups.push_back(MCFixup::create(BitOffset >> 3, MO.getExpr(),
(MCFixupKind)Kind, MI.getLoc()));
return 0;
}
llvm_unreachable("Unexpected operand type!");
}
|
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 %rcx
movzbl 0x5(%rax,%rcx), %ebp
shll $0x3, %ebp
movq %rsi, %rdi
movl %edx, %esi
callq 0x19c5ea4
subl %eax, %ebp
addl $-0x8, %ebp
shrl $0x3, %ebp
movq 0x8(%r15), %rax
movq 0x8(%r14), %rcx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %rax, (%rsi)
movl %ebp, 0x8(%rsi)
movl $0x85, 0xc(%rsi)
movq %rcx, 0x10(%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x18a7ff6
movq (%rbx), %rcx
movl 0x8(%rbx), %edx
leaq (%rdx,%rdx,2), %rdx
movq 0x10(%rax), %rsi
movq %rsi, 0x10(%rcx,%rdx,8)
movups (%rax), %xmm0
movups %xmm0, (%rcx,%rdx,8)
incl 0x8(%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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_cast<uint64_t>(MO.getImm());
if (MO.isExpr()) {
unsigned MIBitSize = MCII.get(MI.getOpcode()).getSize() * 8;
uint32_t RawBitOffset = getOperandBitOffset(MI, OpNum, STI);
unsigned OpBitSize =
SystemZ::MCFixupKindInfos[Kind - FirstTargetFixupKind].TargetSize;
uint32_t BitOffset = MIBitSize - RawBitOffset - OpBitSize;
Fixups.push_back(MCFixup::create(BitOffset >> 3, MO.getExpr(),
(MCFixupKind)Kind, MI.getLoc()));
return 0;
}
llvm_unreachable("Unexpected operand type!");
}
|
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 %rcx
movzbl 0x5(%rax,%rcx), %ebp
movq %rsi, %rdi
movl %edx, %esi
callq 0x19c5ea4
notl %eax
shrl $0x3, %eax
addl %ebp, %eax
andl $0x1fffffff, %eax # imm = 0x1FFFFFFF
movq 0x8(%r15), %rcx
movq 0x8(%r14), %rdx
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq %rcx, (%rsi)
movl %eax, 0x8(%rsi)
movl $0x89, 0xc(%rsi)
movq %rdx, 0x10(%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x18a7ff6
movq (%rbx), %rcx
movl 0x8(%rbx), %edx
leaq (%rdx,%rdx,2), %rdx
movq 0x10(%rax), %rsi
movq %rsi, 0x10(%rcx,%rdx,8)
movups (%rax), %xmm0
movups %xmm0, (%rcx,%rdx,8)
incl 0x8(%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/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);
MAI->addInitialFrameState(Inst);
return MAI;
}
|
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, -0x58(%r15)
movb $0x7, -0x38(%r15)
xorps %xmm0, %xmm0
movups %xmm0, -0x30(%r15)
movups %xmm0, -0x20(%r15)
movq %r15, -0x10(%r15)
movq %rcx, -0x8(%r15)
movb $0x0, (%r15)
movl %eax, -0x50(%r15)
movq %rcx, -0x48(%r15)
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x28ca1a4
movq 0x48(%r14), %rdi
cmpq %r15, %rdi
je 0x19c8a6a
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x7800d0
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x19c8a81
movq 0x48(%rsp), %rsi
subq %rdi, %rsi
callq 0x7800d0
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/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},
{"fixup_ve_lo32", 0, 32, 0},
{"fixup_ve_pc_hi32", 0, 32, MCFixupKindInfo::FKF_IsPCRel},
{"fixup_ve_pc_lo32", 0, 32, MCFixupKindInfo::FKF_IsPCRel},
{"fixup_ve_got_hi32", 0, 32, 0},
{"fixup_ve_got_lo32", 0, 32, 0},
{"fixup_ve_gotoff_hi32", 0, 32, 0},
{"fixup_ve_gotoff_lo32", 0, 32, 0},
{"fixup_ve_plt_hi32", 0, 32, 0},
{"fixup_ve_plt_lo32", 0, 32, 0},
{"fixup_ve_tls_gd_hi32", 0, 32, 0},
{"fixup_ve_tls_gd_lo32", 0, 32, 0},
{"fixup_ve_tpoff_hi32", 0, 32, 0},
{"fixup_ve_tpoff_lo32", 0, 32, 0},
};
if (Kind < FirstTargetFixupKind)
return MCAsmBackend::getFixupKindInfo(Kind);
assert(unsigned(Kind - FirstTargetFixupKind) < getNumFixupKinds() &&
"Invalid kind!");
return Infos[Kind - FirstTargetFixupKind];
}
|
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::BlockType::F32)
.Case("f64", WebAssembly::BlockType::F64)
.Case("v128", WebAssembly::BlockType::V128)
.Case("funcref", WebAssembly::BlockType::Funcref)
.Case("externref", WebAssembly::BlockType::Externref)
.Case("exnref", WebAssembly::BlockType::Exnref)
.Case("void", WebAssembly::BlockType::Void)
.Default(WebAssembly::BlockType::Invalid);
}
|
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 %rcx, %rbx
jmp 0x19cb5d6
xorl %ebx, %ebx
movq %rbx, %rax
shrq $0x20, %rax
movq %r14, %rcx
xorq $0x3, %rcx
orq %rax, %rcx
jne 0x19cb606
leaq 0x36ca5a1(%rip), %rsi # 0x5095b91
movq %r15, %rdi
movq %r14, %rdx
callq 0x780c70
leaq 0x7e(%r12), %rcx
testl %eax, %eax
cmoveq %rcx, %rbx
cmpq $0x3, %r14
jne 0x19cb631
movq %rbx, %rax
andq %r12, %rax
jne 0x19cb631
leaq 0x2662277(%rip), %rsi # 0x402d892
movq %r15, %rdi
movq %r14, %rdx
callq 0x780c70
leaq 0x7d(%r12), %rcx
testl %eax, %eax
cmoveq %rcx, %rbx
cmpq $0x3, %r14
jne 0x19cb65c
movq %rbx, %rax
andq %r12, %rax
jne 0x19cb65c
leaq 0x2a5e114(%rip), %rsi # 0x442975a
movq %r15, %rdi
movq %r14, %rdx
callq 0x780c70
leaq 0x7c(%r12), %rcx
testl %eax, %eax
cmoveq %rcx, %rbx
cmpq $0x4, %r14
jne 0x19cb687
movq %rbx, %rax
andq %r12, %rax
jne 0x19cb687
leaq 0x3320383(%rip), %rsi # 0x4ceb9f4
movq %r15, %rdi
movq %r14, %rdx
callq 0x780c70
leaq 0x7b(%r12), %rcx
testl %eax, %eax
cmoveq %rcx, %rbx
cmpq $0x7, %r14
jne 0x19cb6b2
movq %rbx, %rax
andq %r12, %rax
jne 0x19cb6b2
leaq 0x365730d(%rip), %rsi # 0x50229a9
movq %r15, %rdi
movq %r14, %rdx
callq 0x780c70
leaq 0x70(%r12), %rcx
testl %eax, %eax
cmoveq %rcx, %rbx
cmpq $0x9, %r14
jne 0x19cb6dd
movq %rbx, %rax
andq %r12, %rax
jne 0x19cb6dd
leaq 0x36572c3(%rip), %rsi # 0x502298a
movq %r15, %rdi
movq %r14, %rdx
callq 0x780c70
leaq 0x6f(%r12), %rcx
testl %eax, %eax
cmoveq %rcx, %rbx
cmpq $0x6, %r14
jne 0x19cb708
movq %rbx, %rax
andq %r12, %rax
jne 0x19cb708
leaq 0x331ff5e(%rip), %rsi # 0x4ceb650
movq %r15, %rdi
movq %r14, %rdx
callq 0x780c70
leaq 0x69(%r12), %rcx
testl %eax, %eax
cmoveq %rcx, %rbx
cmpq $0x4, %r14
jne 0x19cb733
movq %rbx, %rax
andq %r12, %rax
jne 0x19cb733
leaq 0x3585c18(%rip), %rsi # 0x4f51335
movq %r15, %rdi
movq %r14, %rdx
callq 0x780c70
leaq 0x40(%r12), %rcx
testl %eax, %eax
cmoveq %rcx, %rbx
xorl %eax, %eax
testq %r12, %rbx
cmovel %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/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
callq 0x7f9ba8
leaq 0x25b4772(%rip), %rsi # 0x3f805cd
movl $0x2, %edx
movq %rax, %rdi
callq 0x7f9ba8
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x7f9ba8
movq 0x20(%rax), %rcx
cmpq 0x18(%rax), %rcx
jae 0x19cbe91
leaq 0x1(%rcx), %rdx
movq %rdx, 0x20(%rax)
movb $0xa, (%rcx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
movl $0xa, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x2b7d68e
nop
|
/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 # 0x3f805cd
testl %r13d, %r13d
je 0x19ccc9c
movl $0x2, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x7f9ba8
leal (%r14,%r13), %eax
movl %eax, %eax
movq 0x10(%r15), %rcx
shlq $0x4, %rax
movq 0x8(%rcx,%rax), %rsi
movq %rbx, %rdi
callq 0x2b7d122
incl %r13d
cmpl %r13d, %ebp
jne 0x19ccc87
leaq 0x2f2e9b2(%rip), %rsi # 0x48fb678
movl $0x1, %edx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x7f9ba8
nop
|
/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(BinOp->getLHS());
auto SectionRHS = getTargetSection(BinOp->getRHS());
return SectionLHS == SectionRHS ? nullptr : SectionLHS;
}
if (auto UnOp = dyn_cast<MCUnaryExpr>(Expr))
return getTargetSection(UnOp->getSubExpr());
return nullptr;
}
|
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 %bpl, %bpl
jne 0x19cf276
movq 0x10(%rbx), %rdi
callq 0x19cf214
movq %rax, %r14
movq 0x18(%rbx), %rdi
callq 0x19cf214
cmpq %rax, %r14
movl $0x0, %eax
cmovneq %r14, %rax
testb %bpl, %bpl
je 0x19cf288
cmpb $0x3, (%rbx)
jne 0x19cf286
movq 0x10(%rbx), %rbx
jmp 0x19cf21b
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
|
/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 0x28e14a4
movq %rsi, %r14
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %rcx, %rdx
xorl %ecx, %ecx
callq 0x28e4bf6
movq 0x10(%r14), %rax
movzbl 0x8(%rax,%r12), %edx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x188cd0a
movq (%r15), %rdi
movq %r14, %rsi
callq 0x2b7d21a
movq %r15, %rdi
callq 0x28e4cbc
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/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)
ShuffleMask[Idx + i] = NumElts + i;
}
|
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, %ecx
movl %ebx, %edx
movl %ebp, (%rax,%rdx,4)
incl %ebx
incl %ebp
decq %rcx
jne 0x19dbff1
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/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 0x930830
incl %ebp
decl %r15d
jne 0x19dc082
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/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
movl %ebp, %esi
callq 0x930830
incl %ebp
cmpl %ebp, %r14d
jne 0x19dc436
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/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 0x19df331
movb $0x1, %al
retq
|
/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
jae 0x19df380
movq 0x8(%rcx), %r8
movzbl (%r8,%rax), %r8d
andl $0x7, %edx
movb $0x1, %al
btl %edx, %r8d
jae 0x19df380
retq
addl $0x2, %esi
shlq $0x4, %rsi
addq %rsi, %rdi
cmpb $0x1, (%rdi)
jne 0x19df3b6
movl 0x8(%rdi), %eax
testq %rax, %rax
je 0x19df3b6
movl %eax, %edx
shrl $0x3, %edx
movzwl 0x16(%rcx), %esi
cmpl %esi, %edx
jae 0x19df3b6
movq 0x8(%rcx), %rcx
movzbl (%rcx,%rdx), %ecx
andl $0x7, %eax
btl %eax, %ecx
setb %al
retq
xorl %eax, %eax
retq
|
/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 (is64Bit)
MAI = new X86_64MCAsmInfoDarwin(TheTriple);
else
MAI = new X86MCAsmInfoDarwin(TheTriple);
} else if (TheTriple.isOSBinFormatELF()) {
// Force the use of an ELF container.
MAI = new X86ELFMCAsmInfo(TheTriple);
} else if (TheTriple.isWindowsMSVCEnvironment() ||
TheTriple.isWindowsCoreCLREnvironment()) {
if (Options.getAssemblyLanguage().equals_insensitive("masm"))
MAI = new X86MCAsmInfoMicrosoftMASM(TheTriple);
else
MAI = new X86MCAsmInfoMicrosoft(TheTriple);
} else if (TheTriple.isOSCygMing() ||
TheTriple.isWindowsItaniumEnvironment()) {
MAI = new X86MCAsmInfoGNUCOFF(TheTriple);
} else if (TheTriple.isUEFI()) {
MAI = new X86MCAsmInfoGNUCOFF(TheTriple);
} else {
// The default is ELF.
MAI = new X86ELFMCAsmInfo(TheTriple);
}
// Initialize initial frame state.
// Calculate amount of bytes used for return address storing
int stackGrowth = is64Bit ? -8 : -4;
// Initial state of the frame pointer is esp+stackGrowth.
unsigned StackPtr = is64Bit ? X86::RSP : X86::ESP;
MCCFIInstruction Inst = MCCFIInstruction::cfiDefCfa(
nullptr, MRI.getDwarfRegNum(StackPtr, true), -stackGrowth);
MAI->addInitialFrameState(Inst);
// Add return address to move list
unsigned InstPtr = is64Bit ? X86::RIP : X86::EIP;
MCCFIInstruction Inst2 = MCCFIInstruction::createOffset(
nullptr, MRI.getDwarfRegNum(InstPtr, true), stackGrowth);
MAI->addInitialFrameState(Inst2);
return MAI;
}
|
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 %r15, %rsi
cmpl $0x26, %ebp
jne 0x19e0b4a
callq 0x19e196a
jmp 0x19e0baa
movl $0x1e8, %edi # imm = 0x1E8
callq 0x7808d0
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x19e1982
jmp 0x19e0baa
movl 0x2c(%r15), %r12d
movl 0x30(%r15), %eax
movl %r12d, %ecx
xorl $0xe, %ecx
movl %eax, %esi
xorl $0x13, %esi
orl %ecx, %esi
je 0x19e0afe
testl %eax, %eax
sete %sil
cmpl $0x16, %eax
sete %dil
cmpl $0xe, %r12d
jne 0x19e0b51
orb %dil, %sil
je 0x19e0b51
movq %rdx, %rdi
callq 0x28fb240
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
cmpq $0x4, %rdx
jne 0x19e0b30
leaq 0x3474fd5(%rip), %rsi # 0x4e55af2
leaq 0x18(%rsp), %rdi
movl $0x4, %edx
callq 0x2b56644
testl %eax, %eax
je 0x19e0b92
movl $0x1e8, %edi # imm = 0x1E8
callq 0x7808d0
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x19e1a48
jmp 0x19e0baa
callq 0x19e1898
jmp 0x19e0baa
movl %eax, %edx
xorl $0x15, %edx
orl %edx, %ecx
je 0x19e0b78
cmpl $0x1, %eax
sete %cl
cmpl $0x14, %eax
sete %al
cmpl $0xe, %r12d
jne 0x19e0d0a
orb %al, %cl
je 0x19e0d0a
movl $0x1e8, %edi # imm = 0x1E8
callq 0x7808d0
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x19e1b1a
jmp 0x19e0baa
movl $0x1e8, %edi # imm = 0x1E8
callq 0x7808d0
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x19e1acc
xorl %r12d, %r12d
xorl %eax, %eax
cmpl $0x26, %ebp
setne %r12b
sete %al
leaq 0x4(,%rax,4), %rax
movq %rax, 0x8(%rsp)
movl $0x3d, %eax
movl $0x21, %esi
cmovel %eax, %esi
movl $0x3a, %eax
movl $0x1d, %ebp
cmovel %eax, %ebp
shll $0x2, %r12d
orq $-0x8, %r12
movq 0x10(%rsp), %r13
movq %r13, %rdi
movl $0x1, %edx
callq 0x28f28d0
xorl %r14d, %r14d
leaq 0x70(%rsp), %r15
movq %r14, -0x58(%r15)
movb $0x7, -0x38(%r15)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%r15)
movups %xmm0, -0x30(%r15)
movq %r15, -0x10(%r15)
movq %r14, -0x8(%r15)
movb %r14b, (%r15)
movl %eax, -0x50(%r15)
movq 0x8(%rsp), %rax
movq %rax, -0x48(%r15)
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x28ca1a4
movq %r13, %rdi
movl %ebp, %esi
movl $0x1, %edx
callq 0x28f28d0
leaq 0xd8(%rsp), %r13
movq %r14, -0x58(%r13)
movb $0x3, -0x38(%r13)
xorps %xmm0, %xmm0
movups %xmm0, -0x30(%r13)
movups %xmm0, -0x20(%r13)
movq %r13, -0x10(%r13)
movq %r14, -0x8(%r13)
movb %r14b, (%r13)
movl %eax, -0x50(%r13)
movq %r12, -0x48(%r13)
leaq 0x80(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x28ca1a4
movq 0x48(%r14), %rdi
cmpq %r13, %rdi
je 0x19e0caa
movq 0xd8(%rsp), %rsi
incq %rsi
callq 0x7800d0
movq 0xb0(%rsp), %rdi
testq %rdi, %rdi
je 0x19e0cc7
movq 0xc0(%rsp), %rsi
subq %rdi, %rsi
callq 0x7800d0
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0x19e0cde
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x7800d0
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x19e0cf5
movq 0x58(%rsp), %rsi
subq %rdi, %rsi
callq 0x7800d0
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x1e8, %edi # imm = 0x1E8
callq 0x7808d0
movq %rax, %rbx
movq %rax, %rdi
cmpl $0xd, %r12d
jne 0x19e0ac2
jmp 0x19e0b88
|
/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.
CodePointerSize = (is64Bit && !isX32) ? 8 : 4;
// OTOH, stack slot size is always 8 for x86-64, even with the x32 ABI.
CalleeSaveStackSlotSize = is64Bit ? 8 : 4;
AssemblerDialect = AsmWriterFlavor;
TextAlignFillValue = 0x90;
// Debug Information
SupportsDebugInformation = true;
// Exceptions handling
ExceptionsType = ExceptionHandling::DwarfCFI;
}
|
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(%r14)
sete %al
cmovnel %edx, %ecx
movl %ecx, 0x8(%rbx)
shll $0x2, %eax
addl %edx, %eax
movl %eax, 0xc(%rbx)
movl 0x3f5886b(%rip), %eax # 0x593a240
movl %eax, 0xb0(%rbx)
movl $0x90, 0x154(%rbx)
movb $0x1, 0x1a0(%rbx)
movl $0x1, 0x1a4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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;
WinEHEncodingType = WinEH::EncodingType::Itanium;
ExceptionsType = ExceptionHandling::WinEH;
} else {
ExceptionsType = ExceptionHandling::DwarfCFI;
}
AssemblerDialect = AsmWriterFlavor;
TextAlignFillValue = 0x90;
AllowAtInName = true;
}
|
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 %rcx, 0x70(%rbx)
movl $0x8, 0x8(%rbx)
movl $0x5, 0x1ac(%rbx)
movl $0x4, %eax
movl %eax, 0x1a4(%rbx)
movl 0x3f586c3(%rip), %eax # 0x593a240
movl %eax, 0xb0(%rbx)
movl $0x90, 0x154(%rbx)
movb $0x1, 0xb4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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)
leaq 0x3f0a4b3(%rip), %rax # 0x58f7c68
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x3f0a355(%rip), %rax # 0x58f7b18
addq $0x10, %rax
movq %rax, 0x98(%rbx)
movups %xmm0, 0xa0(%rbx)
leaq -0x11f07ec(%rip), %rax # 0x7fcff0
movq %rax, 0xb8(%rbx)
leaq -0x11f07f8(%rip), %rax # 0x7fcff2
movq %rax, 0xb0(%rbx)
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x19f1646
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2b1e814
nop
|
/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 $0xd0, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x7800d0
nop
|
/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, %rsi
callq 0x2b56b9e
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x2b7d704
movq (%r15), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x19f34e5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7800d0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
|
/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",
"ARM (big endian)", "ARM");
RegisterTarget<Triple::thumb, /*HasJIT=*/true> A(getTheThumbLETarget(),
"thumb", "Thumb", "ARM");
RegisterTarget<Triple::thumbeb, /*HasJIT=*/true> B(
getTheThumbBETarget(), "thumbeb", "Thumb (big endian)", "ARM");
}
|
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 0x350b730(%rip), %rsi # 0x4eff65a
leaq 0x350b72f(%rip), %rdx # 0x4eff660
leaq 0x76(%rip), %r8 # 0x19f3fae
movq %rbx, %rcx
movl $0x1, %r9d
callq 0x290994c
callq 0x19f3ea8
leaq 0x3f47306(%rip), %rdi # 0x593b258
leaq 0x36b42ea(%rip), %rsi # 0x50a8243
leaq 0x17eb245(%rip), %rdx # 0x31df1a5
leaq 0x4f(%rip), %r8 # 0x19f3fb6
movq %rbx, %rcx
movl $0x1, %r9d
callq 0x290994c
callq 0x19f3ec6
leaq 0x3f473d7(%rip), %rdi # 0x593b358
leaq 0x350b6e9(%rip), %rsi # 0x4eff671
leaq 0x350b6ea(%rip), %rdx # 0x4eff679
leaq 0x28(%rip), %r8 # 0x19f3fbe
movq %rbx, %rcx
movl $0x1, %r9d
popq %rbx
jmp 0x290994c
nop
|
/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(NAME, CREATE_PASS) \
if (llvm::parseAnalysisUtilityPasses< \
std::remove_reference<decltype(CREATE_PASS)>::type>(NAME, Name, \
FPM)) \
return true;
#define FUNCTION_PASS(NAME, CREATE_PASS) \
if (Name == NAME) { \
FPM.addPass(CREATE_PASS); \
return true; \
}
#include "PollyPasses.def"
return false;
}
|
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 $0xc, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x19f7801
testb %al, %al
jne 0x19f634f
leaq 0x350c3c7(%rip), %rdi # 0x4f024ac
movl $0x14, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x19f7902
testb %al, %al
jne 0x19f634f
xorl %ebp, %ebp
leaq -0xd(%r14), %rax
cmpq $0xe, %rax
ja 0x19f634f
leaq 0x350b3c1(%rip), %rcx # 0x4f014d8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x350c39a(%rip), %rsi # 0x4f024c1
movq %r15, %rdi
movq %r14, %rdx
callq 0x780c70
testl %eax, %eax
je 0x19f6341
xorl %ebp, %ebp
leaq -0x11(%r14), %rax
cmpq $0xa, %rax
ja 0x19f634f
leaq 0x350b3c3(%rip), %rcx # 0x4f01514
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x350c36e(%rip), %rsi # 0x4f024cf
movq %r15, %rdi
movq %r14, %rdx
callq 0x780c70
testl %eax, %eax
je 0x19f632c
xorl %ebp, %ebp
leaq -0x11(%r14), %rax
cmpq $0xa, %rax
ja 0x19f634f
leaq 0x350b3b5(%rip), %rcx # 0x4f01540
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x350c348(%rip), %rsi # 0x4f024e3
movq %r15, %rdi
movq %r14, %rdx
callq 0x780c70
testl %eax, %eax
je 0x19f6317
xorl %ebp, %ebp
leaq -0x11(%r14), %rax
cmpq $0x6, %rax
ja 0x19f634f
leaq 0x350b3a7(%rip), %rcx # 0x4f0156c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x350c32a(%rip), %rsi # 0x4f024ff
movq %r15, %rdi
movq %r14, %rdx
callq 0x780c70
testl %eax, %eax
je 0x19f62e9
cmpq $0x12, %r14
je 0x19f6220
cmpq $0x17, %r14
je 0x19f623c
cmpq $0x16, %r14
jne 0x19f6252
leaq 0x350c310(%rip), %rsi # 0x4f02511
movq %r15, %rdi
movq %r14, %rdx
callq 0x780c70
testl %eax, %eax
je 0x19f62bb
cmpq $0x17, %r14
je 0x19f623c
cmpq $0x12, %r14
jne 0x19f6252
leaq 0x350c301(%rip), %rsi # 0x4f02528
movq %r15, %rdi
movq %r14, %rdx
callq 0x780c70
testl %eax, %eax
je 0x19f628a
cmpq $0x17, %r14
jne 0x19f6252
leaq 0x350c2f8(%rip), %rsi # 0x4f0253b
movq %r15, %rdi
movq %r14, %rdx
callq 0x780c70
testl %eax, %eax
je 0x19f6259
xorl %ebp, %ebp
jmp 0x19f634f
leaq 0x350ca32(%rip), %rax # 0x4f02c92
movq %rsp, %rsi
movq %rax, 0x8(%rsi)
movq $0x9, 0x10(%rsi)
leaq 0x3e83cda(%rip), %rax # 0x5879f50
addq $0x10, %rax
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x19f7bfe
jmp 0x19f634c
leaq 0x3512cfe(%rip), %rax # 0x4f08f8f
movq %rsp, %rsi
movq %rax, 0x8(%rsi)
movq $0x5, 0x10(%rsi)
leaq 0x3e83c39(%rip), %rax # 0x5879ee0
addq $0x10, %rax
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x19f7ba0
jmp 0x19f634c
leaq 0x3512dc3(%rip), %rax # 0x4f09085
movq %rsp, %rsi
movq %rax, 0x8(%rsi)
movq $0xa, 0x10(%rsi)
leaq 0x3e83bb0(%rip), %rax # 0x5879e88
addq $0x10, %rax
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x19f7b42
jmp 0x19f634c
leaq 0x3512c9f(%rip), %rax # 0x4f08f8f
movq %rsp, %rsi
movq %rax, 0x8(%rsi)
movq $0x5, 0x10(%rsi)
leaq 0x3e86fca(%rip), %rax # 0x587d2d0
addq $0x10, %rax
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x19f7ae4
jmp 0x19f634c
callq 0x2b7e53f
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x19f7a96
jmp 0x19f634c
callq 0x2b7e53f
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x19f7a48
jmp 0x19f634c
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x19f7a04
movb $0x1, %bpl
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/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:
//
// -O2 or O2 or -la (where -l and -a are separate options)
//
// If this is the case, we cannot allow a value.
//
if (Owner.hasArgStr())
return ValueRequired;
else
return ValueDisallowed;
}
|
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
cmpb $0x1, 0x94(%rsi)
jne 0x19f71ec
movl 0x80(%rsi), %eax
cmpl %eax, 0x90(%rsi)
jne 0x19f71ec
retq
|
/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 compile times.
Passes.push_back(std::unique_ptr<PassConceptT>(
new PassModelT(std::forward<PassT>(Pass))));
}
|
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, %rbx
movq %rax, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xadff9e
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x19f7b3a
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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 %ecx, 0x48(%rdi)
leaq 0x3faeb61(%rip), %rdx # 0x59a68b8
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xade436
leaq 0x3f4c36d(%rip), %r15 # 0x59440d8
movq %rbx, %rdi
movq %r15, %rsi
callq 0xae98d2
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xae987e
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
|
/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 %ecx, 0x48(%rdi)
leaq 0x3fae6e7(%rip), %rdx # 0x59a68b8
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xade436
leaq 0x3f4a943(%rip), %r15 # 0x5942b28
movq %rbx, %rdi
movq %r15, %rsi
callq 0xae98d2
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xae987e
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
|
/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::InvalidateAnalysisPass<polly::ScopInfoAnalysis>&&)
|
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 compile times.
Passes.push_back(std::unique_ptr<PassConceptT>(
new PassModelT(std::forward<PassT>(Pass))));
}
|
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(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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. However, we must still free the
// Scop analysis results which may hold AssertingVH that cause an error
// if its value is destroyed.
PreservedAnalyses PA = PreservedAnalyses::all();
PA.abandon<ScopInfoAnalysis>();
PA.abandon<ScopAnalysis>();
AM.invalidate(F, PA);
return PreservedAnalyses::all();
}
SmallPriorityWorklist<Region *, 4> Worklist;
for (auto &S : SI)
if (S.second)
Worklist.insert(S.first);
ScopStandardAnalysisResults AR = {AM.getResult<DominatorTreeAnalysis>(F),
AM.getResult<ScopInfoAnalysis>(F),
AM.getResult<ScalarEvolutionAnalysis>(F),
AM.getResult<LoopAnalysis>(F),
AM.getResult<RegionInfoAnalysis>(F),
AM.getResult<TargetIRAnalysis>(F)};
ScopAnalysisManager &SAM =
AM.getResult<ScopAnalysisManagerFunctionProxy>(F).getManager();
SPMUpdater Updater{Worklist, SAM};
while (!Worklist.empty()) {
Region *R = Worklist.pop_back_val();
if (!SD.isMaxRegionInScop(*R, /*Verify=*/false))
continue;
Scop *scop = SI.getScop(R);
if (!scop)
continue;
Updater.CurrentScop = scop;
Updater.InvalidateCurrentScop = false;
PreservedAnalyses PassPA = Pass.run(*scop, SAM, AR, Updater);
SAM.invalidate(*scop, PassPA);
if (Updater.invalidateCurrentScop())
SI.recompute();
};
// FIXME: For the same reason as we add a BarrierNoopPass in the legacy pass
// manager, do not preserve any analyses. While CodeGeneration may preserve
// IR analyses sufficiently to process another Scop in the same function (it
// has to, otherwise the ScopDetection result itself would need to be
// invalidated), it is not sufficient for other purposes. For instance,
// CodeGeneration does not inform LoopInfo about new loops in the
// Polly-generated IR.
return PreservedAnalyses::none();
}
|
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 %rbp, %rdi
movq %r14, %rdx
callq 0x2a8ddb2
cmpl $0x0, 0x28(%rax)
je 0x19fc5a6
movq %rax, %r12
movq %r13, 0x10(%rsp)
leaq 0x40(%rsp), %rdi
xorl %esi, %esi
callq 0x19fcee2
leaq 0x98(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movabsq $0x400000000, %rax # imm = 0x400000000
movq %rax, -0x8(%rcx)
movl 0x28(%r12), %r13d
testq %r13, %r13
movq %r14, %rax
je 0x19fc320
movq 0x20(%r12), %rbx
shlq $0x4, %r13
leaq 0x40(%rsp), %r14
cmpq $0x0, 0x8(%rbx)
je 0x19fc316
movq %r14, %rdi
movq %rbx, %rsi
movq %rbp, %r15
movq %rax, %rbp
callq 0x19fc6cc
movq %rbp, %rax
movq %r15, %rbp
addq $0x10, %rbx
addq $-0x10, %r13
jne 0x19fc2f8
leaq 0x3fa9db9(%rip), %rsi # 0x59a60e0
movq %rbp, %rdi
movq %rax, %rbx
movq %rax, %rdx
callq 0x2a8ddb2
addq $0x8, %rax
movq %rax, 0xb8(%rsp)
leaq 0x3f46f70(%rip), %rsi # 0x59432b8
movq %rbp, %rdi
movq %rbx, %rdx
callq 0x2a8ddb2
addq $0x8, %rax
movq %rax, 0xc0(%rsp)
leaq 0x3f95b92(%rip), %rsi # 0x5991ef8
movq %rbp, %rdi
movq %rbx, %rdx
callq 0x2a8ddb2
addq $0x8, %rax
movq %rax, 0xc8(%rsp)
leaq 0x3f9313c(%rip), %rsi # 0x598f4c0
movq %rbp, %rdi
movq %rbx, %rdx
callq 0x2a8ddb2
addq $0x8, %rax
movq %rax, 0xd0(%rsp)
leaq 0x3f94b36(%rip), %rsi # 0x5990ed8
movq %rbp, %rdi
movq %rbx, %rdx
callq 0x2a8ddb2
addq $0x8, %rax
movq %rax, 0xd8(%rsp)
leaq 0x3fa5d18(%rip), %rsi # 0x59a20d8
movq %rbp, %rdi
movq %rbx, %rdx
callq 0x2a8ddb2
addq $0x8, %rax
movq %rax, 0xe0(%rsp)
leaq 0x3f47cfa(%rip), %rsi # 0x59440d8
movq %rbp, %rdi
movq %rbx, %rdx
callq 0x2a8ddb2
movq 0x8(%rax), %r13
movb $0x0, 0x28(%rsp)
leaq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq %r13, 0x38(%rsp)
movl 0x90(%rsp), %eax
testl %eax, %eax
je 0x19fc510
addq $0x8, 0x8(%rsp)
movq %r12, %rbp
addq $0x8, %rbp
leaq 0x40(%rsp), %r15
leaq 0xe8(%rsp), %rbx
movq 0x88(%rsp), %rcx
movl %eax, %eax
movq -0x8(%rcx,%rax,8), %r14
movq %r15, %rdi
callq 0x19fd43c
movq 0x8(%rsp), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x1a40f08
testb %al, %al
je 0x19fc501
movq %r14, 0xe8(%rsp)
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x19fd4aa
movl 0x28(%r12), %ecx
shlq $0x4, %rcx
addq 0x20(%r12), %rcx
cmpq %rcx, %rax
je 0x19fc484
movq 0x8(%rax), %r14
jmp 0x19fc487
xorl %r14d, %r14d
testq %r14, %r14
je 0x19fc501
movq %r14, 0x20(%rsp)
movb $0x0, 0x28(%rsp)
movq %rbx, %rdi
movq 0x18(%rsp), %rsi
movq %r14, %rdx
movq %r13, %rcx
leaq 0xb8(%rsp), %r8
leaq 0x20(%rsp), %r9
callq 0x1a76244
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x19fc752
cmpb $0x1, 0x28(%rsp)
jne 0x19fc4d3
movq %rbp, %rdi
callq 0x1a5b3e4
movq 0x120(%rsp), %rdi
cmpq 0x118(%rsp), %rdi
je 0x19fc4ea
callq 0x780910
movq 0xf0(%rsp), %rdi
cmpq 0xe8(%rsp), %rdi
je 0x19fc501
callq 0x780910
movl 0x90(%rsp), %eax
testl %eax, %eax
jne 0x19fc42a
xorps %xmm0, %xmm0
movq 0x10(%rsp), %r13
movups %xmm0, (%r13)
movups %xmm0, 0x10(%r13)
movups %xmm0, 0x30(%r13)
movups %xmm0, 0x40(%r13)
movups %xmm0, 0x50(%r13)
movups %xmm0, 0x20(%r13)
leaq 0x50(%r13), %rax
leaq 0x20(%r13), %rcx
movq %rcx, (%r13)
movq %rcx, 0x8(%r13)
movl $0x2, %ecx
movq %rcx, 0x10(%r13)
xorl %edx, %edx
movl %edx, 0x18(%r13)
movq %rax, 0x30(%r13)
movq %rax, 0x38(%r13)
movq %rcx, 0x40(%r13)
movl %edx, 0x48(%r13)
movq 0x88(%rsp), %rdi
leaq 0x98(%rsp), %rax
cmpq %rax, %rdi
je 0x19fc57f
callq 0x780910
testb $0x1, 0x40(%rsp)
jne 0x19fc6b7
movq 0x48(%rsp), %rdi
movl 0x50(%rsp), %esi
shlq $0x4, %rsi
movl $0x8, %edx
callq 0x2b410f1
jmp 0x19fc6b7
leaq 0x60(%rsp), %rax
movq %rax, -0x20(%rax)
movq %rax, -0x18(%rax)
movl $0x2, %ecx
movq %rcx, -0x10(%rax)
xorl %edx, %edx
movl %edx, -0x8(%rax)
leaq 0x70(%rsp), %r15
leaq 0x90(%rsp), %rax
movq %rax, -0x20(%rax)
movq %rax, -0x18(%rax)
movq %rcx, -0x10(%rax)
movl %edx, -0x8(%rax)
leaq 0x3faa2d4(%rip), %rdx # 0x59a68b8
leaq 0xe8(%rsp), %rdi
leaq 0x40(%rsp), %rbx
movq %rbx, %rsi
callq 0xade436
leaq 0x3f46cb8(%rip), %r12 # 0x59432b8
movq %rbx, %rdi
movq %r12, %rsi
callq 0xae98d2
leaq 0xe8(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xae987e
leaq 0x3f46503(%rip), %r12 # 0x5942b28
movq %rbx, %rdi
movq %r12, %rsi
callq 0xae98d2
leaq 0xe8(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xae987e
movq %rbp, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2a8cbe2
leaq 0x20(%r13), %rax
movq %rax, (%r13)
movq %rax, 0x8(%r13)
movl $0x2, %ecx
movq %rcx, 0x10(%r13)
xorl %edx, %edx
movl %edx, 0x18(%r13)
leaq 0x50(%r13), %rax
movq %rax, 0x30(%r13)
movq %rax, 0x38(%r13)
movq %rcx, 0x40(%r13)
movl %edx, 0x48(%r13)
leaq 0xe8(%rsp), %rdi
movq %r13, %rsi
leaq 0x3faa226(%rip), %rdx # 0x59a68b8
callq 0xade436
movq 0x38(%rbx), %rdi
cmpq 0x30(%rbx), %rdi
je 0x19fc6a6
callq 0x780910
movq 0x48(%rsp), %rdi
cmpq 0x40(%rsp), %rdi
je 0x19fc6b7
callq 0x780910
movq %r13, %rax
addq $0x148, %rsp # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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
// IsResultInvalidated.
SmallDenseMap<AnalysisKey *, bool, 8> IsResultInvalidated;
Invalidator Inv(IsResultInvalidated, AnalysisResults);
AnalysisResultListT &ResultsList = AnalysisResultLists[&IR];
for (auto &AnalysisResultPair : ResultsList) {
// This is basically the same thing as Invalidator::invalidate, but we
// can't call it here because we're operating on the type-erased result.
// Moreover if we instead called invalidate() directly, it would do an
// unnecessary look up in ResultsList.
AnalysisKey *ID = AnalysisResultPair.first;
auto &Result = *AnalysisResultPair.second;
auto IMapI = IsResultInvalidated.find(ID);
if (IMapI != IsResultInvalidated.end())
// This result was already handled via the Invalidator.
continue;
// Try to invalidate the result, giving it the Invalidator so it can
// recursively query for any dependencies it has and record the result.
// Note that we cannot reuse 'IMapI' here or pre-insert the ID, as
// Result.invalidate may insert things into the map, invalidating our
// iterator.
bool Inserted =
IsResultInvalidated.insert({ID, Result.invalidate(IR, PA, Inv)}).second;
(void)Inserted;
assert(Inserted && "Should never have already inserted this ID, likely "
"indicates a cycle!");
}
// Now erase the results that were marked above as invalidated.
if (!IsResultInvalidated.empty()) {
for (auto I = ResultsList.begin(), E = ResultsList.end(); I != E;) {
AnalysisKey *ID = I->first;
if (!IsResultInvalidated.lookup(ID)) {
++I;
continue;
}
if (auto *PI = getCachedResult<PassInstrumentationAnalysis>(IR))
PI->runAnalysisInvalidated(this->lookUpPass(ID), IR);
I = ResultsList.erase(I);
AnalysisResults.erase({ID, &IR});
}
}
if (ResultsList.empty())
AnalysisResultLists.erase(&IR);
}
|
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(%r15), %rax
movq %r14, 0x50(%rsp)
movq %rax, 0x38(%rsp)
movq %rax, 0x58(%rsp)
movq %r15, 0x40(%rsp)
leaq 0x18(%r15), %rdi
leaq 0x18(%rsp), %rsi
movq %rbx, (%rsp)
movq %rbx, (%rsi)
movq %rdi, 0x30(%rsp)
callq 0x19fd762
movq %rax, %r13
movq 0x8(%rax), %rbx
addq $0x8, %r13
cmpq %r13, %rbx
je 0x19fc85d
leaq 0x60(%rsp), %r15
movl $0x8, %ebp
movq 0x10(%rbx), %r14
movq 0x18(%rbx), %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x19fc968
testb $0x1, 0x60(%rsp)
movq 0x68(%rsp), %rcx
leaq 0x68(%rsp), %rdx
cmovneq %rdx, %rcx
movl 0x70(%rsp), %edx
cmovnel %ebp, %edx
shlq $0x4, %rdx
addq %rcx, %rdx
cmpq %rdx, %rax
jne 0x19fc855
movq (%r12), %rax
movq %r12, %rdi
movq (%rsp), %rsi
movq 0x48(%rsp), %rdx
leaq 0x50(%rsp), %rcx
callq *0x10(%rax)
movq %r14, 0x8(%rsp)
movb %al, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
leaq 0x8(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq 0x19fcac4
movq (%rbx), %rbx
cmpq %r13, %rbx
jne 0x19fc7e4
cmpl $0x2, 0x60(%rsp)
movq (%rsp), %rbx
jb 0x19fc920
movq (%r13), %r14
cmpq %r13, %r14
je 0x19fc920
leaq 0x60(%rsp), %r15
leaq 0x18(%rsp), %r12
movq 0x10(%r14), %rbp
movq %rbp, 0x18(%rsp)
movq %r15, %rdi
movq %r12, %rsi
leaq 0x8(%rsp), %rdx
callq 0x19fca24
testb %al, %al
je 0x19fc914
movq 0x8(%rsp), %rax
cmpb $0x0, 0x8(%rax)
je 0x19fc914
movq 0x40(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x19fd5b0
testq %rax, %rax
je 0x19fc8dd
movq %rax, %r12
movq %r15, %rdi
movq %rbp, %rsi
callq 0x19fdd4c
movq 0x8(%rax), %rsi
movq %r12, %rdi
movq %rbx, %rdx
callq 0x19fd606
movq (%r14), %r12
movq %r13, %rdi
movq %r14, %rsi
callq 0x19fde1c
movq %rbp, 0x18(%rsp)
movq %rbx, 0x20(%rsp)
movq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %r15
movq %r15, %rsi
callq 0x19fd6d2
movq %r12, %r14
movq %r15, %r12
leaq 0x60(%rsp), %r15
jmp 0x19fc917
movq (%r14), %r14
cmpq %r13, %r14
jne 0x19fc883
cmpq %r13, (%r13)
jne 0x19fc938
leaq 0x18(%rsp), %rsi
movq %rbx, (%rsi)
movq 0x30(%rsp), %rdi
callq 0x19fd714
testb $0x1, 0x60(%rsp)
jne 0x19fc956
movq 0x68(%rsp), %rdi
movl 0x70(%rsp), %esi
shlq $0x4, %rsi
movl $0x8, %edx
callq 0x2b410f1
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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 const*)
|
iterator find(const_arg_type_t<KeyT> Val) {
BucketT *TheBucket;
if (LookupBucketFor(Val, TheBucket))
return makeIterator(TheBucket,
shouldReverseIterate<KeyT>() ? getBuckets()
: getBucketsEnd(),
*this, true);
return end();
}
|
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 (%r14), %rax
cmoveq %rdx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
|
/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::AnalysisResultConcept<polly::Scop, llvm::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>::Invalidator>>>>>, llvm::DenseMapInfo<std::pair<llvm::AnalysisKey*, polly::Scop*>, void>, llvm::detail::DenseMapPair<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<polly::Scop, llvm::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>::Invalidator>>>>>>>, 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<polly::Scop, llvm::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>::Invalidator>>>>>, llvm::DenseMapInfo<std::pair<llvm::AnalysisKey*, polly::Scop*>, void>, llvm::detail::DenseMapPair<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<polly::Scop, llvm::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>::Invalidator>>>>>>>::find(std::pair<llvm::AnalysisKey*, polly::Scop*> const&) const
|
const_iterator find(const_arg_type_t<KeyT> Val) const {
const BucketT *TheBucket;
if (LookupBucketFor(Val, TheBucket))
return makeConstIterator(TheBucket,
shouldReverseIterate<KeyT>() ? getBuckets()
: getBucketsEnd(),
*this, true);
return end();
}
|
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, %rdx
addq $0x10, %rsp
popq %rbx
retq
|
/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, 0x80(%r13)
movb $0x1, 0x91(%r13)
movb (%rax), %al
movb %al, 0x90(%r13)
movq (%rbx), %rsi
movq %r13, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2b1f3c8
|
/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)
addq $0x10, %r8
cmpq %rdx, %r9
jne 0x1a0199d
testq %rax, %rax
je 0x1a019e2
movq (%rdi), %r14
addq $-0x8, %r14
leaq (%r14,%rbx), %rdi
callq 0x1a0194c
addq $-0x10, %rbx
jne 0x1a019d3
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>::Invalidator, polly::ScopStandardAnalysisResults&>>>, llvm::DenseMapInfo<llvm::AnalysisKey*, void>, llvm::detail::DenseMapPair<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::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>::Invalidator, polly::ScopStandardAnalysisResults&>>>>>, 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::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>::Invalidator, polly::ScopStandardAnalysisResults&>>>, llvm::DenseMapInfo<llvm::AnalysisKey*, void>, llvm::detail::DenseMapPair<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::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>::Invalidator, polly::ScopStandardAnalysisResults&>>>>>::LookupBucketFor<llvm::AnalysisKey*>(llvm::AnalysisKey* const&, llvm::detail::DenseMapPair<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::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>::Invalidator, polly::ScopStandardAnalysisResults&>>>> const*&) const
|
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)
jne 0x1a01dd0
movq %r11, (%rdx)
movb $0x1, %al
xorl %r11d, %r11d
testb %r11b, %r11b
jne 0x1a01dad
jmp 0x1a01e06
cmpq $-0x1000, %rbx # imm = 0xF000
jne 0x1a01dea
testq %r9, %r9
cmovneq %r9, %r11
movq %r11, (%rdx)
xorl %r11d, %r11d
xorl %eax, %eax
jmp 0x1a01dc9
xorq $-0x2000, %rbx # imm = 0xE000
orq %r9, %rbx
cmoveq %r11, %r9
addl %r10d, %r8d
incl %r10d
andl %ecx, %r8d
movb $0x1, %r11b
jmp 0x1a01dc9
popq %rbx
jmp 0x1a01e12
movq $0x0, (%rdx)
xorl %eax, %eax
andb $0x1, %al
retq
nop
|
/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::DenseMapInfo<llvm::AnalysisKey*, void>, llvm::detail::DenseMapPair<llvm::AnalysisKey*, llvm::TinyPtrVector<llvm::AnalysisKey*>>>&)
|
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) {
// If we're swapping inline bucket arrays, we have to cope with some of
// the tricky bits of DenseMap's storage system: the buckets are not
// fully initialized. Thus we swap every key, but we may have
// a one-directional move of the value.
for (unsigned i = 0, e = InlineBuckets; i != e; ++i) {
BucketT *LHSB = &getInlineBuckets()[i],
*RHSB = &RHS.getInlineBuckets()[i];
bool hasLHSValue = (!KeyInfoT::isEqual(LHSB->getFirst(), EmptyKey) &&
!KeyInfoT::isEqual(LHSB->getFirst(), TombstoneKey));
bool hasRHSValue = (!KeyInfoT::isEqual(RHSB->getFirst(), EmptyKey) &&
!KeyInfoT::isEqual(RHSB->getFirst(), TombstoneKey));
if (hasLHSValue && hasRHSValue) {
// Swap together if we can...
std::swap(*LHSB, *RHSB);
continue;
}
// Swap separately and handle any asymmetry.
std::swap(LHSB->getFirst(), RHSB->getFirst());
if (hasLHSValue) {
::new (&RHSB->getSecond()) ValueT(std::move(LHSB->getSecond()));
LHSB->getSecond().~ValueT();
} else if (hasRHSValue) {
::new (&LHSB->getSecond()) ValueT(std::move(RHSB->getSecond()));
RHSB->getSecond().~ValueT();
}
}
return;
}
if (!Small && !RHS.Small) {
std::swap(getLargeRep()->Buckets, RHS.getLargeRep()->Buckets);
std::swap(getLargeRep()->NumBuckets, RHS.getLargeRep()->NumBuckets);
return;
}
SmallDenseMap &SmallSide = Small ? *this : RHS;
SmallDenseMap &LargeSide = Small ? RHS : *this;
// First stash the large side's rep and move the small side across.
LargeRep TmpRep = std::move(*LargeSide.getLargeRep());
LargeSide.getLargeRep()->~LargeRep();
LargeSide.Small = true;
// This is similar to the standard move-from-old-buckets, but the bucket
// count hasn't actually rotated in this case. So we have to carefully
// move construct the keys and values into their new locations, but there
// is no need to re-hash things.
for (unsigned i = 0, e = InlineBuckets; i != e; ++i) {
BucketT *NewB = &LargeSide.getInlineBuckets()[i],
*OldB = &SmallSide.getInlineBuckets()[i];
::new (&NewB->getFirst()) KeyT(std::move(OldB->getFirst()));
OldB->getFirst().~KeyT();
if (!KeyInfoT::isEqual(NewB->getFirst(), EmptyKey) &&
!KeyInfoT::isEqual(NewB->getFirst(), TombstoneKey)) {
::new (&NewB->getSecond()) ValueT(std::move(OldB->getSecond()));
OldB->getSecond().~ValueT();
}
}
// The hard part of moving the small buckets across is done, just move
// the TmpRep into its new home.
SmallSide.Small = false;
new (SmallSide.getLargeRep()) LargeRep(std::move(TmpRep));
}
|
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, (%rdi)
movl 0x4(%rsi), %eax
movl %eax, 0x4(%rdi)
movl %edx, 0x4(%rsi)
movl (%rdi), %eax
testb $0x1, %al
jne 0x1a029b3
testb $0x1, (%rbx)
jne 0x1a029bc
movq 0x8(%r14), %rax
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%r14)
movq %rax, 0x8(%rbx)
movl 0x10(%r14), %eax
movl 0x10(%rbx), %ecx
movl %ecx, 0x10(%r14)
movl %eax, 0x10(%rbx)
jmp 0x1a02b10
testb $0x1, (%rbx)
jne 0x1a02a27
testb $0x1, %al
je 0x1a0298b
testb $0x1, %al
movq %r14, %r15
cmoveq %rbx, %r15
cmoveq %r14, %rbx
movups 0x8(%rbx), %xmm0
movaps %xmm0, (%rsp)
orb $0x1, (%rbx)
movl $0x10, %r14d
movq -0x8(%r15,%r14), %rax
movq %rax, -0x8(%rbx,%r14)
orq $0x1000, %rax # imm = 0x1000
cmpq $-0x1000, %rax # imm = 0xF000
je 0x1a02a0b
leaq (%r15,%r14), %rdi
movq (%r15,%r14), %rax
movq %rax, (%rbx,%r14)
movq $0x0, (%r15,%r14)
callq 0x1a02b1e
addq $0x10, %r14
cmpq $0x30, %r14
jne 0x1a029da
andb $-0x2, (%r15)
movaps (%rsp), %xmm0
movups %xmm0, 0x8(%r15)
jmp 0x1a02b10
leaq 0x8(%rsp), %r15
addq $0x10, %r14
addq $0x10, %rbx
xorl %r13d, %r13d
movq -0x8(%r14,%r13), %rcx
movq -0x8(%rbx,%r13), %rax
cmpq $-0x1000, %rcx # imm = 0xF000
je 0x1a02aab
cmpq $-0x2000, %rcx # imm = 0xE000
je 0x1a02aab
cmpq $-0x1000, %rax # imm = 0xF000
je 0x1a02aab
cmpq $-0x2000, %rax # imm = 0xE000
je 0x1a02aab
movq %rcx, (%rsp)
leaq (%r14,%r13), %rdi
movq (%r14,%r13), %rax
movq %rax, 0x8(%rsp)
movq $0x0, (%r14,%r13)
leaq (%rbx,%r13), %r12
movq -0x8(%rbx,%r13), %rax
movq %rax, -0x8(%r14,%r13)
movq %r12, %rsi
callq 0x1a02b54
movq (%rsp), %rax
movq %rax, -0x8(%rbx,%r13)
movq %r12, %rdi
movq %r15, %rsi
callq 0x1a02b54
movq %r15, %rdi
jmp 0x1a02afd
movq %rax, -0x8(%r14,%r13)
movq %rcx, -0x8(%rbx,%r13)
orq $0x1000, %rcx # imm = 0x1000
cmpq $-0x1000, %rcx # imm = 0xF000
jne 0x1a02ae9
orq $0x1000, %rax # imm = 0x1000
cmpq $-0x1000, %rax # imm = 0xF000
je 0x1a02b02
leaq (%rbx,%r13), %rdi
movq (%rbx,%r13), %rax
movq %rax, (%r14,%r13)
movq $0x0, (%rbx,%r13)
jmp 0x1a02afd
leaq (%r14,%r13), %rdi
movq (%r14,%r13), %rax
movq %rax, (%rbx,%r13)
movq $0x0, (%r14,%r13)
callq 0x1a02b1e
addq $0x10, %r13
cmpq $0x20, %r13
jne 0x1a02a37
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/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, llvm::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>::Invalidator>>>>, std::allocator<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<polly::Scop, polly::ScopStandardAnalysisResults&>::Invalidator>>>>>>, llvm::DenseMapInfo<polly::Scop*, void>, llvm::detail::DenseMapPair<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<polly::Scop, polly::ScopStandardAnalysisResults&>::Invalidator>>>>, std::allocator<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<polly::Scop, polly::ScopStandardAnalysisResults&>::Invalidator>>>>>>>>, 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<polly::Scop, polly::ScopStandardAnalysisResults&>::Invalidator>>>>, std::allocator<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<polly::Scop, polly::ScopStandardAnalysisResults&>::Invalidator>>>>>>, llvm::DenseMapInfo<polly::Scop*, void>, llvm::detail::DenseMapPair<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<polly::Scop, polly::ScopStandardAnalysisResults&>::Invalidator>>>>, std::allocator<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<polly::Scop, polly::ScopStandardAnalysisResults&>::Invalidator>>>>>>>>::clear()
|
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;
}
const KeyT EmptyKey = getEmptyKey(), TombstoneKey = getTombstoneKey();
if (std::is_trivially_destructible<ValueT>::value) {
// Use a simpler loop when values don't need destruction.
for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P)
P->getFirst() = EmptyKey;
} else {
unsigned NumEntries = getNumEntries();
for (BucketT *P = getBuckets(), *E = getBucketsEnd(); P != E; ++P) {
if (!KeyInfoT::isEqual(P->getFirst(), EmptyKey)) {
if (!KeyInfoT::isEqual(P->getFirst(), TombstoneKey)) {
P->getSecond().~ValueT();
--NumEntries;
}
P->getFirst() = EmptyKey;
}
}
assert(NumEntries == 0 && "Node count imbalance!");
(void)NumEntries;
}
setNumEntries(0);
setNumTombstones(0);
}
|
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 %r15, %r15
je 0x1a03054
movq (%rbx), %r14
shlq $0x5, %r15
addq $0x8, %r14
movq -0x8(%r14), %rax
cmpq $-0x2000, %rax # imm = 0xE000
je 0x1a03042
cmpq $-0x1000, %rax # imm = 0xF000
je 0x1a0304a
movq %r14, %rdi
callq 0x19fdb94
movq $-0x1000, -0x8(%r14) # imm = 0xF000
addq $0x20, %r14
addq $-0x20, %r15
jne 0x1a03026
movq $0x0, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
|
/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<polly::Scop, llvm::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>::Invalidator>>>>>, llvm::DenseMapInfo<std::pair<llvm::AnalysisKey*, polly::Scop*>, void>, llvm::detail::DenseMapPair<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<polly::Scop, llvm::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>::Invalidator>>>>>>>::shrink_and_clear()
|
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 (NewNumBuckets == NumBuckets) {
this->BaseT::initEmpty();
return;
}
deallocate_buffer(Buckets, sizeof(BucketT) * OldNumBuckets,
alignof(BucketT));
init(NewNumBuckets);
}
|
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
movl $0x40, %ebp
cmovgel %edx, %ebp
cmpl %eax, %ebp
jne 0x1a030d7
movq $0x0, 0x8(%rbx)
testq %rax, %rax
je 0x1a030d0
movq (%rbx), %rcx
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %rax
movq $-0x1000, %rdx # imm = 0xF000
movq %rdx, (%rcx)
movq %rdx, 0x8(%rcx)
addq $0x18, %rcx
cmpq %rax, %rcx
jne 0x1a030c0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq (%rbx), %rdi
shlq $0x3, %rax
leaq (%rax,%rax,2), %rsi
movl $0x8, %edx
callq 0x2b410f1
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1a01c96
|
/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<polly::Scop, polly::ScopStandardAnalysisResults&>::Invalidator>>>>, std::allocator<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<polly::Scop, polly::ScopStandardAnalysisResults&>::Invalidator>>>>>>, llvm::DenseMapInfo<polly::Scop*, void>, llvm::detail::DenseMapPair<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<polly::Scop, polly::ScopStandardAnalysisResults&>::Invalidator>>>>, std::allocator<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<polly::Scop, polly::ScopStandardAnalysisResults&>::Invalidator>>>>>>>>::shrink_and_clear()
|
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 (NewNumBuckets == NumBuckets) {
this->BaseT::initEmpty();
return;
}
deallocate_buffer(Buckets, sizeof(BucketT) * OldNumBuckets,
alignof(BucketT));
init(NewNumBuckets);
}
|
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
cmpl $0x41, %eax
movl $0x40, %ebp
cmovgel %eax, %ebp
movl 0x10(%rbx), %ecx
cmpl %ecx, %ebp
jne 0x1a0320e
movq $0x0, 0x8(%rbx)
testq %rcx, %rcx
je 0x1a03209
movq (%rbx), %rax
movabsq $0x7ffffffffffffff, %rdx # imm = 0x7FFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x1, %ecx
negq %rcx
addq %rdx, %rcx
addq $0x2, %rcx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
addq $0x20, %rax
xorl %edx, %edx
movdqa 0x11b1e8e(%rip), %xmm1 # 0x2bb5020
movdqa 0x11b1e96(%rip), %xmm2 # 0x2bb5030
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movq %rdx, %xmm4
pshufd $0x44, %xmm4, %xmm4 # xmm4 = xmm4[0,1,0,1]
por %xmm1, %xmm4
pxor %xmm2, %xmm4
movdqa %xmm4, %xmm5
pcmpgtd %xmm0, %xmm5
pcmpeqd %xmm0, %xmm4
pshufd $0xf5, %xmm4, %xmm6 # xmm6 = xmm4[1,1,3,3]
pand %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm4 # xmm4 = xmm5[1,1,3,3]
por %xmm6, %xmm4
movd %xmm4, %esi
notl %esi
testb $0x1, %sil
je 0x1a031e6
movq $-0x1000, -0x20(%rax) # imm = 0xF000
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %esi
testb $0x1, %sil
je 0x1a031fc
movq $-0x1000, (%rax) # imm = 0xF000
addq $0x2, %rdx
addq $0x40, %rax
cmpq %rdx, %rcx
jne 0x1a031a2
popq %rbx
popq %r14
popq %rbp
retq
movq (%rbx), %rdi
shlq $0x5, %r14
movl $0x8, %edx
movq %r14, %rsi
callq 0x2b410f1
movq %rbx, %rdi
movl %ebp, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x1a01b64
|
/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<decltype(CREATE_PASS)>::type>(NAME, Name, \
SPM)) \
return true;
#define SCOP_PASS(NAME, CREATE_PASS) \
if (Name == NAME) { \
SPM.addPass(CREATE_PASS); \
return true; \
}
#include "PollyPasses.def"
return false;
}
|
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 # 0x4f033e8
movl $0x9, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x1a03ab6
testb %al, %al
jne 0x1a039a6
leaq 0x34fff36(%rip), %rdi # 0x4f033f2
movl $0x11, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x1a03bb7
testb %al, %al
jne 0x1a039a6
xorl %ebp, %ebp
leaq -0x9(%r14), %r12
cmpq $0xf, %r12
ja 0x1a039a6
leaq 0x34fe09a(%rip), %rax # 0x4f01588
movslq (%rax,%r12,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x34fff89(%rip), %rsi # 0x4f03487
movq %r15, %rdi
movq %r14, %rdx
callq 0x780c70
testl %eax, %eax
je 0x1a037b0
xorl %ebp, %ebp
cmpq $0xf, %r12
ja 0x1a039a6
leaq 0x34fe264(%rip), %rax # 0x4f01788
movslq (%rax,%r12,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x34ffed0(%rip), %rsi # 0x4f03404
movq %r15, %rdi
movq %r14, %rdx
callq 0x780c70
testl %eax, %eax
je 0x1a03835
xorl %ebp, %ebp
cmpq $0xf, %r12
ja 0x1a039a6
leaq 0x34fe06e(%rip), %rax # 0x4f015c8
movslq (%rax,%r12,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x34ffec0(%rip), %rsi # 0x4f0342a
movq %r15, %rdi
movq %r14, %rdx
callq 0x780c70
testl %eax, %eax
je 0x1a0381d
xorl %ebp, %ebp
cmpq $0xf, %r12
ja 0x1a039a6
leaq 0x34fe0b8(%rip), %rax # 0x4f01648
movslq (%rax,%r12,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x34ffe9b(%rip), %rsi # 0x4f0343b
movq %r15, %rdi
movq %r14, %rdx
callq 0x780c70
testl %eax, %eax
je 0x1a03805
xorl %ebp, %ebp
cmpq $0xf, %r12
ja 0x1a039a6
leaq 0x34fe0c2(%rip), %rax # 0x4f01688
movslq (%rax,%r12,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x34ffe7e(%rip), %rsi # 0x4f03454
movq %r15, %rdi
movq %r14, %rdx
callq 0x780c70
testl %eax, %eax
je 0x1a037f5
xorl %ebp, %ebp
cmpq $0xf, %r12
ja 0x1a039a6
leaq 0x34fe0cc(%rip), %rax # 0x4f016c8
movslq (%rax,%r12,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x34ffe56(%rip), %rsi # 0x4f03462
movq %r15, %rdi
movq %r14, %rdx
callq 0x780c70
testl %eax, %eax
je 0x1a037df
xorl %ebp, %ebp
cmpq $0xf, %r12
ja 0x1a039a6
leaq 0x34fe0d6(%rip), %rax # 0x4f01708
movslq (%rax,%r12,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x34ffe2f(%rip), %rsi # 0x4f03471
movq %r15, %rdi
movq %r14, %rdx
callq 0x780c70
testl %eax, %eax
je 0x1a037c0
xorl %ebp, %ebp
cmpq $0xf, %r12
ja 0x1a039a6
leaq 0x34fe0e0(%rip), %rax # 0x4f01748
movslq (%rax,%r12,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x34ffe1c(%rip), %rsi # 0x4f03494
movq %r15, %rdi
movq %r14, %rdx
callq 0x780c70
testl %eax, %eax
je 0x1a03798
xorl %ebp, %ebp
cmpq $0xf, %r12
ja 0x1a039a6
leaq 0x34fe12a(%rip), %rax # 0x4f017c8
movslq (%rax,%r12,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x34ffdfa(%rip), %rsi # 0x4f034a8
movq %r15, %rdi
movq %r14, %rdx
callq 0x780c70
testl %eax, %eax
je 0x1a0393c
xorl %ebp, %ebp
leaq -0xd(%r14), %rax
cmpq $0xb, %rax
ja 0x1a0398c
leaq 0x34fe130(%rip), %rcx # 0x4f01808
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x34ffdcd(%rip), %rsi # 0x4f034b5
movq %r15, %rdi
movq %r14, %rdx
callq 0x780c70
testl %eax, %eax
je 0x1a03977
xorl %ebp, %ebp
cmpq $0xf, %r14
jle 0x1a03747
cmpq $0x10, %r14
je 0x1a038d5
cmpq $0x14, %r14
je 0x1a03875
cmpq $0x18, %r14
jne 0x1a039a6
leaq 0x34ffda1(%rip), %rsi # 0x4f034c9
movq %r15, %rdi
movq %r14, %rdx
callq 0x780c70
testl %eax, %eax
je 0x1a03855
xorl %ebp, %ebp
cmpq $0xf, %r14
jg 0x1a03865
cmpq $0x9, %r14
je 0x1a03897
cmpq $0xd, %r14
jne 0x1a039a6
leaq 0x34ffd80(%rip), %rsi # 0x4f034e2
movq %r15, %rdi
movq %r14, %rdx
callq 0x780c70
testl %eax, %eax
je 0x1a03845
cmpq $0x9, %r14
je 0x1a03897
cmpq $0x10, %r14
je 0x1a038d5
cmpq $0x14, %r14
je 0x1a03875
jmp 0x1a038eb
callq 0x2b7e507
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x1a03da8
jmp 0x1a039a3
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x19fbeea
jmp 0x1a039a3
callq 0x2b7e507
movq %rsp, %rsi
movq %rax, (%rsi)
movl $0x0, 0x8(%rsi)
movq %rbx, %rdi
callq 0x1a03d54
jmp 0x1a039a3
movq %rsp, %rsi
movl $0x0, (%rsi)
movq %rbx, %rdi
callq 0x19fbe9e
jmp 0x1a039a3
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x19fc14e
jmp 0x1a039a3
callq 0x2b7e507
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x1a03d06
jmp 0x1a039a3
callq 0x2b7e507
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x1a03cb8
jmp 0x1a039a3
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x19fc0c6
jmp 0x1a039a3
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x19fc082
jmp 0x1a039a3
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x19fc03e
jmp 0x1a039a3
cmpq $0x10, %r14
je 0x1a038d5
cmpq $0x14, %r14
jne 0x1a039a6
leaq 0x34ffc74(%rip), %rsi # 0x4f034f0
movq %r15, %rdi
movq %r14, %rdx
callq 0x780c70
testl %eax, %eax
je 0x1a03902
cmpq $0x10, %r14
je 0x1a038d5
cmpq $0x9, %r14
jne 0x1a038eb
leaq 0x34ffc67(%rip), %rsi # 0x4f03505
movq %r15, %rdi
movq %r14, %rdx
callq 0x780c70
testl %eax, %eax
je 0x1a038f2
cmpq $0x10, %r14
je 0x1a038d5
cmpq $0x9, %r14
jne 0x1a038eb
leaq 0x34ffc4f(%rip), %rsi # 0x4f0350f
movq %r15, %rdi
movq %r14, %rdx
callq 0x780c70
testl %eax, %eax
je 0x1a0392f
cmpq $0x10, %r14
jne 0x1a038eb
leaq 0x34ffc3d(%rip), %rsi # 0x4f03519
movq %r15, %rdi
movq %r14, %rdx
callq 0x780c70
testl %eax, %eax
je 0x1a0391a
xorl %ebp, %ebp
jmp 0x1a039a6
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x19fbfb6
jmp 0x1a039a3
callq 0x2b7e507
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x1a03e44
jmp 0x1a039a3
callq 0x2b7e507
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x1a03e92
jmp 0x1a039a3
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x19fbffa
jmp 0x1a039a3
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x19fbf2e
jmp 0x1a039a3
leaq 0x34ffac7(%rip), %rsi # 0x4f03417
movq %r15, %rdi
movq %r14, %rdx
callq 0x780c70
testl %eax, %eax
je 0x1a03998
xorl %ebp, %ebp
cmpq $0xf, %r12
ja 0x1a039a6
leaq 0x34fdc9a(%rip), %rax # 0x4f01608
movslq (%rax,%r12,4), %rcx
addq %rax, %rcx
jmpq *%rcx
callq 0x2b7e507
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x1a03df6
jmp 0x1a039a3
cmpq $0x9, %r14
je 0x1a03897
jmp 0x1a039a6
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x19fbf72
movb $0x1, %bpl
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/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::ScopStandardAnalysisResults&>, polly::ScopStandardAnalysisResults&, polly::SPMUpdater&>::addPass<polly::MaximalStaticExpansionPrinterPass>(polly::MaximalStaticExpansionPrinterPass&&)
|
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 compile times.
Passes.push_back(std::unique_ptr<PassConceptT>(
new PassModelT(std::forward<PassT>(Pass))));
}
|
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
testq %rdi, %rdi
je 0x1a03ed8
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>, polly::ScopStandardAnalysisResults&, polly::SPMUpdater&>::addPass<llvm::InvalidateAnalysisPass<llvm::PassInstrumentationAnalysis>>(llvm::InvalidateAnalysisPass<llvm::PassInstrumentationAnalysis>&&)
|
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 compile times.
Passes.push_back(std::unique_ptr<PassConceptT>(
new PassModelT(std::forward<PassT>(Pass))));
}
|
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(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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::ScopStandardAnalysisResults&>, polly::ScopStandardAnalysisResults&, polly::SPMUpdater&>>, void>::type llvm::PassManager<polly::Scop, llvm::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>, polly::ScopStandardAnalysisResults&, polly::SPMUpdater&>::addPass<llvm::RequireAnalysisPass<llvm::PassInstrumentationAnalysis, polly::Scop, llvm::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>, polly::ScopStandardAnalysisResults&, polly::SPMUpdater&>>(llvm::RequireAnalysisPass<llvm::PassInstrumentationAnalysis, polly::Scop, llvm::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>, polly::ScopStandardAnalysisResults&, polly::SPMUpdater&>&&)
|
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 compile times.
Passes.push_back(std::unique_ptr<PassConceptT>(
new PassModelT(std::forward<PassT>(Pass))));
}
|
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(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/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::ScopStandardAnalysisResults&, polly::SPMUpdater&)
|
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 %rdx, 0x38(%rbx)
movq %rax, 0x40(%rbx)
movl %ecx, 0x48(%rbx)
leaq 0x3fa26f5(%rip), %rdx # 0x59a68b8
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0xade436
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
retq
nop
|
/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 0x7f9ba8
movq 0x20(%rax), %rcx
cmpq 0x18(%rax), %rcx
jae 0x1a043c7
leaq 0x1(%rcx), %rdx
movq %rdx, 0x20(%rax)
movb $0x3e, (%rcx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
movl $0x3e, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x2b7d68e
nop
|
/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*>, llvm::ReassociatePass::PairMapValue, llvm::DenseMapInfo<std::pair<llvm::Value*, llvm::Value*>, void>, llvm::detail::DenseMapPair<std::pair<llvm::Value*, llvm::Value*>, llvm::ReassociatePass::PairMapValue>>::destroyAll()
|
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), %rcx
movq %rax, %rdx
xorq %r15, %rdx
movq %rcx, %rsi
xorq %r15, %rsi
orq %rdx, %rsi
je 0x1a07a0d
xorq %r12, %rax
xorq %r12, %rcx
orq %rax, %rcx
jne 0x1a07a20
leaq -0x28(%rbx), %rax
addq $0x48, %rbx
addq $0x48, %rax
cmpq %r14, %rax
jne 0x1a079e9
jmp 0x1a07a65
movq 0x10(%rbx), %rax
cmpq $-0x2000, %rax # imm = 0xE000
je 0x1a07a41
cmpq $-0x1000, %rax # imm = 0xF000
je 0x1a07a41
testq %rax, %rax
je 0x1a07a41
movq %rbx, %rdi
callq 0x2aa1dc0
movq -0x8(%rbx), %rax
cmpq $-0x2000, %rax # imm = 0xE000
je 0x1a07a0d
cmpq $-0x1000, %rax # imm = 0xF000
je 0x1a07a0d
testq %rax, %rax
je 0x1a07a0d
leaq -0x18(%rbx), %rdi
callq 0x2aa1dc0
jmp 0x1a07a0d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/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 $0x5, %eax
andl $0x60, %eax
andl $-0x61, %ecx
orl %eax, %ecx
movw %cx, 0xa(%r13)
movq (%rbx), %rsi
movq %r13, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2b1f3c8
|
/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 0x2b410f1
addq $-0x18, %r15
cmpq $-0x1b0, %r15 # imm = 0xFE50
jne 0x1a08ada
leaq 0x50(%rbx), %rdi
callq 0x1a07a72
movq 0x38(%rbx), %rdi
movl 0x48(%rbx), %esi
shlq $0x3, %rsi
movl $0x8, %edx
callq 0x2b410f1
movq 0x20(%rbx), %rdi
movl 0x30(%rbx), %esi
shlq $0x4, %rsi
movl $0x8, %edx
callq 0x2b410f1
movq 0x8(%rbx), %rdi
movl 0x18(%rbx), %esi
shlq $0x4, %rsi
movl $0x8, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x2b410f1
|
/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 $0x0, 0xb0(%r14)
leaq 0x3e70b55(%rip), %rax # 0x587b030
addq $0x10, %rax
movq %rax, (%r14)
movups %xmm0, 0xb8(%r14)
movq $0x0, 0xc8(%r14)
leaq 0x3eed58c(%rip), %rax # 0x58f7a88
addq $0x10, %rax
movq %rax, 0xd0(%r14)
movups %xmm0, 0xd8(%r14)
leaq 0x40ec(%rip), %rax # 0x1a0e602
movq %rax, 0xf0(%r14)
leaq 0x40e0(%rip), %rax # 0x1a0e604
movq %rax, 0xe8(%r14)
movq %r14, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
movq %rbx, %r9
callq 0x1a0e583
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2b1e814
|
/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 GetDeps = [&Deps](Dependences::AnalysisLevel) -> const Dependences & {
return Deps.getDependences(Dependences::AL_Statement);
};
OptimizationRemarkEmitter ORE(&S.getFunction());
TargetTransformInfo *TTI = &SAR.TTI;
isl::schedule LastSchedule;
bool DepsChanged = false;
runIslScheduleOptimizer(S, GetDeps, TTI, &ORE, LastSchedule, DepsChanged);
if (DepsChanged)
Deps.abandonDependences();
if (OS) {
*OS << "Printing analysis 'Polly - Optimize schedule of SCoP' for region: '"
<< S.getName() << "' in function '" << S.getFunction().getName()
<< "':\n";
runScheduleOptimizerPrinter(*OS, LastSchedule);
}
return PreservedAnalyses::all();
}
|
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 0x20(%r15), %rax
movq (%rax), %rax
andq $-0x8, %rax
movq 0x48(%rax), %rsi
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x267b1b8
movq 0x28(%r13), %rcx
leaq 0x18(%rsp), %r9
movq $0x0, (%r9)
leaq 0x17(%rsp), %r13
movb $0x0, (%r13)
movq %r13, (%rsp)
leaq 0x2fd3(%rip), %rsi # 0x1a0de12
movq %r15, %rdi
movq %rbp, %rdx
movq %r14, %r8
callq 0x1a0b58c
cmpb $0x1, (%r13)
jne 0x1a0ae5c
movq %r12, %rdi
callq 0x1a3bbe0
movq 0x20(%rsp), %r12
testq %r12, %r12
je 0x1a0af12
leaq 0x34f9f23(%rip), %rsi # 0x4f04d94
movl $0x43, %edx
movq %r12, %rdi
callq 0x7f9ba8
movq %rax, %r14
movq %r15, %rdi
callq 0x1a0ddb6
movq %r14, %rdi
movq %rax, %rsi
callq 0x7f9ba8
leaq 0x34f9f3d(%rip), %rsi # 0x4f04dd8
movl $0xf, %edx
movq %rax, %rdi
callq 0x7f9ba8
movq %rax, %r14
movq 0x20(%r15), %rax
movq (%rax), %rax
andq $-0x8, %rax
movq 0x48(%rax), %rdi
callq 0x2a9f76a
movq %r14, %rdi
movq %rax, %rsi
callq 0x7f9ba8
leaq 0x34f9f17(%rip), %rsi # 0x4f04de8
movl $0x3, %edx
movq %rax, %rdi
callq 0x7f9ba8
leaq 0x28(%rsp), %r14
movq $0x0, (%r14)
movq 0x18(%rsp), %rdi
callq 0x1b55ef1
movq %rax, %r15
movq %rax, (%r14)
movq %r12, %rdi
movq %r14, %rsi
callq 0x1a0dcd7
testq %r15, %r15
je 0x1a0af12
movq %r15, %rdi
callq 0x1b55e86
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 %rdx, 0x38(%rbx)
movq %rax, 0x40(%rbx)
movl %ecx, 0x48(%rbx)
leaq 0x3f9b973(%rip), %rdx # 0x59a68b8
leaq 0x50(%rsp), %rdi
movq %rbx, %rsi
callq 0xade436
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x1a0af61
callq 0x1b55e86
leaq 0x48(%rsp), %rdi
callq 0xa4f8aa
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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
jmp 0x1b55e86
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/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
// transformations have been performed. This can e.g. be tiling, loop
// interchange, or ...) We can track this either at the place where the
// transformation has been performed or, in case of automatic ILP based
// optimizations, by comparing (yet to be defined) performance metrics
// before/after the scheduling optimizer
// (e.g., #stride-one accesses)
// FIXME: A schedule tree whose union_map-conversion is identical to the
// original schedule map may still allow for parallelization, i.e. can still
// be profitable.
auto NewScheduleMap = NewSchedule.get_map();
auto OldSchedule = S.getSchedule();
assert(!OldSchedule.is_null() &&
"Only IslScheduleOptimizer can insert extension nodes "
"that make Scop::getSchedule() return nullptr.");
bool changed = !OldSchedule.is_equal(NewScheduleMap);
return changed;
}
|
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 0x7808d0
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x3e6f046(%rip), %rcx # 0x587aff8
addq $0x10, %rcx
movq %rcx, (%rax)
leaq 0x10(%rax), %rcx
movb $0x0, 0x10(%rax)
movq %rax, 0x8(%r14)
movq %rcx, (%r14)
movl %ebp, 0x10(%r14)
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1a0dbd2
movq %r15, %rdi
callq 0x1a09b4a
movl %eax, %ebp
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x1a0bff4
callq 0xa775b8
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1a0c003
callq 0xa775b8
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1a0c011
callq 0x1b8cd9e
testq %rbx, %rbx
je 0x1a0c01e
movq %rbx, %rdi
callq 0x1b8cd9e
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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, (%rax)
movb $0x1, 0x10(%rax)
movq %rax, %rdi
callq 0xa775b8
cmpl $0x6, %ebp
je 0x1a0d6e5
movq (%r14), %rdi
callq 0x1b57721
leaq 0x34f74cd(%rip), %rdx # 0x4f04b62
leaq 0x34f74ed(%rip), %rcx # 0x4f04b89
movq %rax, %rdi
movl $0x5, %esi
movl $0x4446, %r8d # imm = 0x4446
callq 0x1af81bb
xorl %eax, %eax
jmp 0x1a0d6ed
movl $0x18, %edi
callq 0x7808d0
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x3e6d926(%rip), %rcx # 0x587aff8
addq $0x10, %rcx
movq %rcx, (%rax)
movb $0x1, 0x10(%rax)
movq %rax, %rdi
callq 0xa775b8
movq (%r14), %rdi
callq 0x1b578ac
movq %rax, (%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
|
/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::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 const&, llvm::cl::OptionHidden const&, llvm::cl::initializer<char [3]> const&, llvm::cl::cat const&)
|
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
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2b1f3c8
|
/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 0x1a13230
movl 0x8(%rbx), %r14d
testq %r14, %r14
je 0x1a13273
movq (%rbx), %rbx
shlq $0x3, %r14
movq -0x8(%rbx,%r14), %rdi
testq %rdi, %rdi
je 0x1a1326d
callq 0x1b57667
addq $-0x8, %r14
jne 0x1a1325e
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/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::TakesParamByValue) {
if (LLVM_UNLIKELY(This->isReferenceToStorage(&Elt))) {
ReferencesStorage = true;
Index = &Elt - This->begin();
}
}
This->grow(NewSize);
return ReferencesStorage ? This->begin() + Index : &Elt;
}
|
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
cmpq %rbx, %rcx
seta %bpl
andb %sil, %bpl
movq $-0x1, %r15
cmpb $0x1, %bpl
je 0x1a13628
movq %r14, %rdi
movq %rdx, %rsi
callq 0x1a13634
testb %bpl, %bpl
je 0x1a135d6
shlq $0x3, %r15
addq (%r14), %r15
movq %r15, %rbx
jmp 0x1a135d6
movq %rbx, %r15
subq %rax, %r15
sarq $0x3, %r15
jmp 0x1a1360c
|
/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 0x1a136ae
movl 0x8(%rbx), %r14d
testq %r14, %r14
je 0x1a136f1
movq (%rbx), %rbx
shlq $0x3, %r14
movq -0x8(%rbx,%r14), %rdi
testq %rdi, %rdi
je 0x1a136eb
callq 0x1b8d068
addq $-0x8, %r14
jne 0x1a136dc
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/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
setne %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x1a1891d
decl %r14d
xorl %r13d, %r13d
leaq 0x8(%rsp), %r15
leaq 0x34f0992(%rip), %r12 # 0x4f0924d
movq (%rsp), %rdi
movl %r13d, %esi
callq 0x1b25eea
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
movl $0x4, %esi
callq 0x2b7d99a
movq %rax, %rdi
movq %r15, %rsi
callq 0x1a1893a
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x7f9ba8
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1a18903
callq 0x1b0fdb2
movq %rsp, %rax
cmpq %rbp, %rax
setne %al
cmpl %r13d, %r14d
leal 0x1(%r13), %ecx
setne %dl
orb %al, %dl
movl %ecx, %r13d
jne 0x1a188bb
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1a1892b
callq 0x1b25bfc
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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 %rbx
retq
|
/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.project_out(isl::dim::set, 1, SetDims - 1);
return bool(Set.is_bounded());
}
|
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), %r12 # 0x587aff8
addq $0x10, %r12
movq %r12, (%rax)
leaq 0x10(%rax), %rcx
movb $0x0, 0x10(%rax)
movq %rax, 0x8(%r14)
movq %rcx, (%r14)
movl %ebp, 0x10(%r14)
movb $0x1, 0x10(%rax)
movq %r14, %rdi
callq 0x1a0d056
movl %eax, %ebp
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x1a1a481
callq 0xa775b8
movq (%rbx), %rdi
callq 0x1b10b72
movq %rax, %rdi
movl $0x1, %esi
xorl %edx, %edx
movl %ebp, %ecx
callq 0x1b15aed
movq (%rbx), %rdi
movq %rax, (%rbx)
testq %rdi, %rdi
je 0x1a1a4aa
callq 0x1b139c2
movq (%rbx), %rdi
callq 0x1b10b72
movq %rax, %rdi
movl $0x3, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x1b15aed
movq (%rbx), %rdi
movq %rax, (%rbx)
testq %rdi, %rdi
je 0x1a1a4d3
callq 0x1b139c2
movq (%rbx), %rdi
callq 0x1b0f2d0
movl %eax, %ebp
leaq 0x8(%rsp), %r14
movq $0x0, (%r14)
movl $0x18, %edi
callq 0x7808d0
movq %r15, 0x8(%rax)
movq %r12, (%rax)
leaq 0x10(%rax), %rcx
movb $0x0, 0x10(%rax)
movq %rax, 0x8(%r14)
movq %rcx, (%r14)
movl %ebp, 0x10(%r14)
movb $0x1, 0x10(%rax)
movq %r14, %rdi
callq 0x1a0d056
movl %eax, %ebp
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x1a1a529
callq 0xa775b8
decl %ebp
movq (%rbx), %rdi
callq 0x1b10b72
movq %rax, %rdi
movl $0x3, %esi
movl $0x1, %edx
movl %ebp, %ecx
callq 0x1b15aed
movq (%rbx), %rdi
movq %rax, (%rbx)
testq %rdi, %rdi
je 0x1a1a557
callq 0x1b139c2
movq (%rbx), %rdi
callq 0x1af296b
movl %eax, %ebx
leaq 0x8(%rsp), %r14
movq $0x0, (%r14)
movl $0x18, %edi
callq 0x7808d0
movq %r15, 0x8(%rax)
movq %r12, (%rax)
leaq 0x10(%rax), %rcx
movb $0x0, 0x10(%rax)
movq %rax, 0x8(%r14)
movq %rcx, (%r14)
movl %ebx, 0x10(%r14)
movq %r14, %rdi
callq 0x1a09b4a
movl %eax, %ebx
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x1a1a5a9
callq 0xa775b8
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/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(%rip), %rax # 0x57479c8
addq $0x10, %rax
movq %rax, 0x88(%r14)
leaq 0x3edce25(%rip), %rax # 0x58f7c68
addq $0x10, %rax
movq %rax, (%r14)
leaq 0x3edccc7(%rip), %rax # 0x58f7b18
addq $0x10, %rax
movq %rax, 0x98(%r14)
movups %xmm0, 0xa0(%r14)
leaq -0x121de7b(%rip), %rax # 0x7fcff0
movq %rax, 0xb8(%r14)
leaq -0x121de87(%rip), %rax # 0x7fcff2
movq %rax, 0xb0(%r14)
movq %r14, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
movq %rbx, %r9
callq 0x1a2042d
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2b1e814
|
/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.Execute = std::move(Execute);
Result.Depends.append(Depends.begin(), Depends.end());
return Result;
}
|
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 0x38(%rbx), %rax
movq %rax, 0x28(%rbx)
movabsq $0x400000000, %rax # imm = 0x400000000
movq %rax, 0x30(%rbx)
orl $0x2, %r8d
movl %r8d, (%rbx)
callq 0x1a1d906
shlq $0x4, %r14
addq %r15, %r14
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1a1d990
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/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, llvm::DenseMapInfo<std::pair<llvm::Value*, polly::ScopStmt*>, void>, llvm::detail::DenseSetPair<std::pair<llvm::Value*, polly::ScopStmt*>>>::moveFromOldBuckets(llvm::detail::DenseSetPair<std::pair<llvm::Value*, polly::ScopStmt*>>*, llvm::detail::DenseSetPair<std::pair<llvm::Value*, polly::ScopStmt*>>*)
|
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::isEqual(B->getFirst(), EmptyKey) &&
!KeyInfoT::isEqual(B->getFirst(), TombstoneKey)) {
// Insert the key/value into the new table.
BucketT *DestBucket;
bool FoundVal = LookupBucketFor(B->getFirst(), DestBucket);
(void)FoundVal; // silence warning.
assert(!FoundVal && "Key already in new map?");
DestBucket->getFirst() = std::move(B->getFirst());
::new (&DestBucket->getSecond()) ValueT(std::move(B->getSecond()));
incrementNumEntries();
// Free the value.
B->getSecond().~ValueT();
}
B->getFirst().~KeyT();
}
}
|
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, 0x8(%rcx)
addq $0x10, %rcx
cmpq %rax, %rcx
jne 0x1a1fbe1
cmpq %rbx, %r14
je 0x1a1fc57
movq $-0x1000, %r13 # imm = 0xF000
movq $-0x2000, %rbp # imm = 0xE000
movq %rsp, %r12
movq (%r14), %rax
movq 0x8(%r14), %rcx
movq %rax, %rdx
xorq %r13, %rdx
movq %rcx, %rsi
xorq %r13, %rsi
orq %rdx, %rsi
je 0x1a1fc4e
xorq %rbp, %rax
xorq %rbp, %rcx
orq %rax, %rcx
je 0x1a1fc4e
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x1a1f992
movq (%rsp), %rax
movq (%r14), %rcx
movq %rcx, (%rax)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rax)
incl 0x8(%r15)
addq $0x10, %r14
cmpq %rbx, %r14
jne 0x1a1fc07
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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
shll $0x5, %eax
andl $0x60, %eax
andl $-0x61, %ecx
orl %eax, %ecx
movw %cx, 0xa(%r15)
popq %rbx
popq %r14
popq %r15
retq
|
/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, unsigned Indent) {
Knowledge Existing(std::move(ExistingOccupied), std::move(ExistingUnused),
std::move(ExistingKnown), std::move(ExistingWrites));
Knowledge Proposed(std::move(ProposedOccupied), std::move(ProposedUnused),
std::move(ProposedKnown), std::move(ProposedWrites));
return Knowledge::isConflicting(Existing, Proposed, OS, Indent);
}
|
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
movq %rbx, (%r14)
movq (%r12), %rdi
callq 0x1b8cb99
movq %rax, %r12
movq %rax, (%r14)
leaq 0x90(%rsp), %r13
movq %rbx, (%r13)
movq (%rbp), %rdi
callq 0x1b8d04d
movq %rax, %rbp
movq %rax, (%r13)
leaq 0x88(%rsp), %r14
movq %rbx, (%r14)
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x1b8d04d
movq %rax, %rbx
movq %rax, (%r14)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %r13, %rcx
movq %r14, %r8
callq 0x1a20c44
testq %rbx, %rbx
je 0x1a20aa1
movq %rbx, %rdi
callq 0x1b8cd9e
testq %rbp, %rbp
je 0x1a20aae
movq %rbp, %rdi
callq 0x1b8cd9e
testq %r12, %r12
je 0x1a20abb
movq %r12, %rdi
callq 0x1b8d068
movq 0xd0(%rsp), %r12
testq %r15, %r15
je 0x1a20ad0
movq %r15, %rdi
callq 0x1b8d068
xorl %ebp, %ebp
leaq 0x20(%rsp), %rbx
movq %rbp, (%rbx)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x1b8cb99
movq %rax, %r14
movq %rax, (%rbx)
leaq 0x18(%rsp), %r15
movq %rbp, (%r15)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x1b8cb99
movq %rax, %rbx
movq %rax, (%r15)
leaq 0x80(%rsp), %r15
movq %rbp, (%r15)
movq (%r12), %rdi
callq 0x1b8d04d
movq %rax, %r12
movq %rax, (%r15)
leaq 0x78(%rsp), %r13
movq %rbp, (%r13)
movq 0xd8(%rsp), %rax
movq (%rax), %rdi
callq 0x1b8d04d
movq %rax, %rbp
movq %rax, (%r13)
leaq 0x58(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x18(%rsp), %rdx
movq %r15, %rcx
movq %r13, %r8
callq 0x1a20c44
testq %rbp, %rbp
je 0x1a20b69
movq %rbp, %rdi
callq 0x1b8cd9e
testq %r12, %r12
je 0x1a20b76
movq %r12, %rdi
callq 0x1b8cd9e
testq %rbx, %rbx
je 0x1a20b83
movq %rbx, %rdi
callq 0x1b8d068
movl 0xe8(%rsp), %ebx
movq 0xe0(%rsp), %r15
testq %r14, %r14
je 0x1a20b9f
movq %r14, %rdi
callq 0x1b8d068
leaq 0x38(%rsp), %rdi
leaq 0x58(%rsp), %r14
movq %r14, %rsi
movq %r15, %rdx
movl %ebx, %ecx
callq 0x1a20ca6
movl %eax, %ebx
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x1a20bc6
callq 0x1b8cd9e
movq 0x68(%rsp), %rdi
testq %rdi, %rdi
je 0x1a20bd5
callq 0x1b8cd9e
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x1a20be4
callq 0x1b8d068
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x1a20bf3
callq 0x1b8d068
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x1a20c02
callq 0x1b8cd9e
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x1a20c11
callq 0x1b8cd9e
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x1a20c20
callq 0x1b8d068
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x1a20c2f
callq 0x1b8d068
movl %ebx, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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 = getScatterSpace(Schedule);
}
|
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)
jmp 0x1a25ec3
lock
incl 0x8(%rax)
xorl %r12d, %r12d
movl %r12d, 0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movq %r15, 0x30(%rbx)
movq %rcx, 0x38(%rbx)
leaq 0x40(%rbx), %r13
leaq 0x50(%rbx), %r14
movups %xmm0, 0x40(%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x1a54a92
movq %r12, 0xa8(%rbx)
leaq 0xd0(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rbx)
movups %xmm0, 0x68(%rbx)
movups %xmm0, 0x78(%rbx)
movups %xmm0, 0x88(%rbx)
movups %xmm0, 0x94(%rbx)
movq %rax, 0xb0(%rbx)
movq %rax, 0xb8(%rbx)
movq $0x4, 0xc0(%rbx)
movl %r12d, 0xc8(%rbx)
movups %xmm0, 0xf0(%rbx)
movl %r12d, 0x100(%rbx)
movq %r12, 0x108(%rbx)
leaq 0x110(%rbx), %rdi
xorl %esi, %esi
callq 0x1a29ca4
movl %r12d, 0x168(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x158(%rbx)
movq %rsp, %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x1a58774
movq (%r12), %rdi
callq 0x1b8cb99
movq %rax, %r15
movq 0x50(%rbx), %rdi
callq 0x1b8d04d
movq %rax, %rdi
movq %r15, %rsi
callq 0x1b8ddce
movq 0x50(%rbx), %rdi
movq %rax, 0x50(%rbx)
testq %rdi, %rdi
je 0x1a25faf
callq 0x1b8cd9e
movq (%r14), %rdi
callq 0x1b8cc91
movq (%r13), %rdi
movq %rax, (%r13)
testq %rdi, %rdi
je 0x1a25fc9
callq 0x1b6fe0a
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1a8f6c8
movq 0x48(%rbx), %rdi
movq (%r15), %rax
movq %rax, 0x48(%rbx)
movq %rdi, (%r15)
testq %rdi, %rdi
je 0x1a25ff1
callq 0x1b6fe0a
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1a25fff
callq 0x1b8d068
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/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, %r14
movq %rbx, 0x38(%rsp)
movq 0x50(%rsp), %rdx
leaq 0x48(%rsp), %r12
movq %r12, %rdi
callq 0x1a27e50
xorl %ebp, %ebp
leaq 0x40(%rsp), %r13
movq %rbp, (%r13)
movq 0x50(%r15), %rdi
callq 0x1b8d04d
movq %rax, (%r13)
movq (%r12), %rdi
callq 0x1b10b72
movq %rax, %rbx
movq %rax, %rdi
callq 0x1b0fb8c
movq %rax, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
movq %r13, %rsi
callq 0x1a8f6c8
movq (%r13), %rdi
callq 0x1b8d04d
movq %rax, %r13
movq %rbx, 0x30(%rsp)
movq %rbx, %rdi
callq 0x1b10b72
movq %rax, %rdi
callq 0x1b8d278
movq %rax, 0x20(%rsp)
movq %rax, %rdi
callq 0x1b8cb99
movq %rax, %rdi
callq 0x1b8e70b
movq %rax, %r15
leaq 0x58(%rsp), %r12
movq %rbp, (%r12)
movq %r13, 0x28(%rsp)
movq %r13, %rdi
callq 0x1b8d04d
movq %rax, %r13
movq %rax, (%r12)
leaq 0x60(%rsp), %rbx
movq %rbp, (%rbx)
movq %r15, %rdi
callq 0x1b8d04d
movq %rax, %rbp
movq %rax, (%rbx)
movq %rsp, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x1a28e3e
testq %rbp, %rbp
je 0x1a275fd
movq %rbp, %rdi
callq 0x1b8cd9e
testq %r13, %r13
je 0x1a2760a
movq %r13, %rdi
callq 0x1b8cd9e
movq (%rsp), %rdi
callq 0x1b8d04d
movq %rax, %rdi
callq 0x1b8fdab
movq %rax, %r13
movq %rax, %rdi
callq 0x1b8d04d
movq %rax, %rdi
callq 0x1b8eda1
movq %rax, %rbp
movq %rax, %rdi
callq 0x1b8cb99
movq %rax, %rdi
callq 0x1b8f281
movq %rax, %r12
testq %rbp, %rbp
je 0x1a27651
movq %rbp, %rdi
callq 0x1b8d068
testq %r13, %r13
je 0x1a2765e
movq %r13, %rdi
callq 0x1b8cd9e
movq (%rsp), %rdi
testq %rdi, %rdi
movq 0x8(%rsp), %rbx
je 0x1a27671
callq 0x1b8cd9e
testq %r15, %r15
je 0x1a2767e
movq %r15, %rdi
callq 0x1b8cd9e
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x1a2768d
callq 0x1b8d068
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x1a2769c
callq 0x1b8cd9e
movq %rbx, %rdi
callq 0x1b6fd4e
movq %rax, %rbx
movq 0x18(%rsp), %rdi
callq 0x1b6fd4e
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1b728db
movq %rax, %r15
xorl %r13d, %r13d
movq %rsp, %rbx
movq %r13, (%rbx)
movq %r12, %rbp
movq %r12, %rdi
callq 0x1b8d04d
movq %rax, (%rbx)
leaq 0x58(%rsp), %r12
movq %r13, (%r12)
movq %r15, %rdi
callq 0x1b6fd4e
movq %rax, (%r12)
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x1a8f4f1
movq (%r12), %rdi
testq %rdi, %rdi
je 0x1a27709
callq 0x1b6fe0a
movq (%rsp), %rdi
testq %rdi, %rdi
movq 0x38(%rsp), %rbx
je 0x1a2771c
callq 0x1b8cd9e
testq %r15, %r15
movq 0x8(%rsp), %r13
je 0x1a2772e
movq %r15, %rdi
callq 0x1b6fe0a
testq %rbp, %rbp
je 0x1a2773b
movq %rbp, %rdi
callq 0x1b8cd9e
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x1a2774a
callq 0x1b6fe0a
addq $0x8, %r14
testq %r13, %r13
je 0x1a2775b
movq %r13, %rdi
callq 0x1b6fe0a
movq (%r14), %rdi
movq 0x10(%rsp), %rax
movq %rax, (%r14)
movq %rdi, 0x10(%rsp)
testq %rdi, %rdi
je 0x1a27775
callq 0x1b0fdb2
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x1a27784
callq 0x1b139c2
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x1a27793
callq 0x1b8cd9e
movq %r14, %rdi
callq 0x1a906fd
movq $0x0, (%rbx)
movq (%r14), %rdi
callq 0x1b10b80
movq %rax, (%rbx)
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x1a277bc
callq 0x1b139c2
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/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
movq %rax, %r12
movq (%r13), %r15
movq %r15, %rdi
callq 0x1b10b80
movq %rax, %rdi
movq %r12, %rsi
callq 0x1b176e0
movq %rax, (%rbx)
testq %r15, %r15
je 0x1a2818c
movq %r15, %rdi
callq 0x1b0fdb2
testq %r14, %r14
je 0x1a28199
movq %r14, %rdi
callq 0x1afe3ec
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/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 = Unwrapped.get_tuple_id(isl::dim::out);
if (OutTupleId.is_null())
return isl::boolean();
auto *PHI = dyn_cast<PHINode>(static_cast<Value *>(OutTupleId.get_user()));
if (!PHI)
return true;
isl::id InTupleId = Unwrapped.get_tuple_id(isl::dim::in);
if (OutTupleId.is_null())
return isl::boolean();
auto *IncomingStmt = static_cast<ScopStmt *>(InTupleId.get_user());
MemoryAccess *PHIRead = IncomingStmt->lookupPHIReadOf(PHI);
if (!isNormalizable(PHIRead))
return true;
return false;
}
|
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 $0x18, %edi
callq 0x7808d0
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x3e527b6(%rip), %r12 # 0x587aff8
addq $0x10, %r12
movq %r12, (%rax)
leaq 0x10(%rax), %rcx
movb $0x0, 0x10(%rax)
movq %rax, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movl %ebp, 0x30(%rsp)
movb $0x1, 0x10(%rax)
cmpl $0x1, %ebp
jne 0x1a288fd
movq %r13, 0x18(%rsp)
movq %r15, %rdi
callq 0x1b6fd4e
movq %rax, %rdi
callq 0x1b73436
movq %rax, %rbp
movq %rax, %rdi
movl $0x3, %esi
callq 0x1b70067
movq %rax, %r13
testq %rax, %rax
je 0x1a2890f
movq %rbp, 0x8(%rsp)
movq %r13, %rdi
callq 0x1aff14a
cmpb $0x54, (%rax)
jne 0x1a2894c
movq %rax, %rbp
movq 0x8(%rsp), %rdi
movl $0x2, %esi
callq 0x1b70067
movq %rax, 0x10(%rsp)
movq %rax, %rdi
callq 0x1aff14a
leaq 0xc8(%rax), %rdi
leaq 0x40(%rsp), %rsi
movq %rbp, (%rsi)
leaq 0x38(%rsp), %rdx
callq 0x1a1f4b4
testb %al, %al
je 0x1a2898b
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rsi
jmp 0x1a2898d
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x1a0dbd2
jmp 0x1a289fe
movq $0x0, (%rbx)
movl $0x18, %edi
callq 0x7808d0
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
movq %r12, (%rax)
leaq 0x10(%rax), %rcx
movb $0x0, 0x10(%rax)
movq %rax, 0x8(%rbx)
movq %rcx, (%rbx)
movl $0xffffffff, 0x10(%rbx) # imm = 0xFFFFFFFF
jmp 0x1a289e4
movq $0x0, (%rbx)
movl $0x18, %edi
callq 0x7808d0
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
movq %r12, (%rax)
leaq 0x10(%rax), %rcx
movb $0x0, 0x10(%rax)
movq %rax, 0x8(%rbx)
movq %rcx, (%rbx)
movl $0x1, 0x10(%rbx)
movq 0x8(%rsp), %rbp
jmp 0x1a289e4
xorl %esi, %esi
movq 0x18(%rsp), %rdi
callq 0x1a28744
xorb $0x1, %al
movzbl %al, %ebp
movq $0x0, (%rbx)
movl $0x18, %edi
callq 0x7808d0
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
movq %r12, (%rax)
leaq 0x10(%rax), %rcx
movb $0x0, 0x10(%rax)
movq %rax, 0x8(%rbx)
movq %rcx, (%rbx)
movl %ebp, 0x10(%rbx)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
movq 0x8(%rsp), %rbp
je 0x1a289e4
callq 0x1afe3ec
testq %r13, %r13
je 0x1a289f1
movq %r13, %rdi
callq 0x1afe3ec
testq %rbp, %rbp
je 0x1a289fe
movq %rbp, %rdi
callq 0x1b6fe0a
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x1a28a0d
callq 0xa775b8
testq %r15, %r15
je 0x1a28a1a
movq %r15, %rdi
callq 0x1b6fe0a
testq %r14, %r14
je 0x1a28a27
movq %r14, %rdi
callq 0x1b6fe0a
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/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), %rax
andl $0x1, (%rbx)
movl $0x0, 0x4(%rbx)
cmoveq 0x8(%rbx), %rax
movl $0x4, %ecx
cmovel 0x10(%rbx), %ecx
testl %ecx, %ecx
je 0x1a29da8
movl %ecx, %ecx
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x1, %ecx
negq %rcx
addq %rdx, %rcx
addq $0x2, %rcx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
addq $0x10, %rax
xorl %edx, %edx
movdqa 0x118b2ef(%rip), %xmm1 # 0x2bb5020
movdqa 0x118b2f7(%rip), %xmm2 # 0x2bb5030
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movq %rdx, %xmm4
pshufd $0x44, %xmm4, %xmm4 # xmm4 = xmm4[0,1,0,1]
por %xmm1, %xmm4
pxor %xmm2, %xmm4
movdqa %xmm4, %xmm5
pcmpgtd %xmm0, %xmm5
pcmpeqd %xmm0, %xmm4
pshufd $0xf5, %xmm4, %xmm6 # xmm6 = xmm4[1,1,3,3]
pand %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm4 # xmm4 = xmm5[1,1,3,3]
por %xmm6, %xmm4
movd %xmm4, %esi
notl %esi
testb $0x1, %sil
je 0x1a29d85
movq $-0x1000, -0x10(%rax) # imm = 0xF000
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %esi
testb $0x1, %sil
je 0x1a29d9b
movq $-0x1000, (%rax) # imm = 0xF000
addq $0x2, %rdx
addq $0x20, %rax
cmpq %rdx, %rcx
jne 0x1a29d41
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
|
/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<BucketT *>(&TmpStorage);
BucketT *TmpEnd = TmpBegin;
// Loop over the buckets, moving non-empty, non-tombstones into the
// temporary storage. Have the loop move the TmpEnd forward as it goes.
const KeyT EmptyKey = this->getEmptyKey();
const KeyT TombstoneKey = this->getTombstoneKey();
for (BucketT *P = getBuckets(), *E = P + InlineBuckets; P != E; ++P) {
if (!KeyInfoT::isEqual(P->getFirst(), EmptyKey) &&
!KeyInfoT::isEqual(P->getFirst(), TombstoneKey)) {
assert(size_t(TmpEnd - TmpBegin) < InlineBuckets &&
"Too many inline buckets!");
::new (&TmpEnd->getFirst()) KeyT(std::move(P->getFirst()));
::new (&TmpEnd->getSecond()) ValueT(std::move(P->getSecond()));
++TmpEnd;
P->getSecond().~ValueT();
}
P->getFirst().~KeyT();
}
// AtLeast == InlineBuckets can happen if there are many tombstones,
// and grow() is used to remove them. Usually we always switch to the
// large rep here.
if (AtLeast > InlineBuckets) {
Small = false;
new (getLargeRep()) LargeRep(allocateBuckets(AtLeast));
}
this->moveFromOldBuckets(TmpBegin, TmpEnd);
return;
}
LargeRep OldRep = std::move(*getLargeRep());
getLargeRep()->~LargeRep();
if (AtLeast <= InlineBuckets) {
Small = true;
} else {
new (getLargeRep()) LargeRep(allocateBuckets(AtLeast));
}
this->moveFromOldBuckets(OldRep.Buckets, OldRep.Buckets+OldRep.NumBuckets);
// Free the old table.
deallocate_buffer(OldRep.Buckets, sizeof(BucketT) * OldRep.NumBuckets,
alignof(BucketT));
}
|
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 %ecx, %eax
shrl $0x10, %eax
orl %ecx, %eax
incl %eax
cmpl $0x41, %eax
movl $0x40, %ebp
cmovael %eax, %ebp
movl (%rbx), %eax
testb $0x1, %al
jne 0x1a2a076
movq 0x8(%rbx), %r14
movl 0x10(%rbx), %r15d
cmpl $0x4, %ebp
ja 0x1a2a107
orl $0x1, %eax
movl %eax, (%rbx)
jmp 0x1a2a11e
leaq 0x8(%rsp), %r14
movl $0x10, %r15d
movq -0x8(%rbx,%r15), %rax
movq %rax, %rcx
orq $0x1000, %rcx # imm = 0x1000
cmpq $-0x1000, %rcx # imm = 0xF000
je 0x1a2a0c3
movq %rax, (%r14)
movq $0x0, 0x8(%r14)
movq (%rbx,%r15), %rdi
callq 0x1b8d04d
movq %rax, 0x8(%r14)
addq $0x10, %r14
movq (%rbx,%r15), %rdi
testq %rdi, %rdi
je 0x1a2a0c3
callq 0x1b8cd9e
addq $0x10, %r15
cmpq $0x50, %r15
jne 0x1a2a081
cmpl $0x4, %ebp
jbe 0x1a2a0ec
andb $-0x2, (%rbx)
movl %ebp, %edi
shlq $0x4, %rdi
movl $0x8, %esi
callq 0x2b410ec
movq %rax, 0x8(%rbx)
movl %ebp, 0x10(%rbx)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1a2a14c
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, %edi
shlq $0x4, %rdi
movl $0x8, %esi
callq 0x2b410ec
movq %rax, 0x8(%rbx)
movl %ebp, 0x10(%rbx)
shlq $0x4, %r15
leaq (%r14,%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a2a14c
movl $0x8, %edx
movq %r14, %rdi
movq %r15, %rsi
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2b410f1
nop
|
/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::DenseMapInfo<std::pair<polly::ScopStmt*, polly::ScopStmt*>, void>, llvm::detail::DenseMapPair<std::pair<polly::ScopStmt*, polly::ScopStmt*>, isl::map>>::LookupBucketFor<std::pair<polly::ScopStmt*, polly::ScopStmt*>>(std::pair<polly::ScopStmt*, polly::ScopStmt*> const&, llvm::detail::DenseMapPair<std::pair<polly::ScopStmt*, polly::ScopStmt*>, isl::map> const*&) const
|
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 $-0x40a7b892e31b1a47, %rax # imm = 0xBF58476D1CE4E5B9
imulq %r8, %rax
movq %rax, %r8
shrq $0x1f, %r8
xorl %eax, %r8d
decl %ecx
andl %ecx, %r8d
movl $0x1, %r11d
xorl %r9d, %r9d
movq $-0x2000, %r10 # imm = 0xE000
movl %r8d, %ebx
leaq (%rbx,%rbx,2), %rbx
leaq (%rdi,%rbx,8), %rbx
movq (%rbx), %r15
movq 0x8(%rbx), %r14
cmpq %r15, (%rsi)
jne 0x1a2a38e
cmpq %r14, 0x8(%rsi)
jne 0x1a2a38e
movq %rbx, (%rdx)
movb $0x1, %al
xorl %ebx, %ebx
testb %bl, %bl
jne 0x1a2a364
jmp 0x1a2a3cd
cmpq $-0x1000, %r15 # imm = 0xF000
jne 0x1a2a3b0
cmpq $-0x1000, %r14 # imm = 0xF000
jne 0x1a2a3b0
testq %r9, %r9
cmovneq %r9, %rbx
movq %rbx, (%rdx)
xorl %ebx, %ebx
xorl %eax, %eax
jmp 0x1a2a388
xorq %r10, %r15
xorq %r10, %r14
orq %r15, %r14
orq %r9, %r14
cmoveq %rbx, %r9
addl %r11d, %r8d
incl %r11d
andl %ecx, %r8d
movb $0x1, %bl
jmp 0x1a2a388
popq %rbx
popq %r14
popq %r15
jmp 0x1a2a3dd
movq $0x0, (%rdx)
xorl %eax, %eax
andb $0x1, %al
retq
|
/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->moveFromOldBuckets(OldBuckets, OldBuckets+OldNumBuckets);
// Free the old table.
deallocate_buffer(OldBuckets, sizeof(BucketT) * OldNumBuckets,
alignof(BucketT));
}
|
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 %eax
cmpl $0x41, %eax
movl $0x40, %ecx
cmovael %eax, %ecx
movq (%rdi), %r14
movl %ecx, 0x10(%rdi)
shlq $0x3, %rcx
leaq (%rcx,%rcx,2), %rdi
movl $0x8, %esi
callq 0x2b410ec
movq %rax, (%rbx)
testq %r14, %r14
je 0x1a2a4e5
shlq $0x3, %r15
leaq (%r15,%r15,2), %r15
leaq (%r14,%r15), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a2a51a
movl $0x8, %edx
movq %r14, %rdi
movq %r15, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x2b410f1
movq $0x0, 0x8(%rbx)
movl 0x10(%rbx), %ecx
testq %rcx, %rcx
je 0x1a2a514
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rcx
movq $-0x1000, %rdx # imm = 0xF000
movq %rdx, (%rax)
movq %rdx, 0x8(%rax)
addq $0x18, %rax
cmpq %rcx, %rax
jne 0x1a2a504
popq %rbx
popq %r14
popq %r15
retq
|
/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), %rax
andl $0x1, (%rbx)
movl $0x0, 0x4(%rbx)
cmoveq 0x8(%rbx), %rax
movl $0x4, %ecx
cmovel 0x10(%rbx), %ecx
testl %ecx, %ecx
je 0x1a2dd00
movl %ecx, %ecx
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x1, %ecx
negq %rcx
addq %rdx, %rcx
addq $0x2, %rcx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
addq $0x10, %rax
xorl %edx, %edx
movdqa 0x1187397(%rip), %xmm1 # 0x2bb5020
movdqa 0x118739f(%rip), %xmm2 # 0x2bb5030
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movq %rdx, %xmm4
pshufd $0x44, %xmm4, %xmm4 # xmm4 = xmm4[0,1,0,1]
por %xmm1, %xmm4
pxor %xmm2, %xmm4
movdqa %xmm4, %xmm5
pcmpgtd %xmm0, %xmm5
pcmpeqd %xmm0, %xmm4
pshufd $0xf5, %xmm4, %xmm6 # xmm6 = xmm4[1,1,3,3]
pand %xmm5, %xmm6
pshufd $0xf5, %xmm5, %xmm4 # xmm4 = xmm5[1,1,3,3]
por %xmm6, %xmm4
movd %xmm4, %esi
notl %esi
testb $0x1, %sil
je 0x1a2dcdd
movq $-0x1000, -0x10(%rax) # imm = 0xF000
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %esi
testb $0x1, %sil
je 0x1a2dcf3
movq $-0x1000, (%rax) # imm = 0xF000
addq $0x2, %rdx
addq $0x20, %rax
cmpq %rdx, %rcx
jne 0x1a2dc99
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
|
/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::Value* const&, llvm::detail::DenseMapPair<llvm::Value*, isl::set> const*&) const
|
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
leaq (%rcx,%rbx), %r11
movq (%rcx,%rbx), %rbx
cmpq %rbx, (%rsi)
jne 0x1a2ddb0
movq %r11, (%rdx)
movb $0x1, %al
xorl %r11d, %r11d
testb %r11b, %r11b
jne 0x1a2dd8e
jmp 0x1a2dde6
cmpq $-0x1000, %rbx # imm = 0xF000
jne 0x1a2ddca
testq %r9, %r9
cmovneq %r9, %r11
movq %r11, (%rdx)
xorl %r11d, %r11d
xorl %eax, %eax
jmp 0x1a2dda9
xorq $-0x2000, %rbx # imm = 0xE000
orq %r9, %rbx
cmoveq %r11, %r9
addl %r10d, %edi
incl %r10d
andl %r8d, %edi
movb $0x1, %r11b
jmp 0x1a2dda9
popq %rbx
jmp 0x1a2ddf2
movq $0x0, (%rdx)
xorl %eax, %eax
andb $0x1, %al
retq
nop
|
/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.