name string | code string | asm string | file string |
|---|---|---|---|
llvm::InstrEmitter::AddOperand(llvm::MachineInstrBuilder&, llvm::SDValue, unsigned int, llvm::MCInstrDesc const*, llvm::DenseMap<llvm::SDValue, llvm::Register, llvm::DenseMapInfo<llvm::SDValue, void>, llvm::detail::DenseMapPair<llvm::SDValue, llvm::Register>>&, bool, bool, bool) | void InstrEmitter::AddOperand(MachineInstrBuilder &MIB,
SDValue Op,
unsigned IIOpNum,
const MCInstrDesc *II,
DenseMap<SDValue, Register> &VRBaseMap,
bool IsDebug, bool Is... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, %r14
movl %r8d, %ebp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
movb 0xa8(%rsp), %dil
movb 0xa0(%rsp), %sil
movb 0x98(%rsp), %dl
movq 0x90(%rsp), %rax
movl 0x18(%r12), %r8d
testl %r8d, %r8d
js 0x200a1ba
cmpl $0x23, %r8d
je... | /CodeGen/SelectionDAG/InstrEmitter.cpp |
GetMOForConstDbgOp(llvm::SDDbgOperand const&) | MachineOperand GetMOForConstDbgOp(const SDDbgOperand &Op) {
const Value *V = Op.getConst();
if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
if (CI->getBitWidth() > 64)
return MachineOperand::CreateCImm(CI);
return MachineOperand::CreateImm(CI->getSExtValue());
}
if (const ConstantFP *CF = ... | movq %rdi, %rax
movq 0x8(%rsi), %rcx
movzbl (%rcx), %edx
cmpl $0x14, %edx
je 0x200bbdd
cmpl $0x12, %edx
je 0x200bbc4
cmpl $0x11, %edx
jne 0x200bbf0
movl 0x20(%rcx), %edx
cmpl $0x41, %edx
jb 0x200bc08
movl $0xfff00000, %edx # imm = 0xFFF00000
andl (%rax), %edx
orl $0x2, %edx
jmp 0x200bbce
movl $0xfff00000, %edx ... | /CodeGen/SelectionDAG/InstrEmitter.cpp |
llvm::InstrEmitter::EmitMachineNode(llvm::SDNode*, bool, bool, llvm::DenseMap<llvm::SDValue, llvm::Register, llvm::DenseMapInfo<llvm::SDValue, void>, llvm::detail::DenseMapPair<llvm::SDValue, llvm::Register>>&) | void InstrEmitter::
EmitMachineNode(SDNode *Node, bool IsClone, bool IsCloned,
DenseMap<SDValue, Register> &VRBaseMap) {
unsigned Opc = Node->getMachineOpcode();
// Handle subreg insert/extract specially
if (Opc == TargetOpcode::EXTRACT_SUBREG ||
Opc == TargetOpcode::INSERT_SUBREG ||
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %r8, %r12
movl %ecx, %r9d
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x18(%rsi), %r8d
movl %r8d, %eax
notl %eax
leal -0x8(%rax), %ecx
cmpl $0xa, %ecx
ja 0x200bf92
leaq 0x2fe8a95(%rip), %rdx # 0x4ff49d0
movslq (%rdx,%rcx,... | /CodeGen/SelectionDAG/InstrEmitter.cpp |
llvm::InstrEmitter::EmitSpecialNode(llvm::SDNode*, bool, bool, llvm::DenseMap<llvm::SDValue, llvm::Register, llvm::DenseMapInfo<llvm::SDValue, void>, llvm::detail::DenseMapPair<llvm::SDValue, llvm::Register>>&) | void InstrEmitter::
EmitSpecialNode(SDNode *Node, bool IsClone, bool IsCloned,
DenseMap<SDValue, Register> &VRBaseMap) {
switch (Node->getOpcode()) {
default:
#ifndef NDEBUG
Node->dump();
#endif
llvm_unreachable("This target-independent node should have been selected!");
case ISD::EntryTok... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rsi, %r14
movq %rdi, %r12
movl 0x18(%rsi), %eax
cmpl $0x12b, %eax # imm = 0x12B
movq %rdi, 0x10(%rsp)
jg 0x200caae
movq %r8, %r9
cmpl $0x31, %eax
jle 0x200cbbb
leal -0x12a(%rax), %esi
movzbl %dl... | /CodeGen/SelectionDAG/InstrEmitter.cpp |
llvm::DAGTypeLegalizer::SoftenFloatRes_BUILD_PAIR(llvm::SDNode*) | SDValue DAGTypeLegalizer::SoftenFloatRes_BUILD_PAIR(SDNode *N) {
// Convert the inputs to integers, and build a new pair out of them.
return DAG.getNode(ISD::BUILD_PAIR, SDLoc(N),
TLI.getTypeToTransformTo(*DAG.getContext(),
N->getValueType(0)),
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r12
movq %rdi, %r15
movq 0x8(%rdi), %rbx
movq 0x48(%rsi), %rsi
movq %rsi, 0x28(%rsp)
testq %rsi, %rsi
je 0x200e01f
leaq 0x28(%rsp), %rdi
movl $0x1, %edx
callq 0x1a648a8
movl 0x44(%r12), %eax
leaq 0x28(%rsp), %r14
movl %eax, 0... | /CodeGen/SelectionDAG/LegalizeFloatTypes.cpp |
llvm::DAGTypeLegalizer::PromoteFloatRes_BinOp(llvm::SDNode*) | SDValue DAGTypeLegalizer::PromoteFloatRes_BinOp(SDNode *N) {
EVT VT = N->getValueType(0);
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
SDValue Op0 = GetPromotedFloat(N->getOperand(0));
SDValue Op1 = GetPromotedFloat(N->getOperand(1));
return DAG.getNode(N->getOpcode(), SDLoc(N), NVT, Op0, Op1, N... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x30(%rsi), %rax
movq 0x8(%rax), %rcx
movq (%rdi), %rdi
movq 0x8(%r15), %rdx
movq 0x40(%rdx), %rsi
movq (%rdi), %r8
movl (%rax), %edx
callq *0x240(%r8)
movb %al, 0x23(%rsp)
movq %rdx, 0x30(%rsp)
movq ... | /CodeGen/SelectionDAG/LegalizeFloatTypes.cpp |
llvm::DAGTypeLegalizer::PromoteFloatRes_ExpOp(llvm::SDNode*) | SDValue DAGTypeLegalizer::PromoteFloatRes_ExpOp(SDNode *N) {
EVT VT = N->getValueType(0);
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
SDValue Op0 = GetPromotedFloat(N->getOperand(0));
SDValue Op1 = N->getOperand(1);
return DAG.getNode(N->getOpcode(), SDLoc(N), NVT, Op0, Op1);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x30(%rsi), %rax
movq 0x8(%rax), %rcx
movq (%rdi), %rdi
movq 0x8(%r15), %rdx
movq 0x40(%rdx), %rsi
movq (%rdi), %r8
movl (%rax), %edx
callq *0x240(%r8)
movb %al, 0x27(%rsp)
movq %rdx, 0x28(%rsp)
movq ... | /CodeGen/SelectionDAG/LegalizeFloatTypes.cpp |
llvm::DAGTypeLegalizer::PromoteFloatRes_STRICT_FP_ROUND(llvm::SDNode*) | SDValue DAGTypeLegalizer::PromoteFloatRes_STRICT_FP_ROUND(SDNode *N) {
SDLoc DL(N);
SDValue Chain = N->getOperand(0);
SDValue Op = N->getOperand(1);
EVT VT = N->getValueType(0);
EVT OpVT = Op->getValueType(0);
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
EVT IVT = EVT::getIn... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x48(%rsi), %rsi
movq %rsi, 0x38(%rsp)
testq %rsi, %rsi
je 0x2019464
leaq 0x38(%rsp), %rdi
movl $0x1, %edx
callq 0x1a648a8
movl 0x44(%rbx), %eax
movl %eax, 0x40(%rsp)
movq 0x28(%rbx), %rax
movups (%ra... | /CodeGen/SelectionDAG/LegalizeFloatTypes.cpp |
llvm::DAGTypeLegalizer::PromoteFloatRes_SELECT_CC(llvm::SDNode*) | SDValue DAGTypeLegalizer::PromoteFloatRes_SELECT_CC(SDNode *N) {
SDValue TrueVal = GetPromotedFloat(N->getOperand(2));
SDValue FalseVal = GetPromotedFloat(N->getOperand(3));
return DAG.getNode(ISD::SELECT_CC, SDLoc(N),
TrueVal.getNode()->getValueType(0), N->getOperand(0),
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x28(%rsi), %rax
movq 0x50(%rax), %rsi
movl 0x58(%rax), %edx
callq 0x2011db2
movq %rax, %r14
movl %edx, 0x5c(%rsp)
movq 0x28(%rbx), %rax
movq 0x78(%rax), %rsi
movl 0x80(%rax), %edx
movq %r15, %rdi
cal... | /CodeGen/SelectionDAG/LegalizeFloatTypes.cpp |
llvm::DAGTypeLegalizer::PromoteFloatRes_XINT_TO_FP(llvm::SDNode*) | SDValue DAGTypeLegalizer::PromoteFloatRes_XINT_TO_FP(SDNode *N) {
SDLoc DL(N);
EVT VT = N->getValueType(0);
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
SDValue NV = DAG.getNode(N->getOpcode(), DL, NVT, N->getOperand(0));
// Round the value to the desired precision (that of the source type).
r... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r13
movq %rdi, %r12
movq 0x48(%rsi), %rsi
movq %rsi, 0x28(%rsp)
testq %rsi, %rsi
je 0x2019e91
leaq 0x28(%rsp), %rdi
movl $0x1, %edx
callq 0x1a648a8
movl 0x44(%r13), %eax
leaq 0x28(%rsp), %rbx
movl %eax, 0x8(%rbx)
movq 0x30(%r... | /CodeGen/SelectionDAG/LegalizeFloatTypes.cpp |
llvm::DAGTypeLegalizer::SoftPromoteHalfRes_EXTRACT_VECTOR_ELT(llvm::SDNode*) | SDValue DAGTypeLegalizer::SoftPromoteHalfRes_EXTRACT_VECTOR_ELT(SDNode *N) {
SDValue NewOp = BitConvertVectorToIntegerVector(N->getOperand(0));
return DAG.getNode(ISD::EXTRACT_VECTOR_ELT, SDLoc(N),
NewOp.getValueType().getVectorElementType(), NewOp,
N->getOperand(1));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rsi), %rax
movq (%rax), %rsi
movl 0x8(%rax), %edx
callq 0x1fc3860
movq %rax, %r15
movl %edx, %ebp
movq 0x8(%r14), %r14
movq 0x48(%rbx), %rsi
movq %rsi, 0x28(%rsp)
testq %rsi, %rsi
je 0x201a413
leaq 0x28(%rsp), %rdi
m... | /CodeGen/SelectionDAG/LegalizeFloatTypes.cpp |
llvm::DAGTypeLegalizer::SoftPromoteHalfRes_ATOMIC_LOAD(llvm::SDNode*) | SDValue DAGTypeLegalizer::SoftPromoteHalfRes_ATOMIC_LOAD(SDNode *N) {
AtomicSDNode *AM = cast<AtomicSDNode>(N);
// Load the value as an integer value with the same number of bits.
SDValue NewL = DAG.getAtomic(
ISD::ATOMIC_LOAD, SDLoc(N), MVT::i16, DAG.getVTList(MVT::i16, MVT::Other),
{AM->getChain(),... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r15
movq 0x48(%rsi), %rsi
movq %rsi, 0x20(%rsp)
testq %rsi, %rsi
je 0x201ba29
leaq 0x20(%rsp), %rdi
movl $0x1, %edx
callq 0x1a648a8
movl 0x44(%rbx), %eax
leaq 0x20(%rsp), %r12
movl %eax, 0x8(%r12)
mo... | /CodeGen/SelectionDAG/LegalizeFloatTypes.cpp |
llvm::DAGTypeLegalizer::PromoteIntRes_CTTZ(llvm::SDNode*) | SDValue DAGTypeLegalizer::PromoteIntRes_CTTZ(SDNode *N) {
SDValue Op = GetPromotedInteger(N->getOperand(0));
EVT OVT = N->getValueType(0);
EVT NVT = Op.getValueType();
SDLoc dl(N);
// If the larger CTTZ isn't supported by the target, try to expand now.
// If we expand later we'll end up with more operation... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rsi), %rax
movq (%rax), %rsi
movl 0x8(%rax), %edx
callq 0x1ff0994
movq %rax, %r15
movl %edx, %ebp
movq 0x30(%rbx), %rax
movb (%rax), %cl
movq 0x8(%rax), %rax
movb %cl, ... | /CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp |
llvm::DAGTypeLegalizer::PromoteIntRes_SExtIntBinOp(llvm::SDNode*) | SDValue DAGTypeLegalizer::PromoteIntRes_SExtIntBinOp(SDNode *N) {
if (N->getNumOperands() == 2) {
// Sign extend the input.
SDValue LHS = SExtPromotedInteger(N->getOperand(0));
SDValue RHS = SExtPromotedInteger(N->getOperand(1));
return DAG.getNode(N->getOpcode(), SDLoc(N), LHS.getValueType(), LHS, RH... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpw $0x2, 0x40(%rsi)
movq 0x28(%rsi), %rax
jne 0x2020420
movq (%rax), %rsi
movl 0x8(%rax), %edx
movq %r14, %rdi
callq 0x20286d6
movq %rax, %r15
movl %edx, %ebp
movq 0x28(%rbx), %rax
movq 0x28(%rax), %rsi
... | /CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp |
llvm::DAGTypeLegalizer::PromoteIntRes_SIGN_EXTEND_INREG(llvm::SDNode*) | SDValue DAGTypeLegalizer::PromoteIntRes_SIGN_EXTEND_INREG(SDNode *N) {
SDValue Op = GetPromotedInteger(N->getOperand(0));
return DAG.getNode(ISD::SIGN_EXTEND_INREG, SDLoc(N),
Op.getValueType(), Op, N->getOperand(1));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rsi), %rax
movq (%rax), %rsi
movl 0x8(%rax), %edx
callq 0x1ff0994
movq %rax, %r15
movl %edx, %ebp
movq 0x8(%r14), %r14
movq 0x48(%rbx), %rsi
movq %rsi, 0x20(%rsp)
testq %rsi, %rsi
je 0x2020937
leaq 0x20(%r... | /CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp |
llvm::DAGTypeLegalizer::PromoteIntRes_TRUNCATE(llvm::SDNode*) | SDValue DAGTypeLegalizer::PromoteIntRes_TRUNCATE(SDNode *N) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
SDValue Res;
SDValue InOp = N->getOperand(0);
SDLoc dl(N);
switch (getTypeAction(InOp.getValueType())) {
default: llvm_unreachable("Unknown type action!");
case TargetL... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rax
movq 0x40(%rax), %rsi
movq 0x30(%r14), %rax
movq 0x8(%rax), %rcx
movq (%rdi), %r8
movl (%rax), %edx
callq *0x240(%r8)
movb %al, 0x48(%rsp)
m... | /CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp |
llvm::DAGTypeLegalizer::PromoteIntRes_GET_ROUNDING(llvm::SDNode*) | SDValue DAGTypeLegalizer::PromoteIntRes_GET_ROUNDING(SDNode *N) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
SDLoc dl(N);
SDValue Res =
DAG.getNode(N->getOpcode(), dl, {NVT, MVT::Other}, N->getOperand(0));
// Legalize the chain result - switch anything that used the old c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x8(%r14), %rax
movq 0x40(%rax), %rsi
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rcx
movq (%rdi), %r8
movl (%rax), %edx
callq *0x240(%r8)
movl %eax, %ebp
movq %rdx, %r12
movq 0x48(%rbx), %rsi
movq ... | /CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp |
llvm::DAGTypeLegalizer::PromoteIntRes_UADDSUBO_CARRY(llvm::SDNode*, unsigned int) | SDValue DAGTypeLegalizer::PromoteIntRes_UADDSUBO_CARRY(SDNode *N,
unsigned ResNo) {
if (ResNo == 1)
return PromoteIntRes_Overflow(N);
// We need to sign-extend the operands so the carry value computed by the
// wide operation will be equivalent to the ca... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
cmpl $0x1, %edx
jne 0x2024d7d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2028892
movq %rax, %r15
jmp 0x2024eba
movq 0x28(%rbx), %rax
movq (%rax), %rsi
movl 0x8(%rax), %edx
movq %r14, %rdi
callq 0x20286d6
movq... | /CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp |
llvm::DAGTypeLegalizer::PromoteIntRes_MULFIX(llvm::SDNode*) | SDValue DAGTypeLegalizer::PromoteIntRes_MULFIX(SDNode *N) {
// Can just promote the operands then continue with operation.
SDLoc dl(N);
SDValue Op1Promoted, Op2Promoted;
bool Signed =
N->getOpcode() == ISD::SMULFIX || N->getOpcode() == ISD::SMULFIXSAT;
bool Saturating =
N->getOpcode() == ISD::SMUL... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rsi, %r14
movq %rdi, %rbx
movq 0x48(%rsi), %rsi
movq %rsi, 0x58(%rsp)
testq %rsi, %rsi
je 0x202614a
leaq 0x58(%rsp), %rdi
movl $0x1, %edx
callq 0x1a648a8
movl 0x44(%r14), %eax
movl %eax, 0x60(%rsp)
movl 0x... | /CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp |
llvm::DAGTypeLegalizer::PromoteIntRes_DIVFIX(llvm::SDNode*) | SDValue DAGTypeLegalizer::PromoteIntRes_DIVFIX(SDNode *N) {
SDLoc dl(N);
SDValue Op1Promoted, Op2Promoted;
bool Signed = N->getOpcode() == ISD::SDIVFIX ||
N->getOpcode() == ISD::SDIVFIXSAT;
bool Saturating = N->getOpcode() == ISD::SDIVFIXSAT ||
N->getOpcode() == ISD::UDIVFIXS... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rsi, %r14
movq %rdi, %rbx
movq 0x48(%rsi), %rsi
movq %rsi, 0x48(%rsp)
testq %rsi, %rsi
je 0x202647e
leaq 0x48(%rsp), %rdi
movl $0x1, %edx
callq 0x1a648a8
movl 0x44(%r14), %eax
movl %eax, 0x50(%rsp)
movl 0x... | /CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp |
llvm::DAGTypeLegalizer::PromoteIntRes_FFREXP(llvm::SDNode*) | SDValue DAGTypeLegalizer::PromoteIntRes_FFREXP(SDNode *N) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(1));
EVT VT = N->getValueType(0);
SDLoc dl(N);
SDValue Res =
DAG.getNode(N->getOpcode(), dl, DAG.getVTList(VT, NVT), N->getOperand(0));
ReplaceValueWith(SDValue(N, 0), Res)... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x8(%r14), %rax
movq 0x40(%rax), %rsi
movq 0x30(%rbx), %rax
movq 0x18(%rax), %rcx
movq (%rdi), %r8
movl 0x10(%rax), %edx
callq *0x240(%r8)
movq %rdx, %r8
movq 0x30(%rbx), %rcx
movb (... | /CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp |
llvm::DAGTypeLegalizer::PromoteIntRes_XRINT(llvm::SDNode*) | SDValue DAGTypeLegalizer::PromoteIntRes_XRINT(SDNode *N) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
SDLoc dl(N);
return DAG.getNode(N->getOpcode(), dl, NVT, N->getOperand(0));
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x8(%r14), %rax
movq 0x40(%rax), %rsi
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rcx
movq (%rdi), %r8
movl (%rax), %edx
callq *0x240(%r8)
movl %eax, %ebp
movq %rdx, %r15
movq 0x48(%rbx), %rsi
movq ... | /CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp |
llvm::DAGTypeLegalizer::PromoteIntOp_MSCATTER(llvm::MaskedScatterSDNode*, unsigned int) | SDValue DAGTypeLegalizer::PromoteIntOp_MSCATTER(MaskedScatterSDNode *N,
unsigned OpNo) {
bool TruncateStore = N->isTruncatingStore();
SmallVector<SDValue, 5> NewOps(N->op_begin(), N->op_end());
if (OpNo == 2) {
// The Mask
EVT DataVT = N->getValue().getValu... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movzwl 0x1e(%rsi), %r15d
shrl $0xa, %r15d
andl $0x1, %r15d
movq 0x28(%rsi), %rsi
movzwl 0x40(%rbx), %eax
leaq (%rax,%rax,4), %rax
leaq (%rsi,%rax,8), %rdx
leaq 0x68(%rsp), %rcx
movq %rcx, -... | /CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp |
llvm::DAGTypeLegalizer::PromoteIntOp_INSERT_SUBVECTOR(llvm::SDNode*) | SDValue DAGTypeLegalizer::PromoteIntOp_INSERT_SUBVECTOR(SDNode *N) {
SDLoc dl(N);
// The result type is equal to the first input operand's type, so the
// type that needs promoting must be the second source vector.
SDValue V0 = N->getOperand(0);
SDValue V1 = GetPromotedInteger(N->getOperand(1));
SDValue Idx... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x48(%rsi), %rsi
movq %rsi, 0x40(%rsp)
testq %rsi, %rsi
je 0x202b820
leaq 0x40(%rsp), %rdi
movl $0x1, %edx
callq 0x1a648a8
movl 0x44(%rbx), %eax
movl %eax, 0x48(%rsp)
movq 0x28(%rbx), %rax
movq (%rax)... | /CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp |
llvm::DAGTypeLegalizer::ExpandIntRes_ADDSUBE(llvm::SDNode*, llvm::SDValue&, llvm::SDValue&) | void DAGTypeLegalizer::ExpandIntRes_ADDSUBE(SDNode *N,
SDValue &Lo, SDValue &Hi) {
// Expand the subcomponents.
SDValue LHSL, LHSH, RHSL, RHSH;
SDLoc dl(N);
GetExpandedInteger(N->getOperand(0), LHSL, LHSH);
GetExpandedInteger(N->getOperand(1), RHSL, RHSH);
SDVTLis... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rcx, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
movq %rax, 0x80(%rsp)
movl %eax, 0x88(%rsp)
movq %rax, 0x40(%rsp)
movl %eax, 0x48(%rsp)
movq %rax, 0x70(%rsp)
movl %eax, 0x78(%rsp)
movq %rax, 0x... | /CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp |
llvm::DAGTypeLegalizer::ExpandIntRes_UADDSUBO_CARRY(llvm::SDNode*, llvm::SDValue&, llvm::SDValue&) | void DAGTypeLegalizer::ExpandIntRes_UADDSUBO_CARRY(SDNode *N, SDValue &Lo,
SDValue &Hi) {
// Expand the subcomponents.
SDValue LHSL, LHSH, RHSL, RHSH;
SDLoc dl(N);
GetExpandedInteger(N->getOperand(0), LHSL, LHSH);
GetExpandedInteger(N->getOperand(1), RHSL, RH... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rcx, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
movq %rax, 0x80(%rsp)
movl %eax, 0x88(%rsp)
movq %rax, 0x40(%rsp)
movl %eax, 0x48(%rsp)
movq %rax, 0x70(%rsp)
movl %eax, 0x78(%rsp)
movq %rax, 0x... | /CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp |
llvm::DAGTypeLegalizer::ExpandIntRes_MULFIX(llvm::SDNode*, llvm::SDValue&, llvm::SDValue&) | void DAGTypeLegalizer::ExpandIntRes_MULFIX(SDNode *N, SDValue &Lo,
SDValue &Hi) {
SDLoc dl(N);
EVT VT = N->getValueType(0);
unsigned VTSize = VT.getScalarSizeInBits();
SDValue LHS = N->getOperand(0);
SDValue RHS = N->getOperand(1);
uint64_t Scale = N->getConstantOp... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x778, %rsp # imm = 0x778
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbp
movq 0x48(%rsi), %rsi
movq %rsi, 0xb0(%rsp)
testq %rsi, %rsi
je 0x20366d4
leaq 0xb0(%rsp), %rdi
movl $0x1, %edx
callq 0x1a648a8
movl 0x44(%r15), %e... | /CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp |
llvm::DAGTypeLegalizer::ExpandIntRes_VSCALE(llvm::SDNode*, llvm::SDValue&, llvm::SDValue&) | void DAGTypeLegalizer::ExpandIntRes_VSCALE(SDNode *N, SDValue &Lo,
SDValue &Hi) {
EVT VT = N->getValueType(0);
EVT HalfVT =
EVT::getIntegerVT(*DAG.getContext(), N->getValueSizeInBits(0) / 2);
SDLoc dl(N);
// We assume VSCALE(1) fits into a legal integer.
APInt... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rcx, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movq %rsi, %r13
movq %rdi, %r15
movq 0x30(%rsi), %rax
movb (%rax), %cl
movb %cl, 0x2f(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x70(%rsp)
movq 0x8(%rdi), %rax
movq 0x40(%rax), %rbx
movq %rsi, %rdi... | /CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp |
llvm::DAGTypeLegalizer::ExpandIntegerOperand(llvm::SDNode*, unsigned int) | bool DAGTypeLegalizer::ExpandIntegerOperand(SDNode *N, unsigned OpNo) {
LLVM_DEBUG(dbgs() << "Expand integer operand: "; N->dump(&DAG));
SDValue Res = SDValue();
if (CustomLowerNode(N, N->getOperand(OpNo).getValueType(), false))
return false;
switch (N->getOpcode()) {
default:
#ifndef NDEBUG
dbgs(... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rsi), %rax
movl %edx, %ecx
leaq (%rcx,%rcx,4), %rcx
movq (%rax,%rcx,8), %rdx
movl 0x8(%rax,%rcx,8), %eax
movq 0x30(%rdx), %rdx
shlq $0x4, %rax
movq 0x8(%rdx,%rax), %rcx
movl (%rdx,%rax), %edx
xorl %r15d, %r... | /CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp |
llvm::DAGTypeLegalizer::ExpandIntOp_SETCCCARRY(llvm::SDNode*) | SDValue DAGTypeLegalizer::ExpandIntOp_SETCCCARRY(SDNode *N) {
SDValue LHS = N->getOperand(0);
SDValue RHS = N->getOperand(1);
SDValue Carry = N->getOperand(2);
SDValue Cond = N->getOperand(3);
SDLoc dl = SDLoc(N);
SDValue LHSLo, LHSHi, RHSLo, RHSHi;
GetExpandedInteger(LHS, LHSLo, LHSHi);
GetExpandedInt... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rsi), %rax
movq (%rax), %rdx
movl 0x8(%rax), %r13d
movq 0x28(%rax), %rcx
movq %rcx, 0x60(%rsp)
movl 0x30(%rax), %ecx
movl %ecx, 0x4c(%rsp)
movq 0x50(%rax), %rcx
movq %rcx, 0x68(%rsp)
movsd 0x58(... | /CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp |
llvm::DAGTypeLegalizer::ExpandIntOp_PATCHPOINT(llvm::SDNode*, unsigned int) | SDValue DAGTypeLegalizer::ExpandIntOp_PATCHPOINT(SDNode *N, unsigned OpNo) {
assert(OpNo >= 7);
SDValue Op = N->getOperand(OpNo);
// FIXME: Non-constant operands are not yet handled:
// - https://github.com/llvm/llvm-project/issues/26431
// - https://github.com/llvm/llvm-project/issues/55957
ConstantSDNo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %rbx
movq 0x28(%rsi), %rcx
movl %edx, %eax
leaq (%rax,%rax,4), %r8
movq (%rcx,%r8,8), %r13
movl 0x18(%r13), %esi
cmpl $0x23, %esi
je 0x203de04
cmpl $0xb, %esi
jne 0x203de09
movq %r13, %rsi
jmp 0x203de0b
xorl %esi, %esi
testq %... | /CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp |
llvm::DAGTypeLegalizer::IntegerExpandSetCCOperands(llvm::SDValue&, llvm::SDValue&, llvm::ISD::CondCode&, llvm::SDLoc const&) | void DAGTypeLegalizer::IntegerExpandSetCCOperands(SDValue &NewLHS,
SDValue &NewRHS,
ISD::CondCode &CCCode,
const SDLoc &dl) {
SDValue LHSLo, LHSHi, RHSLo, RHSHi;
GetE... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp # imm = 0x1B8
movq %r8, 0x78(%rsp)
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %rdx
movq %rdi, %r12
xorl %eax, %eax
leaq 0x48(%rsp), %rcx
movq %rax, (%rcx)
movl %eax, 0x8(%rcx)
leaq 0x58(%rsp), %r8
movq %rax, (%r8)
movl %eax, ... | /CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp |
llvm::DAGTypeLegalizer::ExpandRes_EXTRACT_VECTOR_ELT(llvm::SDNode*, llvm::SDValue&, llvm::SDValue&) | void DAGTypeLegalizer::ExpandRes_EXTRACT_VECTOR_ELT(SDNode *N, SDValue &Lo,
SDValue &Hi) {
SDValue OldVec = N->getOperand(0);
ElementCount OldEltCount = OldVec.getValueType().getVectorElementCount();
EVT OldEltVT = OldVec.getValueType().getVectorElementType();
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq %rcx, 0x90(%rsp)
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, 0x88(%rsp)
movq 0x28(%rsi), %rax
movq (%rax), %r13
movl 0x8(%rax), %r15d
movl 0xc(%rax), %eax
movl %eax, 0x2c(%rsp)
movq 0x30(%r13), %rax
movq %r1... | /CodeGen/SelectionDAG/LegalizeTypesGeneric.cpp |
llvm::DAGTypeLegalizer::SplitRes_Select(llvm::SDNode*, llvm::SDValue&, llvm::SDValue&) | void DAGTypeLegalizer::SplitRes_Select(SDNode *N, SDValue &Lo, SDValue &Hi) {
SDValue LL, LH, RL, RH, CL, CH;
SDLoc dl(N);
unsigned Opcode = N->getOpcode();
GetSplitOp(N->getOperand(1), LL, LH);
GetSplitOp(N->getOperand(2), RL, RH);
SDValue Cond = N->getOperand(0);
CL = CH = Cond;
if (Cond.getValueType... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x138, %rsp # imm = 0x138
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
xorl %eax, %eax
movq %rax, 0x98(%rsp)
movl %eax, 0xa0(%rsp)
movq %rax, 0x88(%rsp)
movl %eax, 0x90(%rsp)
movq %rax, 0xc8(%rsp)
movl %eax, 0xd0(%rsp)... | /CodeGen/SelectionDAG/LegalizeTypesGeneric.cpp |
llvm::ResourcePriorityQueue::scheduledNode(llvm::SUnit*) | void ResourcePriorityQueue::scheduledNode(SUnit *SU) {
// Use NULL entry as an event marker to reset
// the DFA state.
if (!SU) {
ResourcesModel->clearResources();
Packet.clear();
return;
}
const SDNode *ScegN = SU->getNode();
// Update reg pressure tracking.
// First update current node.
i... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x2042e32
movq %rsi, %r14
movq (%rsi), %r12
cmpl $0x0, 0x18(%r12)
jns 0x2042dbb
movzwl 0x42(%r12), %r13d
testq %r13, %r13
je 0x2042cc1
shll $0x4, %r13d
xorl %ebp, %ebp
movq 0x30(%r12), %rax
movzbl (%rax,%rbp... | /CodeGen/SelectionDAG/ResourcePriorityQueue.cpp |
llvm::ResourcePriorityQueue::remove(llvm::SUnit*) | void ResourcePriorityQueue::remove(SUnit *SU) {
assert(!Queue.empty() && "Queue is empty!");
std::vector<SUnit *>::iterator I = find(Queue, SU);
if (I != std::prev(Queue.end()))
std::swap(*I, Queue.back());
Queue.pop_back();
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
movq %rsi, (%rdx)
movq 0x30(%rdi), %rdi
movq 0x38(%rbx), %rsi
callq 0xba31b0
movq 0x38(%rbx), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x204306a
movq (%rax), %rdx
movq (%rcx), %rsi
movq %rsi, (%rax)
movq %rdx, (%rcx)
addq $-0x8, 0x38(%rbx)
addq $0x10, %rs... | /CodeGen/SelectionDAG/ResourcePriorityQueue.cpp |
llvm::detail::DenseMapPair<polly::ScopStmt*, isl::map>* llvm::DenseMapBase<llvm::DenseMap<polly::ScopStmt*, isl::map, llvm::DenseMapInfo<polly::ScopStmt*, void>, llvm::detail::DenseMapPair<polly::ScopStmt*, isl::map>>, polly::ScopStmt*, isl::map, llvm::DenseMapInfo<polly::ScopStmt*, void>, llvm::detail::DenseMapPair<po... | BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
BucketT *TheBucket) {
incrementEpoch();
// If the load of the hash table is more than 3/4, or if fewer than 1/8 of
// the buckets are empty (meaning that many are filled with tombstones),
// grow th... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rax
movq %rdx, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %ecx
movl 0x10(%rdi), %esi
leal 0x4(,%rcx,4), %edx
leal (%rsi,%rsi,2), %edi
cmpl %edi, %edx
jae 0x204867b
notl %ecx
addl %esi, %ecx
subl 0xc(%rbx), %ecx
movl %esi, %edx
shrl $0x3, %edx
cmpl %edx, %ecx
jbe 0... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::JSONImporterPrinterLegacyPass::runOnScop(polly::Scop&) | bool runOnScop(Scop &S) override {
JSONImporter &P = getAnalysis<JSONImporter>();
OS << "Printing analysis '" << P.getPassName() << "' for region: '"
<< S.getRegion().getNameStr() << "' in function '"
<< S.getFunction().getName() << "':\n";
P.printScop(OS, S);
return false;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rax
xorl %edi, %edi
leaq 0x389e904(%rip), %rcx # 0x58e772d
leaq 0x10(%rdx), %rsi
cmpq %rcx, (%rdx)
jne 0x2048e36
movq 0x8(%rdx), %rdi
je 0x2048e40
movq %rsi, ... | /Exchange/JSONExporter.cpp |
polly::buildEarlyPollyPipeline(llvm::PassManager<llvm::Module, llvm::AnalysisManager<llvm::Module>>&, llvm::OptimizationLevel) | static void buildEarlyPollyPipeline(llvm::ModulePassManager &MPM,
llvm::OptimizationLevel Level) {
bool EnableForOpt =
shouldEnablePollyForOptimization() && Level.isOptimizingForSpeed();
if (!shouldEnablePollyForDiagnostic() && !EnableForOpt)
return;
FunctionPassMana... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
cmpb $0x1, 0x389c222(%rip) # 0x58e7810
jne 0x204b605
movq %rbx, %rax
shrq $0x20, %rax
sete %al
testl %ebx, %ebx
setne %bpl
andb %al, %bpl
jmp 0x204b607
xorl %ebp, %ebp
callq 0x2050660
orb %bpl, %al
... | /Support/RegisterPasses.cpp |
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 0x204c49a
subq $0x18, %rsp
leaq 0x98(%rsi), %rdi
movl 0x80(%rsi), %eax
leaq 0x88(%rsi), %rcx
leaq 0x380966b(%rip), %r9 # 0x5855ae8
addq $0x10, %r9
leaq 0x8(%rsp), %rdx
movq %r9, (%rdx)
movb $0x1, 0xc(%rdx)
movl %eax, 0x8(%rdx)
callq 0x1c965da
addq $0x18, %rsp
retq
c... | /llvm/Support/CommandLine.h |
bool llvm::parseAnalysisUtilityPasses<polly::ScopAnalysis, llvm::Function, llvm::AnalysisManager<llvm::Function>>(llvm::StringRef, llvm::StringRef, llvm::PassManager<llvm::Function, llvm::AnalysisManager<llvm::Function>>&) | [[nodiscard]] bool ends_with(StringRef Suffix) const {
return Length >= Suffix.Length &&
compareMemory(end() - Suffix.Length, Suffix.Data, Suffix.Length) ==
0;
} | testq %rcx, %rcx
je 0x204cb1e
cmpb $0x3e, -0x1(%rdx,%rcx)
jne 0x204cb1e
pushq %rbx
subq $0x10, %rsp
movq %r8, %rbx
movq %rdi, %rax
cmpq $0xb, %rcx
jb 0x204cab8
movabsq $0x6164696c61766e69, %rdi # imm = 0x6164696C61766E69
xorq (%rdx), %rdi
movabsq $0x3c65746164696c61, %r8 # imm = 0x3C65746164696C61
xorq 0x3(%rdx), %r8
o... | /llvm/ADT/StringRef.h |
llvm::GraphWriter<polly::ScopDetection*>::writeNodes() | void writeNodes() {
// Loop over the graph, printing it out...
for (const auto Node : nodes<GraphType>(G))
if (!isNodeHidden(Node))
writeNode(Node);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1e0, %rsp # imm = 0x1E0
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
leaq 0xf0(%rsp), %r15
movq %r15, %rdi
callq 0x204e9ac
leaq 0x20(%rsp), %rsi
movq %rsp, %r14
movq %r14, %rdi
movq %r15, %rdx
callq 0x1cb9ff4
leaq 0x60(%rsp), %rdi
leaq 0x150(%rsp), %rsi
callq 0x204f68a
leaq 0... | /llvm/Support/GraphWriter.h |
void llvm::printGraphForFunction<polly::ScopDetection*>(llvm::Function&, polly::ScopDetection*, llvm::StringRef, bool) | void printGraphForFunction(Function &F, GraphT Graph, StringRef Name,
bool IsSimple) {
std::string Filename = Name.str() + "." + F.getName().str();
shortenFileName(Filename);
Filename = Filename + ".dot";
std::error_code EC;
errs() << "Writing '" << Filename << "'...";
raw_fd_os... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movl %r8d, 0x4(%rsp)
movq %rdi, %r14
movq %rsi, 0x78(%rsp)
leaq 0x60(%rsp), %r15
movq %r15, -0x10(%r15)
testq %rdx, %rdx
je 0x204ff2a
addq %rdx, %rcx
leaq 0x50(%rsp), %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0... | /llvm/Analysis/DOTGraphTraitsPass.h |
std::enable_if<!std::is_same_v<polly::JSONImportPass, 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::ScopStandardAnalys... | LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v<PassT, PassManager>>
addPass(PassT &&Pass) {
using PassModelT =
detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>;
// Do not use make_unique or emplace_back, they cause too many template
// instantiations, causing terrible co... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x751940
leaq 0x3805274(%rip), %rcx # 0x5856130
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rsp, %r14
movq %rax, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2052238
movq (%r14), %rdi
testq %rdi, %rdi
je 0x2050ee2
movq (%rdi), %rax
callq *0x8... | /llvm/IR/PassManager.h |
std::enable_if<!std::is_same_v<polly::DeadCodeElimPass, 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::ScopStandardAnal... | LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v<PassT, PassManager>>
addPass(PassT &&Pass) {
using PassModelT =
detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>;
// Do not use make_unique or emplace_back, they cause too many template
// instantiations, causing terrible co... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x10
popq %rdi
callq 0x751940
leaq 0x3805270(%rip), %rcx # 0x5856170
addq $0x10, %rcx
movq %rcx, (%rax)
movq %rsp, %r14
movq %rax, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2052238
movq (%r14), %rdi
testq %rdi, %rdi
je 0x2050f26
movq (%rdi), %rax
callq *0x8... | /llvm/IR/PassManager.h |
polly::FunctionToScopPassAdaptor<llvm::PassManager<polly::Scop, llvm::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>, polly::ScopStandardAnalysisResults&, polly::SPMUpdater&>>::run(llvm::Function&, llvm::AnalysisManager<llvm::Function>&) | PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM) {
ScopDetection &SD = AM.getResult<ScopAnalysis>(F);
ScopInfo &SI = AM.getResult<ScopInfoAnalysis>(F);
if (SI.empty()) {
// With no scops having been detected, no IR changes have been made and
// therefore all analyses are preserved... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp # imm = 0x148
movq %rcx, %rbp
movq %rdx, %r14
movq %rsi, 0x18(%rsp)
movq %rdi, %r13
leaq 0x389bd8a(%rip), %rsi # 0x58ecf00
movq %rcx, %rdi
callq 0x1a7f6e0
movq %rax, 0x8(%rsp)
leaq 0x389c4fe(%rip), %rsi # 0x58ed688
movq %... | /polly/ScopPass.h |
llvm::SmallDenseMap<llvm::Region*, long, 4u, llvm::DenseMapInfo<llvm::Region*, void>, llvm::detail::DenseMapPair<llvm::Region*, long>>::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 0x205188a
movl %esi, %ebp
andl $-0x2, %eax
movl %eax, (%rbx)
movl %esi, %edi
shlq $0x4, %rdi
movl $0x8, %esi
callq 0x1cac6bd
movq %rax, 0x8(%rbx)
movl %ebp, 0x10(%rbx)
leaq 0x8(%rbx), %... | /llvm/ADT/DenseMap.h |
void llvm::cl::apply<llvm::cl::opt<polly::PassPositionChoice, false, llvm::cl::parser<polly::PassPositionChoice>>, char [15], llvm::cl::desc, llvm::cl::ValuesClass, llvm::cl::OptionHidden, llvm::cl::initializer<polly::PassPositionChoice>, llvm::cl::cat>(llvm::cl::opt<polly::PassPositionChoice, false, llvm::cl::parser<p... | void apply(Opt *O, const Mod &M, const Mods &... Ms) {
applicator<Mod>::opt(M, *O);
apply(O, Ms...);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movq 0x40(%rsp), %rbx
movq %rsi, %rdi
callq 0x7512e0
movq %rbp, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x1c90c20
movups (%r12), %xmm0
movups %x... | /llvm/Support/CommandLine.h |
llvm::cl::parser<polly::PassPositionChoice>::OptionInfo const* llvm::SmallVectorTemplateCommon<llvm::cl::parser<polly::PassPositionChoice>::OptionInfo, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<llvm::cl::parser<polly::PassPositionChoice>::OptionInfo, false>>(llvm::SmallVectorTemplateBase<llv... | static const T *reserveForParamAndGetAddressImpl(U *This, const T &Elt,
size_t N) {
size_t NewSize = This->size() + N;
if (LLVM_LIKELY(NewSize <= This->capacity()))
return &Elt;
bool ReferencesStorage = false;
int64_t Index = -1;
if (!U::Take... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x8(%rdi), %ecx
movl 0xc(%rdi), %eax
addq %rcx, %rdx
cmpq %rax, %rdx
ja 0x20532ae
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
movq (%rdi), %rax
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
addq %rax,... | /llvm/ADT/SmallVector.h |
void llvm::cl::apply<llvm::cl::opt<bool, false, llvm::cl::parser<bool>>, llvm::cl::desc, llvm::cl::OptionHidden, llvm::cl::initializer<bool>, llvm::cl::cat>(llvm::cl::opt<bool, false, llvm::cl::parser<bool>>*, llvm::cl::desc const&, llvm::cl::OptionHidden const&, llvm::cl::initializer<bool> const&, llvm::cl::cat const&... | void apply(Option &O) const { O.setDescription(Desc); } | 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), %rax
movb (%rax), %cl
movb %cl, 0x80(%rdi)
movb $0x1, 0x91(%rdi)
movb (%rax), %al
movb %al, 0x90(%rdi)
movq (%r8), %rsi
jmp 0x1c90cb2
| /llvm/Support/CommandLine.h |
llvm::detail::AnalysisPassModel<llvm::Function, polly::OwningInnerAnalysisManagerProxy<llvm::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>, llvm::Function>, llvm::AnalysisManager<llvm::Function>::Invalidator>::AnalysisPassModel(polly::OwningInnerAnalysisManagerProxy<llvm::AnalysisManager<polly::Scop... | explicit AnalysisPassModel(PassT Pass) : Pass(std::move(Pass)) {} | leaq 0x3800eb1(%rip), %rax # 0x5856580
addq $0x10, %rax
movq %rax, (%rdi)
movq (%rsi), %rax
movq %rax, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
xorl %eax, %eax
movl %eax, 0x20(%rdi)
movq 0x8(%rsi), %rcx
movq %rcx, 0x10(%rdi)
movq %rax, 0x8(%rsi)
movl 0x10(%rsi), %ecx
movl %ecx, 0x18(%rdi)
movl %eax, 0x10... | /llvm/IR/PassManagerInternal.h |
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::Sc... | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBu... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl 0x10(%rdi), %ebx
movq (%rdi), %r14
leal -0x1(%rsi), %eax
movl %eax, %ecx
shrl %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x2, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x4, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x8, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x10,... | /llvm/ADT/DenseMap.h |
llvm::detail::AnalysisPassModel<polly::Scop, polly::DependenceAnalysis, llvm::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>::Invalidator, polly::ScopStandardAnalysisResults&>::run(polly::Scop&, llvm::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>&, polly::ScopStandardAnalysisResul... | std::unique_ptr<AnalysisResultConcept<IRUnitT, InvalidatorT>>
run(IRUnitT &IR, AnalysisManager<IRUnitT, ExtraArgTs...> &AM,
ExtraArgTs... ExtraArgs) override {
return std::make_unique<ResultModelT>(
Pass.run(IR, AM, std::forward<ExtraArgTs>(ExtraArgs)...));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
addq $0x8, %rsi
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x208cb9c
movl $0x28, %edi
callq 0x751940
movq %rax, %r14
movq (%r15), %rax
movq %rax, (%rsp)
movl $0x1, %ecx
movq 0x20(%rsp,%rcx,8), %rdx
movq %rdx, (%rsp,%rcx,8)
movq $0x0, 0x20(%rsp,%rcx,8)
i... | /llvm/IR/PassManagerInternal.h |
std::enable_if<!std::is_same_v<polly::MaximalStaticExpansionPrinterPass, llvm::PassManager<polly::Scop, llvm::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>, polly::ScopStandardAnalysisResults&, polly::SPMUpdater&>>, void>::type llvm::PassManager<polly::Scop, llvm::AnalysisManager<polly::Scop, polly:... | LLVM_ATTRIBUTE_MINSIZE std::enable_if_t<!std::is_same_v<PassT, PassManager>>
addPass(PassT &&Pass) {
using PassModelT =
detail::PassModel<IRUnitT, PassT, AnalysisManagerT, ExtraArgTs...>;
// Do not use make_unique or emplace_back, they cause too many template
// instantiations, causing terrible co... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x10
popq %rdi
callq 0x751940
movq (%rbx), %rcx
leaq 0x37ff312(%rip), %rdx # 0x5856898
addq $0x10, %rdx
movq %rdx, (%rax)
movq %rcx, 0x8(%rax)
movq %rsp, %rbx
movq %rax, (%rbx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2052238
movq (%rbx), %rdi
tes... | /llvm/IR/PassManager.h |
llvm::PreservedAnalyses llvm::InvalidateAnalysisPass<polly::IslAstAnalysis>::run<polly::Scop, llvm::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>, polly::ScopStandardAnalysisResults&, polly::SPMUpdater&>(polly::Scop&, llvm::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>&, polly::S... | PreservedAnalyses run(IRUnitT &Arg, AnalysisManagerT &AM, ExtraArgTs &&...) {
auto PA = PreservedAnalyses::all();
PA.abandon<AnalysisT>();
return PA;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x20(%rdi), %rax
movq %rax, (%rdi)
movq %rax, 0x8(%rdi)
movl $0x2, %eax
movq %rax, 0x10(%rdi)
xorl %ecx, %ecx
movl %ecx, 0x18(%rdi)
leaq 0x30(%rdi), %r14
leaq 0x50(%rdi), %rdx
movq %rdx, 0x30(%rdi)
movq %rdx, 0x38(%rdi)
movq %rax, 0x40(%rdi)
movl %e... | /llvm/IR/PassManager.h |
polly::DumpModulePass::run(llvm::Module&, llvm::AnalysisManager<llvm::Module>&) | llvm::PreservedAnalyses DumpModulePass::run(llvm::Module &M,
llvm::ModuleAnalysisManager &AM) {
runDumpModule(M, Filename, IsSuffix);
return PreservedAnalyses::all();
} | pushq %rbx
subq $0x20, %rsp
movq %rdx, %r8
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
movzbl 0x20(%rsi), %ecx
movq %r8, %rdi
movq %rax, %rsi
callq 0x205928a
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... | /Support/DumpModulePass.cpp |
llvm::cl::opt<bool, false, llvm::cl::parser<bool>>::opt<char [18], llvm::cl::desc, llvm::cl::OptionHidden, llvm::cl::cat>(char const (&) [18], llvm::cl::desc const&, llvm::cl::OptionHidden const&, llvm::cl::cat 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 %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
xorl %ebp, %ebp
xorl %esi, %esi
xorl %edx, %edx
callq 0x7c77e2
movb %bpl, 0x80(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%r14)
movb %bpl, 0x91(%r14)
leaq 0x36892c... | /llvm/Support/CommandLine.h |
polly::registerCanonicalicationPasses(llvm::legacy::PassManagerBase&) | void polly::registerCanonicalicationPasses(llvm::legacy::PassManagerBase &PM) {
bool UseMemSSA = true;
PM.add(llvm::createPromoteMemoryToRegisterPass());
PM.add(llvm::createEarlyCSEPass(UseMemSSA));
PM.add(llvm::createInstructionCombiningPass());
PM.add(llvm::createCFGSimplificationPass());
PM.add(llvm::cre... | pushq %r15
pushq %r14
pushq %rbx
subq $0xe0, %rsp
movq %rdi, %rbx
callq 0x27eee51
movq (%rbx), %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x10(%rcx)
movl $0x1, %edi
callq 0x247d742
movq (%rbx), %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x10(%rcx)
callq 0x26bc328
movq (%rbx), %rcx
movq %rbx, %rdi
movq %rax, %rsi
call... | /Transform/Canonicalization.cpp |
polly::buildCanonicalicationPassesForNPM(llvm::PassManager<llvm::Module, llvm::AnalysisManager<llvm::Module>>&, llvm::OptimizationLevel) | FunctionPassManager
polly::buildCanonicalicationPassesForNPM(llvm::ModulePassManager &MPM,
llvm::OptimizationLevel Level) {
FunctionPassManager FPM;
bool UseMemSSA = true;
FPM.addPass(PromotePass());
FPM.addPass(EarlyCSEPass(UseMemSSA));
FPM.addPass(InstCombinePass())... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x9e8, %rsp # imm = 0x9E8
movq %rdx, %r14
movq %rsi, 0x58(%rsp)
movq %rdi, %rbx
movabsq $0x100000000, %r15 # imm = 0x100000000
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x110(%rsp), %r13
movq %r13, %rsi
call... | /Transform/Canonicalization.cpp |
polly::DeadCodeElimPass::run(polly::Scop&, llvm::AnalysisManager<polly::Scop, polly::ScopStandardAnalysisResults&>&, polly::ScopStandardAnalysisResults&, polly::SPMUpdater&) | llvm::PreservedAnalyses DeadCodeElimPass::run(Scop &S, ScopAnalysisManager &SAM,
ScopStandardAnalysisResults &SAR,
SPMUpdater &U) {
DependenceAnalysis::Result &DA = SAM.getResult<DependenceAnalysis>(S, SAR);
const Dependence... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r15
movq %rdi, %rbx
leaq 0x3890c49(%rip), %rsi # 0x58ebca0
movq %rcx, %rdi
movq %r8, %rcx
callq 0x204917e
movq %rax, %r14
addq $0x8, %r14
xorl %ebp, %ebp
movq %r14, %rdi
xorl %esi, %esi
callq 0x208cafe
movl 0x388e095(%rip), %esi # 0... | /Transform/DeadCodeElimination.cpp |
llvm::cl::opt<int, false, llvm::cl::parser<int>>::opt<char [28], llvm::cl::desc, llvm::cl::OptionHidden, llvm::cl::initializer<int>, llvm::cl::cat>(char const (&) [28], llvm::cl::desc const&, llvm::cl::OptionHidden const&, llvm::cl::initializer<int> const&, llvm::cl::cat 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 0x7c77e2
movl $0x0, 0x80(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%r14)
movb $0x0, 0x94(%r14)
leaq 0x3696dd1... | /llvm/Support/CommandLine.h |
llvm::cl::opt<bool, false, llvm::cl::parser<bool>>::opt<char [24], llvm::cl::desc, llvm::cl::OptionHidden, llvm::cl::cat>(char const (&) [24], llvm::cl::desc const&, llvm::cl::OptionHidden const&, llvm::cl::cat 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 %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
xorl %ebp, %ebp
xorl %esi, %esi
xorl %edx, %edx
callq 0x7c77e2
movb %bpl, 0x80(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%r14)
movb %bpl, 0x91(%r14)
leaq 0x36876d... | /llvm/Support/CommandLine.h |
llvm::cl::opt<bool, false, llvm::cl::parser<bool>>::opt<char [34], llvm::cl::desc, llvm::cl::initializer<bool>, llvm::cl::cat>(char const (&) [34], llvm::cl::desc const&, llvm::cl::initializer<bool> const&, llvm::cl::cat const&) | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
xorl %ebp, %ebp
xorl %esi, %esi
xorl %edx, %edx
callq 0x7c77e2
movb %bpl, 0x80(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%r14)
movb %bpl, 0x91(%r14)
leaq 0x3686c3... | /llvm/Support/CommandLine.h |
polly::createIslScheduleOptimizerWrapperPass() | Pass *polly::createIslScheduleOptimizerWrapperPass() {
return new IslScheduleOptimizerWrapperPass();
} | pushq %rax
movl $0x40, %edi
callq 0x751940
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
leaq 0x388dc78(%rip), %rdx # 0x58ea428
movq %rdx, 0x10(%rax)
movl $0x0, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0x37fa4d2(%rip), %rdx # 0x5856c98
movq %rdx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movq %rcx, 0x38(%rax)
popq %rc... | /Transform/ScheduleOptimizer.cpp |
isl::schedule_node_set isl::schedule_node::as<isl::schedule_node_set>() 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 0x205f0c1
callq 0x264dfd1
movl %eax, %ebp
movl $0x18, %edi
callq 0x751940
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x37f669c(%rip), %rcx # 0x5855718
addq $0x10, %rcx
movq %rcx, (... | /External/isl/include/isl/isl-noexceptions.h |
polly::ScheduleNodeRewriter<(anonymous namespace)::InsertSimdMarkers>::visitChildren(isl::schedule_node) | isl::schedule_node visitChildren(isl::schedule_node Node, Args... args) {
if (!Node.has_children())
return Node;
isl::schedule_node It = Node.first_child();
while (true) {
It = getDerived().visit(It, std::forward<Args>(args)...);
if (!It.has_next_sibling())
break;
It = It.ne... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, (%rsp)
movq (%rsi), %rdi
callq 0x264ecce
movl %eax, %ebx
leaq 0x18(%rsp), %r15
movq $0x0, (%r15)
movl $0x18, %edi
callq 0x751940
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x3... | /polly/ScheduleTreeTransform.h |
polly::ScheduleTreeVisitor<(anonymous namespace)::InsertSimdMarkers, isl::schedule_node>::visitMultiChild(isl::schedule_node) | RetTy visitMultiChild(isl::schedule_node Node, Args... args) {
return getDerived().visitNode(std::move(Node), std::forward<Args>(args)...);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq $0x0, (%r15)
movq (%rsi), %rdi
callq 0x264e118
movq %rax, %r14
movq %rax, (%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x205f45a
testq %r14, %r14
je 0x205f6e0
movq %r14, %rdi
callq 0x264ded3
movq %rbx, %rax
addq $0x10, %rsp
popq... | /polly/ScheduleTreeTransform.h |
polly::getIsolateOptions(isl::set, unsigned int) | isl::union_set polly::getIsolateOptions(isl::set IsolateDomain,
unsigned OutDimsNum) {
unsigned Dims = unsignedFromIslSize(IsolateDomain.tuple_dim());
assert(OutDimsNum <= Dims &&
"The isl::set IsolateDomain is used to describe the range of schedule "
"dimen... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x2605b5a
movl %eax, %r15d
leaq 0x8(%rsp), %r12
movq $0x0, (%r12)
movl $0x18, %edi
callq 0x751940
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(... | /Transform/ScheduleTreeTransform.cpp |
llvm::SmallVectorTemplateBase<isl::schedule_node, false>::moveElementsForGrow(isl::schedule_node*) | 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 0x20637c8
movq %rsi, %r14
movq (%rbx), %r12
shlq $0x3, %r15
xorl %r13d, %r13d
movq $0x0, (%r14,%r13)
movq (%r12,%r13), %rdi
callq 0x264e118
movq %rax, (%r14,%r13)
addq $0x8, %r13
cmpq %r13, %r15
jne 0x20637a... | /llvm/ADT/SmallVector.h |
(anonymous namespace)::ScheduleTreeRewriter<(anonymous namespace)::BandCollapseRewriter>::visitBand(isl::schedule_node_band) | isl::schedule visitBand(isl::schedule_node_band Band, Args... args) {
isl::schedule NewChild =
getDerived().visit(Band.child(0), std::forward<Args>(args)...);
return rebuildBand(Band, NewChild, [](int) { return true; });
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %r12
movq (%rsi), %rdi
callq 0x264e118
movq %rax, %rdi
xorl %esi, %esi
callq 0x264ee7b
movq %rax, %r15
leaq 0x70(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x30(%rsp), %rdi
callq 0x20637f8
testq %r15, %r15
je 0x2064700... | /Transform/ScheduleTreeTransform.cpp |
(anonymous namespace)::GreedyFusionRewriter::visitSequence(isl::schedule_node_sequence, isl::union_map) | isl::schedule visitSequence(isl::schedule_node_sequence Sequence,
isl::union_map Deps) {
int NumChildren = isl_schedule_node_n_children(Sequence.get());
// List of fusion candidates. The first element is the fusion candidate, the
// second is candidate's ancestor that is the s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp # imm = 0x298
movq %rcx, 0x150(%rsp)
movq %rsi, 0x160(%rsp)
movq %rdi, 0x128(%rsp)
movq %rdx, 0x168(%rsp)
movq (%rdx), %rdi
callq 0x264ecf1
leaq 0x240(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movabsq $0x300000000, %rcx # imm =... | /Transform/ScheduleTreeTransform.cpp |
polly::createForwardOpTreeWrapperPass() | Pass *polly::createForwardOpTreeWrapperPass() {
return new ForwardOpTreeWrapperPass();
} | pushq %rax
movl $0x30, %edi
callq 0x751940
movq $0x0, 0x8(%rax)
leaq 0x387de91(%rip), %rcx # 0x58ea680
movq %rcx, 0x10(%rax)
movl $0x0, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
leaq 0x37ea790(%rip), %rcx # 0x5856f98
movq %rcx, (%rax)
popq %rcx
retq
| /Transform/ForwardOpTree.cpp |
llvm::DenseMapBase<llvm::DenseMap<std::pair<llvm::Value*, polly::ScopStmt*>, (anonymous namespace)::ForwardingAction, llvm::DenseMapInfo<std::pair<llvm::Value*, polly::ScopStmt*>, void>, llvm::detail::DenseMapPair<std::pair<llvm::Value*, polly::ScopStmt*>, (anonymous namespace)::ForwardingAction>>, std::pair<llvm::Valu... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %eax
testq %rax, %rax
je 0x206cf17
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rdi), %rbx
movq %rax, %rcx
shlq $0x7, %rcx
leaq (%rcx,%rax,8), %r14
addq %rbx, %r14
addq $0x48, %rbx
movq $-0x1000, %r15 # imm = 0xF000
movl $0x88, %r12d
movq $-0x2000, %r13 # imm = 0xE000... | /llvm/ADT/DenseMap.h |
(anonymous namespace)::ForwardOpTreeImpl::forwardTree(polly::ScopStmt*, llvm::Value*, polly::ScopStmt*, llvm::Loop*) | ForwardingDecision forwardTree(ScopStmt *TargetStmt, Value *UseVal,
ScopStmt *UseStmt, Loop *UseLoop) {
// Lookup any cached evaluation.
auto It = ForwardingActions.find({UseVal, UseStmt});
if (It != ForwardingActions.end())
return It->second.Decision;
// Make a n... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2e8, %rsp # imm = 0x2E8
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %rbp
movq %rsi, %r12
movq %rdi, %r13
leaq 0x198(%rdi), %r15
leaq 0x1a0(%rsp), %rsi
movq %rdx, (%rsi)
movq %rcx, 0x8(%rsi)
leaq 0x118(%rsp), %rdx
movq %r15, %rdi
callq 0x... | /Transform/ForwardOpTree.cpp |
bool llvm::DenseMapBase<llvm::DenseMap<llvm::Value*, polly::MemoryAccess*, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, polly::MemoryAccess*>>, llvm::Value*, polly::MemoryAccess*, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, polly::MemoryAccess*>>:... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x2070e9f
pushq %rbx
movq (%rdi), %rdi
movl (%rsi), %r8d
movl %r8d, %eax
shrl $0x4, %eax
shrl $0x9, %r8d
xorl %eax, %r8d
decl %ecx
andl %ecx, %r8d
movl $0x1, %r10d
xorl %r9d, %r9d
movl %r8d, %ebx
shlq $0x4, %rbx
leaq (%rdi,%rbx), %r11
movq (%rdi,%rbx), %rbx
cmpq %rbx, (%rsi)
jn... | /llvm/ADT/DenseMap.h |
std::pair<(anonymous namespace)::ForwardingAction*, std::pair<llvm::Value*, polly::ScopStmt*>*>& llvm::SmallVectorTemplateBase<std::pair<(anonymous namespace)::ForwardingAction*, std::pair<llvm::Value*, polly::ScopStmt*>*>, true>::growAndEmplaceBack<(anonymous namespace)::ForwardingAction*&, std::pair<llvm::Value*, pol... | T &growAndEmplaceBack(ArgTypes &&... Args) {
// Use push_back with a copy in case Args has an internal reference,
// side-stepping reference invalidation problems without losing the realloc
// optimization.
push_back(T(std::forward<ArgTypes>(Args)...));
return this->back();
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %r14
movq (%rdx), %r15
movl 0x8(%rdi), %edx
cmpl 0xc(%rdi), %edx
jae 0x20711e1
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
shlq $0x4, %rcx
movq %r14, (%rax,%rcx)
movq %r15, 0x8(%rax,%rcx)
movl 0x8(%rbx), %eax
incl %eax
movl %eax, 0x8(%rbx)
movq (%rbx), %rcx
shlq ... | /llvm/ADT/SmallVector.h |
(anonymous namespace)::DeLICMPrinterLegacyPass::runOnScop(polly::Scop&) | bool runOnScop(Scop &S) override {
DeLICMWrapperPass &P = getAnalysis<DeLICMWrapperPass>();
OS << "Printing analysis '" << P.getPassName() << "' for region: '"
<< S.getRegion().getNameStr() << "' in function '"
<< S.getFunction().getName() << "':\n";
P.printScop(OS, S);
return false;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rax
xorl %edi, %edi
leaq 0x38739bb(%rip), %rcx # 0x58ea990
leaq 0x10(%rdx), %rsi
cmpq %rcx, (%rdx)
jne 0x2076fe2
movq 0x8(%rdx), %rdi
je 0x2076fec
movq %rsi, ... | /Transform/DeLICM.cpp |
polly::ZoneAlgorithm::addArrayWriteAccess(polly::MemoryAccess*) | void ZoneAlgorithm::addArrayWriteAccess(MemoryAccess *MA) {
assert(MA->isLatestArrayKind());
assert(MA->isWrite());
auto *Stmt = MA->getStatement();
// { Domain[] -> Element[] }
isl::map AccRel = intersectRange(getAccessRelationFor(MA), CompatibleElts);
if (MA->isMustWrite())
AllMustWrites = AllMustWr... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movq 0x18(%rsi), %r14
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x2078092
leaq 0x28(%rsp), %r13
movq $0x0, (%r13)
movq 0xa8(%rbx), %rdi
callq 0x26833e6
movq %rax, (%r13)
movq %rsp, %... | /Transform/ZoneAlgo.cpp |
polly::ZoneAlgorithm::computePerPHI(polly::ScopArrayInfo const*) | isl::union_map ZoneAlgorithm::computePerPHI(const ScopArrayInfo *SAI) {
// TODO: If the PHI has an incoming block from before the SCoP, it is not
// represented in any ScopStmt.
auto *PHI = cast<PHINode>(SAI->getBasePtr());
auto It = PerPHIMaps.find(PHI);
if (It != PerPHIMaps.end())
return It->second;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r12
movq %rsi, %rbp
movq %rdi, %r13
movq 0x40(%rdx), %r15
leaq 0x110(%rsi), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2079414
testb $0x1, 0x110(%rbp)
leaq 0x118(%rbp), %rcx
cmoveq 0x118(%rbp), %rcx
movl $0x4, %edx
cmovel 0... | /Transform/ZoneAlgo.cpp |
polly::ZoneAlgorithm::makeValueId(llvm::Value*) | isl::id ZoneAlgorithm::makeValueId(Value *V) {
if (!V)
return {};
auto &Id = ValueIds[V];
if (Id.is_null()) {
auto Name = getIslCompatibleName("Val_", V, ValueIds.size() - 1,
std::string(), UseInstructionNames);
Id = isl::id::alloc(IslCtx.get(), Name.c_str(), V);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq %rdx, (%rsp)
testq %rdx, %rdx
je 0x2079bab
movq %rsi, %r15
leaq 0x90(%rsi), %rdi
movq %rsp, %rsi
callq 0x207bef6
movq %rax, %r14
cmpq $0x0, 0x8(%rax)
jne 0x2079b99
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x... | /Transform/ZoneAlgo.cpp |
polly::ZoneAlgorithm::isCompatibleAccess(polly::MemoryAccess*) | bool ZoneAlgorithm::isCompatibleAccess(MemoryAccess *MA) {
if (!MA)
return false;
if (!MA->isLatestArrayKind())
return false;
Instruction *AccInst = MA->getAccessInstruction();
return isa<StoreInst>(AccInst) || isa<LoadInst>(AccInst);
} | testq %rsi, %rsi
je 0x2079fdc
pushq %rbx
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x20a297a
cmpl $0x0, 0xc0(%rax)
je 0x2079fdf
xorl %eax, %eax
jmp 0x2079fec
xorl %eax, %eax
retq
movq 0x68(%rbx), %rax
movb (%rax), %al
addb $-0x3d, %al
cmpb $0x2, %al
setb %al
popq %rbx
retq
| /Transform/ZoneAlgo.cpp |
llvm::DenseMap<llvm::PHINode*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::PHINode*, void>, llvm::detail::DenseSetPair<llvm::PHINode*>>::copyFrom(llvm::DenseMap<llvm::PHINode*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::PHINode*, void>, llvm::detail::DenseSetPair<llvm::PHINode*>> const&) | void copyFrom(const DenseMap& other) {
this->destroyAll();
deallocate_buffer(Buckets, sizeof(BucketT) * NumBuckets, alignof(BucketT));
if (allocateBuckets(other.NumBuckets)) {
this->BaseT::copyFrom(other);
} else {
NumEntries = 0;
NumTombstones = 0;
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
movl 0x10(%rbx), %esi
shlq $0x3, %rsi
movl $0x8, %edx
callq 0x1cac6c2
movl 0x10(%r14), %r15d
movl %r15d, 0x10(%rbx)
testq %r15, %r15
je 0x207b516
leaq (,%r15,8), %rdi
movl $0x8, %esi
callq 0x1cac6bd
jmp 0x207b518
xorl %eax, %eax
movq %ra... | /llvm/ADT/DenseMap.h |
llvm::DenseMap<std::pair<polly::ScopStmt*, polly::ScopStmt*>, isl::map, llvm::DenseMapInfo<std::pair<polly::ScopStmt*, polly::ScopStmt*>, void>, llvm::detail::DenseMapPair<std::pair<polly::ScopStmt*, polly::ScopStmt*>, isl::map>>::grow(unsigned int) | void grow(unsigned AtLeast) {
unsigned OldNumBuckets = NumBuckets;
BucketT *OldBuckets = Buckets;
allocateBuckets(std::max<unsigned>(64, static_cast<unsigned>(NextPowerOf2(AtLeast-1))));
assert(Buckets);
if (!OldBuckets) {
this->BaseT::initEmpty();
return;
}
this->moveFromOldBu... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x10(%rdi), %r15d
decl %esi
movl %esi, %eax
shrl %eax
orl %esi, %eax
movl %eax, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x4, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x8, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x10, %eax
orl %ecx, %eax
incl %ea... | /llvm/ADT/DenseMap.h |
llvm::detail::DenseMapPair<llvm::Value*, isl::set>* 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... | BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
BucketT *TheBucket) {
incrementEpoch();
// If the load of the hash table is more than 3/4, or if fewer than 1/8 of
// the buckets are empty (meaning that many are filled with tombstones),
// grow th... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rax
movq %rdx, %r14
movq %rdi, %rbx
movl (%rdi), %edx
movl %edx, %ecx
shrl %ecx
movl $0x4, %esi
testb $0x1, %dl
jne 0x207f329
movl 0x10(%rbx), %esi
leal 0x4(,%rcx,4), %edx
leal (%rsi,%rsi,2), %edi
cmpl %edi, %edx
jae 0x207f360
notl %ecx
addl %esi, %ecx
subl ... | /llvm/ADT/DenseMap.h |
llvm::SmallDenseMap<llvm::Value*, isl::set, 4u, llvm::DenseMapInfo<llvm::Value*, void>, llvm::detail::DenseMapPair<llvm::Value*, isl::set>>::grow(unsigned int) | void grow(unsigned AtLeast) {
if (AtLeast > InlineBuckets)
AtLeast = std::max<unsigned>(64, NextPowerOf2(AtLeast-1));
if (Small) {
// First move the inline buckets into a temporary storage.
AlignedCharArrayUnion<BucketT[InlineBuckets]> TmpStorage;
BucketT *TmpBegin = reinterpret_cast<Bu... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebp
movq %rdi, %rbx
cmpl $0x5, %esi
jb 0x207f3c7
decl %ebp
movl %ebp, %eax
shrl %eax
orl %ebp, %eax
movl %eax, %ecx
shrl $0x2, %ecx
orl %eax, %ecx
movl %ecx, %eax
shrl $0x4, %eax
orl %ecx, %eax
movl %eax, %ecx
shrl $0x8, %ecx
orl %eax, %ecx
movl %... | /llvm/ADT/DenseMap.h |
bool llvm::DenseMapBase<llvm::DenseMap<polly::VirtualInstruction, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<polly::VirtualInstruction, void>, llvm::detail::DenseSetPair<polly::VirtualInstruction>>, polly::VirtualInstruction, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<polly::VirtualInstruction, void>, llvm::d... | unsigned getNumBuckets() const {
return NumBuckets;
} | movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x207fa18
pushq %r15
pushq %r14
pushq %rbx
movq (%rdi), %rdi
movl (%rsi), %eax
movl 0x8(%rsi), %r8d
movl %eax, %r9d
shrl $0x4, %r9d
shrl $0x9, %eax
xorl %r9d, %eax
movl %r8d, %r9d
shrl $0x4, %r9d
shrl $0x9, %r8d
xorl %r9d, %r8d
shlq $0x20, %rax
orq %rax, %r8
movabsq $-0x40a7b89... | /llvm/ADT/DenseMap.h |
polly::createMaximalStaticExpansionPass() | Pass *polly::createMaximalStaticExpansionPass() {
return new MaximalStaticExpanderWrapperPass();
} | pushq %rax
movl $0x28, %edi
callq 0x751940
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
leaq 0x386a7df(%rip), %rdx # 0x58ea9a4
movq %rdx, 0x10(%rax)
movl $0x0, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0x37d723d(%rip), %rcx # 0x5857418
movq %rcx, (%rax)
popq %rcx
retq
| /Transform/MaximalStaticExpansion.cpp |
(anonymous namespace)::MaximalStaticExpansionImpl::mapAccess(llvm::SmallPtrSetImpl<polly::MemoryAccess*>&, isl::union_map const&, polly::ScopArrayInfo*, bool) | void mapAccess(SmallPtrSetImpl<MemoryAccess *> &Accesses,
const isl::union_map &Dependences, ScopArrayInfo *ExpandedSAI,
bool Reverse) {
for (auto MA : Accesses) {
// Get the current AM.
auto CurrentAccessMap = MA->getAccessRelation();
// Get RAW dependences for ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r8d, 0x24(%rsp)
movq %rcx, 0x50(%rsp)
movq %rdx, 0x28(%rsp)
movq %rdi, 0x58(%rsp)
movq 0x8(%rsi), %r14
xorl %eax, %eax
cmpq (%rsi), %r14
sete %al
movl 0x10(%rsi,%rax,4), %eax
leaq (%r14,%rax,8), %r13
testq %rax, %rax
je 0x2081c65
s... | /Transform/MaximalStaticExpansion.cpp |
llvm::cl::opt<int, false, llvm::cl::parser<int>>::opt<char [43], llvm::cl::desc, llvm::cl::OptionHidden, llvm::cl::initializer<int>, llvm::cl::cat>(char const (&) [43], llvm::cl::desc const&, llvm::cl::OptionHidden const&, llvm::cl::initializer<int> const&, llvm::cl::cat 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 0x7c77e2
movl $0x0, 0x80(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%r14)
movb $0x0, 0x94(%r14)
leaq 0x366eb5d... | /llvm/Support/CommandLine.h |
llvm::cl::opt<bool, false, llvm::cl::parser<bool>>::opt<char [23], llvm::cl::desc, llvm::cl::OptionHidden, llvm::cl::cat>(char const (&) [23], llvm::cl::desc const&, llvm::cl::OptionHidden const&, llvm::cl::cat 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 %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
xorl %ebp, %ebp
xorl %esi, %esi
xorl %edx, %edx
callq 0x7c77e2
movb %bpl, 0x80(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%r14)
movb %bpl, 0x91(%r14)
leaq 0x36587e... | /llvm/Support/CommandLine.h |
llvm::DenseMapBase<llvm::DenseMap<polly::ScopStmt*, isl::map, llvm::DenseMapInfo<polly::ScopStmt*, void>, llvm::detail::DenseMapPair<polly::ScopStmt*, isl::map>>, polly::ScopStmt*, isl::map, llvm::DenseMapInfo<polly::ScopStmt*, void>, llvm::detail::DenseMapPair<polly::ScopStmt*, isl::map>>::find(polly::ScopStmt 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(... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movq %rsp, %rdx
movq %rax, %rsi
callq 0x2048934
testb %al, %al
je 0x208c5f1
movq (%rsp), %rax
movl 0x10(%rbx), %edx
shlq $0x4, %rdx
addq (%rbx), %rdx
jmp 0x208c5fe
movl 0x10(%rbx), %eax
shlq $0x4, %rax
addq (%rbx), %rax
movq %rax, %rdx
a... | /llvm/ADT/DenseMap.h |
printDependencyMap(llvm::raw_ostream&, isl_union_map*) | static void printDependencyMap(raw_ostream &OS, __isl_keep isl_union_map *DM) {
if (DM)
OS << DM << "\n";
else
OS << "n/a\n";
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x208c8ab
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movl $0x6c6c756e, (%r15) # imm = 0x6C6C756E
movq $0x4, -0x8(%r15)
movb $0x0, 0x4(%r15)
leaq 0x20(%rsp), %r14
movq %rsp, %rdx
movq %r14, %rdi
callq 0x20d0a35
movq (%r14), %rsi
... | /Analysis/DependenceInfo.cpp |
polly::DependenceInfo::recomputeDependences(polly::Dependences::AnalysisLevel) | const Dependences &
DependenceInfo::recomputeDependences(Dependences::AnalysisLevel Level) {
D[Level].reset(new Dependences(S->getSharedIslCtx(), Level));
D[Level]->calculateDependences(*S);
return *D[Level];
} | pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movl $0x58, %edi
callq 0x751940
movq 0x28(%rbx), %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x2c(%rax)
movq (%rcx), %rdx
movq %rdx, 0x40(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x48(%rax)
tes... | /Analysis/DependenceInfo.cpp |
llvm::cl::opt<AnalysisType, false, llvm::cl::parser<AnalysisType>>::getValueExpectedFlagDefault() const | enum ValueExpected getValueExpectedFlagDefault() const {
// If there is an ArgStr specified, then we are of the form:
//
// -opt=O2 or -opt O2 or -optO2
//
// In which case, the value is required. Otherwise if an arg str has not
// been specified, we are of the form:
//
// -... | movq 0xa0(%rdi), %rcx
xorl %eax, %eax
cmpq $0x1, 0x18(%rcx)
adcl $0x2, %eax
retq
| /llvm/Support/CommandLine.h |
llvm::Pass* llvm::callDefaultCtor<(anonymous namespace)::DependenceInfoPrinterLegacyPass, true>() | Pass *callDefaultCtor() {
return new PassName();
} | pushq %rbx
movl $0x30, %edi
callq 0x751940
movq %rax, %rbx
callq 0x1ceb267
xorl %ecx, %ecx
movq %rcx, 0x8(%rbx)
leaq 0x385dcea(%rip), %rdx # 0x58ebcc0
movq %rdx, 0x10(%rbx)
movl $0x0, 0x18(%rbx)
movq %rcx, 0x20(%rbx)
leaq 0x37c98ec(%rip), %rcx # 0x58578d8
movq %rcx, (%rbx)
movq %rax, 0x28(%rbx)
movq %rbx, %rax
popq... | /llvm/PassSupport.h |
llvm::DenseMap<polly::Scop*, std::unique_ptr<polly::Dependences, std::default_delete<polly::Dependences>>, llvm::DenseMapInfo<polly::Scop*, void>, llvm::detail::DenseMapPair<polly::Scop*, std::unique_ptr<polly::Dependences, std::default_delete<polly::Dependences>>>>::init(unsigned int) | void init(unsigned InitNumEntries) {
auto InitBuckets = BaseT::getMinBucketToReserveForEntries(InitNumEntries);
if (allocateBuckets(InitBuckets)) {
this->BaseT::initEmpty();
} else {
NumEntries = 0;
NumTombstones = 0;
}
} | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
je 0x208e03a
shll $0x2, %esi
movl $0xaaaaaaab, %eax # imm = 0xAAAAAAAB
imulq %rsi, %rax
shrq $0x21, %rax
incl %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, %ec... | /llvm/ADT/DenseMap.h |
isl::noexceptions::isl_iterator<isl::set_list>::isl_iterator(isl::set_list const&) | explicit isl_iterator(const ListT &List)
: List(&List), Position(std::max(List.size().release(), 0)) {} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq %rsi, (%rdi)
movq (%rsi), %rdi
callq 0x2663d57
movl %eax, %ebp
movl $0x18, %edi
callq 0x751940
movabsq $0x100000001, %rcx # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x37c6aad(%rip), %rcx # 0x5855718
addq $0x10, %rcx
movq %rcx, (%rax)
movb $0x1, 0x10(%rax)
... | /polly/Support/ISLTools.h |
llvm::DenseMapBase<llvm::DenseMap<polly::MemoryAccess*, isl_map*, llvm::DenseMapInfo<polly::MemoryAccess*, void>, llvm::detail::DenseMapPair<polly::MemoryAccess*, isl_map*>>, polly::MemoryAccess*, isl_map*, llvm::DenseMapInfo<polly::MemoryAccess*, void>, llvm::detail::DenseMapPair<polly::MemoryAccess*, isl_map*>>::move... | void moveFromOldBuckets(BucketT *OldBucketsBegin, BucketT *OldBucketsEnd) {
initEmpty();
// Insert all the old elements.
const KeyT EmptyKey = getEmptyKey();
const KeyT TombstoneKey = getTombstoneKey();
for (BucketT *B = OldBucketsBegin, *E = OldBucketsEnd; B != E; ++B) {
if (!KeyInfoT::isEqu... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq $0x0, 0x8(%rdi)
movl 0x10(%rdi), %ecx
testq %rcx, %rcx
je 0x208f1c3
movq (%r15), %rax
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x1, %ecx
ne... | /llvm/ADT/DenseMap.h |
std::pair<llvm::DenseMapIterator<polly::Scop*, std::unique_ptr<polly::Dependences, std::default_delete<polly::Dependences>>, llvm::DenseMapInfo<polly::Scop*, void>, llvm::detail::DenseMapPair<polly::Scop*, std::unique_ptr<polly::Dependences, std::default_delete<polly::Dependences>>>, false>, bool> llvm::DenseMapBase<ll... | std::pair<iterator, bool> try_emplace(KeyT &&Key, Ts &&... Args) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return std::make_pair(makeIterator(TheBucket,
shouldReverseIterate<KeyT>()
? getBuckets()
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r13
movq %rsi, %rdi
movq %rdx, %rsi
movq %r13, %rdx
callq 0x208f338
movl %eax, %ecx
movq (%r13), %rax
testb %cl, %cl
je 0x208f2ea
xorl %ecx, %ecx
jmp 0x208f312
movq %r... | /llvm/ADT/DenseMap.h |
llvm::cl::opt<bool, true, llvm::cl::parser<bool>>::opt<char [27], llvm::cl::desc, llvm::cl::LocationClass<bool>, llvm::cl::cat>(char const (&) [27], llvm::cl::desc const&, llvm::cl::LocationClass<bool> const&, llvm::cl::cat const&) | explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
xorl %esi, %esi
xorl %edx, %edx
callq 0x7c77e2
movq $0x0, 0x80(%r14)
movb $0x0, 0x91(%r14)
leaq 0x3652f81(%rip), %rax # 0x56e32a0
addq $0x10, %rax
movq %rax, 0x88(%r14)
leaq 0x3668e9f(... | /llvm/Support/CommandLine.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.