name
string | code
string | asm
string | file
string |
|---|---|---|---|
llvm::cl::opt<llvm::InliningAdvisorMode, false, llvm::cl::parser<llvm::InliningAdvisorMode>>::opt<char [18], llvm::cl::initializer<llvm::InliningAdvisorMode>, llvm::cl::OptionHidden, llvm::cl::desc, llvm::cl::ValuesClass>(char const (&) [18], llvm::cl::initializer<llvm::InliningAdvisorMode> const&, llvm::cl::OptionHidden const&, llvm::cl::desc const&, llvm::cl::ValuesClass 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 0x3c65889(%rip), %rax # 0x58876e0
addq $0x10, %rax
movq %rax, 0x88(%r14)
leaq 0x3c657bf(%rip), %rax # 0x5887628
addq $0x10, %rax
movq %rax, (%r14)
movq %r14, 0xa0(%r14)
leaq 0x3c65812(%rip), %rax # 0x5887690
addq $0x10, %rax
movq %rax, 0x98(%r14)
leaq 0xb8(%r14), %rax
movq %rax, 0xa8(%r14)
movabsq $0x800000000, %rax # imm = 0x800000000
movq %rax, 0xb0(%r14)
movups %xmm0, 0x238(%r14)
leaq 0x81a5(%rip), %rax # 0x1c2a05c
movq %rax, 0x250(%r14)
leaq 0x8199(%rip), %rax # 0x1c2a05e
movq %rax, 0x248(%r14)
movq %r14, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
movq %rbx, %r9
callq 0x1c29fd0
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2b1e814
nop
|
/llvm/Support/CommandLine.h
|
llvm::cl::opt<llvm::AttributorRunOption, false, llvm::cl::parser<llvm::AttributorRunOption>>::opt<char [18], llvm::cl::OptionHidden, llvm::cl::initializer<llvm::AttributorRunOption>, llvm::cl::desc, llvm::cl::ValuesClass>(char const (&) [18], llvm::cl::OptionHidden const&, llvm::cl::initializer<llvm::AttributorRunOption> const&, llvm::cl::desc const&, llvm::cl::ValuesClass 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 0x3c653cd(%rip), %rax # 0x58877d8
addq $0x10, %rax
movq %rax, 0x88(%r14)
leaq 0x3c65303(%rip), %rax # 0x5887720
addq $0x10, %rax
movq %rax, (%r14)
movq %r14, 0xa0(%r14)
leaq 0x3c65356(%rip), %rax # 0x5887788
addq $0x10, %rax
movq %rax, 0x98(%r14)
leaq 0xb8(%r14), %rax
movq %rax, 0xa8(%r14)
movabsq $0x800000000, %rax # imm = 0x800000000
movq %rax, 0xb0(%r14)
movups %xmm0, 0x238(%r14)
leaq 0x8183(%rip), %rax # 0x1c2a5ee
movq %rax, 0x250(%r14)
leaq 0x8177(%rip), %rax # 0x1c2a5f0
movq %rax, 0x248(%r14)
movq %r14, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r15, %r8
movq %rbx, %r9
callq 0x1c2a561
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2b1e814
nop
|
/llvm/Support/CommandLine.h
|
llvm::PassBuilder::addPreInlinerPasses(llvm::PassManager<llvm::Module, llvm::AnalysisManager<llvm::Module>>&, llvm::OptimizationLevel, llvm::ThinOrFullLTOPhase)
|
void PassBuilder::addPreInlinerPasses(ModulePassManager &MPM,
OptimizationLevel Level,
ThinOrFullLTOPhase LTOPhase) {
assert(Level != OptimizationLevel::O0 && "Not expecting O0 here!");
if (DisablePreInliner)
return;
InlineParams IP;
IP.DefaultThreshold = PreInlineThreshold;
// FIXME: The hint threshold has the same value used by the regular inliner
// when not optimzing for size. This should probably be lowered after
// performance testing.
// FIXME: this comment is cargo culted from the old pass manager, revisit).
IP.HintThreshold = Level.isOptimizingForSize() ? PreInlineThreshold : 325;
ModuleInlinerWrapperPass MIWP(
IP, /* MandatoryFirst */ true,
InlineContext{LTOPhase, InlinePass::EarlyInliner});
CGSCCPassManager &CGPipeline = MIWP.getPM();
FunctionPassManager FPM;
FPM.addPass(SROAPass(SROAOptions::ModifyCFG));
FPM.addPass(EarlyCSEPass()); // Catch trivial redundancies.
FPM.addPass(SimplifyCFGPass(SimplifyCFGOptions().convertSwitchRangeToICmp(
true))); // Merge & remove basic blocks.
FPM.addPass(InstCombinePass()); // Combine silly sequences.
invokePeepholeEPCallbacks(FPM, Level);
CGPipeline.addPass(createCGSCCToFunctionPassAdaptor(
std::move(FPM), PTO.EagerlyInvalidateAnalyses));
MPM.addPass(std::move(MIWP));
// Delete anything that is now dead to make sure that we don't instrument
// dead code. Instrumentation can end up keeping dead code around and
// dramatically increase code size.
MPM.addPass(GlobalDCEPass());
}
|
cmpb $0x0, 0x3d2275d(%rip) # 0x5946a78
jne 0x1c2461f
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa48, %rsp # imm = 0xA48
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movl 0x3d227f7(%rip), %edx # 0x5946b38
movq %r15, %rsi
shrq $0x20, %rsi
leaq 0x128(%rsp), %rax
movl %edx, (%rax)
btsq $0x20, %rdx
movabsq $0x100000000, %rdi # imm = 0x100000000
addq $0x145, %rdi # imm = 0x145
testq %rsi, %rsi
cmovneq %rdx, %rdi
movq %rdi, 0x4(%rax)
xorl %r12d, %r12d
movb %r12b, 0x10(%rax)
movb %r12b, 0x18(%rax)
movb %r12b, 0x20(%rax)
movb %r12b, 0x28(%rax)
movb %r12b, 0x30(%rax)
movb %r12b, 0x38(%rax)
movb %r12b, 0x3d(%rax)
movw $0x0, 0x3f(%rax)
movb $0x1, 0x41(%rax)
movl %ecx, %edx
btsq $0x21, %rdx
movl $0x8, %ecx
movq %rsp, %rdi
movq %rax, %rsi
rep movsq (%rsi), %es:(%rdi)
movl 0x40(%rax), %eax
movl %eax, 0x40(%rsp)
leaq 0x88(%rsp), %rdi
movl $0x1, %esi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x1fcf1da
leaq 0x50(%rsp), %r13
movq %r12, 0x10(%r13)
xorps %xmm0, %xmm0
movaps %xmm0, (%r13)
leaq 0x170(%rsp), %rbp
movq %rbp, %rdi
xorl %esi, %esi
callq 0x228cbba
movq %r13, %rdi
movq %rbp, %rsi
callq 0x1bdc22a
movb %r12b, (%rbp)
leaq 0x170(%rsp), %rsi
movq %r13, %rdi
callq 0x1a0743c
leaq 0x70(%rsp), %rsi
xorps %xmm0, %xmm0
movaps %xmm0, (%rsi)
movq %r12, 0x10(%rsi)
movl $0x1, (%rsi)
movb %r12b, 0x4(%rsi)
movabsq $0x1010000010001, %rax # imm = 0x1010000010001
movq %rax, 0x5(%rsi)
leaq 0x170(%rsp), %rbp
movq %rbp, %rdi
callq 0x22bf516
movq %r13, %rdi
movq %rbp, %rsi
callq 0xe7099c
leaq 0x170(%rsp), %rbp
movq %rbp, %rdi
movabsq $0x100000000, %rsi # imm = 0x100000000
callq 0x22e5f18
movq %r13, %rdi
movq %rbp, %rsi
callq 0x1a07488
movq 0x840(%rbp), %rdi
leaq 0x9c0(%rsp), %rax
cmpq %rax, %rdi
je 0x1c24491
callq 0x780910
leaq 0xe0(%rsp), %r12
leaq 0x180(%rsp), %r13
movq 0x818(%r13), %rdi
movl 0x828(%r13), %esi
shlq $0x3, %rsi
movl $0x8, %edx
callq 0x2b410f1
movq 0x800(%r13), %rdi
movl 0x810(%r13), %esi
shlq $0x4, %rsi
movl $0x8, %edx
callq 0x2b410f1
movq -0x10(%r13), %rdi
cmpq %r13, %rdi
je 0x1c244e7
callq 0x780910
leaq 0x50(%rsp), %r13
movq %r14, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x1c22566
movzbl 0x20(%r14), %edx
leaq 0x170(%rsp), %r14
xorl %ebp, %ebp
movq %r14, %rdi
movq %r13, %rsi
xorl %ecx, %ecx
callq 0x1bcfd4f
movq %r12, %rdi
movq %r14, %rsi
callq 0xaed430
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1c2452f
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x88(%rsp), %rsi
movq %rbx, %rdi
callq 0x1a07710
leaq 0x198(%rsp), %rax
movb $0x0, -0x28(%rax)
movq %rax, -0x20(%rax)
movq %rax, -0x18(%rax)
movl $0x20, %ecx
movq %rcx, -0x10(%rax)
movl %ebp, -0x8(%rax)
leaq 0x2e0(%rsp), %rax
xorps %xmm0, %xmm0
movups %xmm0, -0x48(%rax)
movl %ebp, -0x38(%rax)
movq %rax, -0x30(%rax)
movl $0x1, %edx
movq %rdx, -0x28(%rax)
movups %xmm0, -0x20(%rax)
movl $0x3f800000, %esi # imm = 0x3F800000
movl %esi, -0x10(%rax)
movups %xmm0, -0x8(%rax)
leaq 0x318(%rsp), %rax
movq %rax, -0x30(%rax)
movq %rdx, -0x28(%rax)
movups %xmm0, -0x20(%rax)
movl %esi, -0x10(%rax)
leaq 0x358(%rsp), %rax
movups %xmm0, -0x48(%rax)
movups %xmm0, -0x38(%rax)
movl %ebp, -0x28(%rax)
movq %rax, -0x20(%rax)
movq %rax, -0x18(%rax)
movq %rcx, -0x10(%rax)
movl %ebp, -0x8(%rax)
leaq 0x170(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xaec81a
movq %r14, %rdi
callq 0xaec896
leaq 0x50(%rsp), %rdi
callq 0x802f1a
leaq 0x110(%rsp), %rdi
callq 0x804aec
leaq 0xf8(%rsp), %rdi
callq 0x804aec
movq %r12, %rdi
callq 0x803abe
addq $0xa48, %rsp # imm = 0xA48
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/Passes/PassBuilderPipelines.cpp
|
llvm::PassBuilder::buildO0DefaultPipeline(llvm::OptimizationLevel, bool)
|
ModulePassManager PassBuilder::buildO0DefaultPipeline(OptimizationLevel Level,
bool LTOPreLink) {
assert(Level == OptimizationLevel::O0 &&
"buildO0DefaultPipeline should only be used with O0");
ModulePassManager MPM;
// Perform pseudo probe instrumentation in O0 mode. This is for the
// consistency between different build modes. For example, a LTO build can be
// mixed with an O0 prelink and an O2 postlink. Loading a sample profile in
// the postlink will require pseudo probe instrumentation in the prelink.
if (PGOOpt && PGOOpt->PseudoProbeForProfiling)
MPM.addPass(SampleProfileProbePass(TM));
if (PGOOpt && (PGOOpt->Action == PGOOptions::IRInstr ||
PGOOpt->Action == PGOOptions::IRUse))
addPGOInstrPassesForO0(
MPM,
/*RunProfileGen=*/(PGOOpt->Action == PGOOptions::IRInstr),
/*IsCS=*/false, PGOOpt->AtomicCounterUpdate, PGOOpt->ProfileFile,
PGOOpt->ProfileRemappingFile, PGOOpt->FS);
// Instrument function entry and exit before all inlining.
MPM.addPass(createModuleToFunctionPassAdaptor(
EntryExitInstrumenterPass(/*PostInlining=*/false)));
invokePipelineStartEPCallbacks(MPM, Level);
if (PGOOpt && PGOOpt->DebugInfoForProfiling)
MPM.addPass(createModuleToFunctionPassAdaptor(AddDiscriminatorsPass()));
invokePipelineEarlySimplificationEPCallbacks(MPM, Level);
// Build a minimal pipeline based on the semantics required by LLVM,
// which is just that always inlining occurs. Further, disable generating
// lifetime intrinsics to avoid enabling further optimizations during
// code generation.
MPM.addPass(AlwaysInlinerPass(
/*InsertLifetimeIntrinsics=*/false));
if (PTO.MergeFunctions)
MPM.addPass(MergeFunctionsPass());
if (EnableMatrix)
MPM.addPass(
createModuleToFunctionPassAdaptor(LowerMatrixIntrinsicsPass(true)));
if (!CGSCCOptimizerLateEPCallbacks.empty()) {
CGSCCPassManager CGPM;
invokeCGSCCOptimizerLateEPCallbacks(CGPM, Level);
if (!CGPM.isEmpty())
MPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM)));
}
if (!LateLoopOptimizationsEPCallbacks.empty()) {
LoopPassManager LPM;
invokeLateLoopOptimizationsEPCallbacks(LPM, Level);
if (!LPM.isEmpty()) {
MPM.addPass(createModuleToFunctionPassAdaptor(
createFunctionToLoopPassAdaptor(std::move(LPM))));
}
}
if (!LoopOptimizerEndEPCallbacks.empty()) {
LoopPassManager LPM;
invokeLoopOptimizerEndEPCallbacks(LPM, Level);
if (!LPM.isEmpty()) {
MPM.addPass(createModuleToFunctionPassAdaptor(
createFunctionToLoopPassAdaptor(std::move(LPM))));
}
}
if (!ScalarOptimizerLateEPCallbacks.empty()) {
FunctionPassManager FPM;
invokeScalarOptimizerLateEPCallbacks(FPM, Level);
if (!FPM.isEmpty())
MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
}
invokeOptimizerEarlyEPCallbacks(MPM, Level);
if (!VectorizerStartEPCallbacks.empty()) {
FunctionPassManager FPM;
invokeVectorizerStartEPCallbacks(FPM, Level);
if (!FPM.isEmpty())
MPM.addPass(createModuleToFunctionPassAdaptor(std::move(FPM)));
}
ModulePassManager CoroPM;
CoroPM.addPass(CoroEarlyPass());
CGSCCPassManager CGPM;
CGPM.addPass(CoroSplitPass());
CoroPM.addPass(createModuleToPostOrderCGSCCPassAdaptor(std::move(CGPM)));
CoroPM.addPass(CoroCleanupPass());
CoroPM.addPass(GlobalDCEPass());
MPM.addPass(CoroConditionalWrapper(std::move(CoroPM)));
invokeOptimizerLastEPCallbacks(MPM, Level);
if (LTOPreLink)
addRequiredLTOPreLinkPasses(MPM);
MPM.addPass(createModuleToFunctionPassAdaptor(AnnotationRemarksPass()));
return MPM;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3f8, %rsp # imm = 0x3F8
movl %ecx, %ebp
movq %rdx, 0x10(%rsp)
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
cmpb $0x1, 0xc0(%rsi)
jne 0x1c2750f
cmpb $0x1, 0xb5(%r15)
jne 0x1c2750f
movq (%r15), %rax
leaq 0x110(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x1bc30f6
cmpb $0x1, 0xc0(%r15)
jne 0x1c2764e
movl 0xa8(%r15), %r14d
leal -0x1(%r14), %eax
cmpl $0x1, %eax
ja 0x1c2764e
movl %ebp, 0xc(%rsp)
movb 0xb6(%r15), %bpl
leaq 0xe0(%rsp), %rax
movq %rax, -0x10(%rax)
movq 0x28(%r15), %rsi
movq 0x30(%r15), %rdx
addq %rsi, %rdx
leaq 0xd0(%rsp), %rdi
callq 0x7fc9f8
leaq 0x100(%rsp), %rax
movq %rax, -0x10(%rax)
movq 0x68(%r15), %rsi
movq 0x70(%r15), %rdx
addq %rsi, %rdx
leaq 0xf0(%rsp), %r12
movq %r12, %rdi
callq 0x7fc9f8
movq 0xb8(%r15), %r13
movq %r13, 0x18(%rsp)
movzbl %bpl, %r8d
xorl %edx, %edx
testq %r13, %r13
je 0x1c275db
cmpl $0x1, %r14d
sete %dl
lock
incl 0x8(%r13)
leaq 0x18(%rsp), %rax
leaq 0xd0(%rsp), %r9
movq %rbx, %rsi
xorl %ecx, %ecx
pushq %rax
pushq %r12
callq 0x1c2498c
addq $0x10, %rsp
lock
decl 0x8(%r13)
jne 0x1c27600
movq (%r13), %rax
movq %r13, %rdi
callq *0x8(%rax)
jmp 0x1c27600
cmpl $0x1, %r14d
sete %dl
leaq 0x18(%rsp), %rax
leaq 0xd0(%rsp), %r9
movq %rbx, %rsi
xorl %ecx, %ecx
pushq %rax
pushq %r12
callq 0x1c2498c
addq $0x10, %rsp
movq 0xf0(%rsp), %rdi
leaq 0x100(%rsp), %rax
cmpq %rax, %rdi
movl 0xc(%rsp), %ebp
je 0x1c27629
movq 0x100(%rsp), %rsi
incq %rsi
callq 0x7800d0
movq 0xd0(%rsp), %rdi
leaq 0xe0(%rsp), %rax
cmpq %rax, %rdi
je 0x1c2764e
movq 0xe0(%rsp), %rsi
incq %rsi
callq 0x7800d0
movl $0x10, %edi
callq 0x7808d0
leaq 0x3b37541(%rip), %rcx # 0x575eba0
addq $0x10, %rcx
movq %rcx, (%rax)
xorl %ecx, %ecx
movb %cl, 0x8(%rax)
leaq 0x110(%rsp), %r12
movq %rax, (%r12)
movb %cl, 0x8(%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xade086
movq (%r12), %rdi
testq %rdi, %rdi
je 0x1c27696
movq (%rdi), %rax
callq *0x8(%rax)
movq %r15, %rdi
movq %rbx, %rsi
movq 0x10(%rsp), %r14
movq %r14, %rdx
callq 0x1c22962
cmpb $0x1, 0xc0(%r15)
jne 0x1c27701
cmpb $0x1, 0xb4(%r15)
jne 0x1c27701
movl $0x10, %edi
callq 0x7808d0
leaq 0x3c5af02(%rip), %rcx # 0x58825d0
addq $0x10, %rcx
movq %rcx, (%rax)
leaq 0x110(%rsp), %r12
movq %rax, (%r12)
movb $0x0, 0x8(%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xade086
movq (%r12), %rdi
testq %rdi, %rdi
je 0x1c27701
movq (%rdi), %rax
callq *0x8(%rax)
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1c229c8
leaq 0x110(%rsp), %rsi
movb $0x0, (%rsi)
movq %rbx, %rdi
callq 0x1a314a0
cmpb $0x1, 0x1a(%r15)
jne 0x1c27739
leaq 0x110(%rsp), %rsi
movq %rbx, %rdi
callq 0x1bc290e
cmpb $0x1, 0x3d1f938(%rip) # 0x5947078
jne 0x1c2778a
movl $0x10, %edi
callq 0x7808d0
leaq 0x3c5d1bd(%rip), %rcx # 0x5884910
addq $0x10, %rcx
movq %rcx, (%rax)
movb $0x1, 0x8(%rax)
leaq 0x110(%rsp), %r12
movq %rax, (%r12)
movb $0x0, 0x8(%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xade086
movq (%r12), %rdi
testq %rdi, %rdi
je 0x1c2778a
movq (%rdi), %rax
callq *0x8(%rax)
cmpl $0x0, 0x218(%r15)
je 0x1c27802
xorps %xmm0, %xmm0
leaq 0x110(%rsp), %r12
movaps %xmm0, (%r12)
movq $0x0, 0x10(%r12)
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x1c226fe
movq (%r12), %rax
cmpq 0x8(%r12), %rax
je 0x1c277f5
leaq 0x20(%rsp), %r12
leaq 0x110(%rsp), %rsi
movq %r12, %rdi
callq 0x1bc1228
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1bc11d6
movq (%r12), %rdi
testq %rdi, %rdi
je 0x1c277f5
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x110(%rsp), %rdi
callq 0x803abe
cmpl $0x0, 0x128(%r15)
movabsq $0x600000000, %rax # imm = 0x600000000
je 0x1c279c4
leaq 0x30(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movl $0x0, 0x30(%rcx)
leaq 0x68(%rsp), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
leaq 0x20(%rsp), %r13
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x1c225cc
movq 0x48(%r13), %r14
movq 0x50(%r13), %r12
leaq 0x80(%rsp), %rdi
cmpq %r12, %r14
jne 0x1c2787f
movq 0x88(%rsp), %rax
cmpq %rax, 0x80(%rsp)
je 0x1c27992
movl %ebp, 0xc(%rsp)
movl $0x80, %edi
callq 0x7808d0
movq %rax, %r13
leaq 0x110(%rsp), %rbp
leaq 0x20(%rsp), %rsi
movq %rbp, %rdi
callq 0x1a07ac2
leaq 0x3c53244(%rip), %rax # 0x587aaf0
addq $0x10, %rax
movq %rax, (%r13)
leaq 0x8(%r13), %rdi
movq %rbp, %rsi
callq 0x1a07ac2
cmpq %r12, %r14
leaq 0xa8(%rsp), %rbp
movq %r13, -0x8(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, (%rbp)
movups %xmm0, 0xb(%rbp)
sete 0x1b(%rbp)
leaq 0xb(%rsp), %rsi
movq %rbp, %rdi
callq 0xae03bc
leaq 0xb(%rsp), %rsi
movq %rbp, %rdi
callq 0xae03fc
leaq 0x170(%rsp), %rdi
callq 0x8033bc
leaq 0x158(%rsp), %r13
movq %r13, %rdi
callq 0x80340a
movq -0x48(%r13), %rdi
leaq 0x120(%rsp), %rax
cmpq %rax, %rdi
je 0x1c2792b
callq 0x780910
leaq 0x110(%rsp), %r13
leaq 0xa0(%rsp), %rsi
movq %r13, %rdi
xorl %edx, %edx
callq 0x1bc81db
movq %rbx, %rdi
movq %r13, %rsi
callq 0xade086
movq (%r13), %rdi
testq %rdi, %rdi
je 0x1c2795f
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x110(%rsp)
movq %rbp, %rdi
callq 0x802f1a
movq 0xa0(%rsp), %rdi
testq %rdi, %rdi
je 0x1c27986
movq (%rdi), %rax
callq *0x8(%rax)
movl 0xc(%rsp), %ebp
leaq 0x80(%rsp), %rdi
callq 0x8033bc
leaq 0x68(%rsp), %rdi
callq 0x80340a
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x1c279b5
callq 0x780910
movq 0x10(%rsp), %r14
movabsq $0x600000000, %rax # imm = 0x600000000
cmpl $0x0, 0x178(%r15)
je 0x1c27b72
leaq 0x30(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movl $0x0, 0x30(%rcx)
leaq 0x68(%rsp), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
leaq 0x20(%rsp), %r13
movq %r15, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x1c22632
movq 0x48(%r13), %r14
movq 0x50(%r13), %r12
leaq 0x80(%rsp), %rdi
cmpq %r12, %r14
jne 0x1c27a37
movq 0x88(%rsp), %rax
cmpq %rax, 0x80(%rsp)
je 0x1c27b4a
movl %ebp, 0xc(%rsp)
movl $0x80, %edi
callq 0x7808d0
movq %rax, %r13
leaq 0x110(%rsp), %rbp
leaq 0x20(%rsp), %rsi
movq %rbp, %rdi
callq 0x1a07ac2
leaq 0x3c5308c(%rip), %rax # 0x587aaf0
addq $0x10, %rax
movq %rax, (%r13)
leaq 0x8(%r13), %rdi
movq %rbp, %rsi
callq 0x1a07ac2
cmpq %r12, %r14
leaq 0xa8(%rsp), %rbp
movq %r13, -0x8(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, (%rbp)
movups %xmm0, 0xb(%rbp)
sete 0x1b(%rbp)
leaq 0xb(%rsp), %rsi
movq %rbp, %rdi
callq 0xae03bc
leaq 0xb(%rsp), %rsi
movq %rbp, %rdi
callq 0xae03fc
leaq 0x170(%rsp), %rdi
callq 0x8033bc
leaq 0x158(%rsp), %r13
movq %r13, %rdi
callq 0x80340a
movq -0x48(%r13), %rdi
leaq 0x120(%rsp), %rax
cmpq %rax, %rdi
je 0x1c27ae3
callq 0x780910
leaq 0x110(%rsp), %r13
leaq 0xa0(%rsp), %rsi
movq %r13, %rdi
xorl %edx, %edx
callq 0x1bc81db
movq %rbx, %rdi
movq %r13, %rsi
callq 0xade086
movq (%r13), %rdi
testq %rdi, %rdi
je 0x1c27b17
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x110(%rsp)
movq %rbp, %rdi
callq 0x802f1a
movq 0xa0(%rsp), %rdi
testq %rdi, %rdi
je 0x1c27b3e
movq (%rdi), %rax
callq *0x8(%rax)
movl 0xc(%rsp), %ebp
leaq 0x80(%rsp), %rdi
callq 0x8033bc
leaq 0x68(%rsp), %rdi
callq 0x80340a
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x1c27b6d
callq 0x780910
movq 0x10(%rsp), %r14
cmpl $0x0, 0x1c8(%r15)
je 0x1c27bec
xorps %xmm0, %xmm0
leaq 0x110(%rsp), %r12
movaps %xmm0, (%r12)
movq $0x0, 0x10(%r12)
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x1c22698
movq (%r12), %rax
cmpq 0x8(%r12), %rax
je 0x1c27bdf
leaq 0x20(%rsp), %r12
leaq 0x110(%rsp), %rsi
movq %r12, %rdi
xorl %edx, %edx
callq 0xade0da
movq %rbx, %rdi
movq %r12, %rsi
callq 0xade086
movq (%r12), %rdi
testq %rdi, %rdi
je 0x1c27bdf
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x110(%rsp), %rdi
callq 0x802f1a
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1c227ca
cmpl $0x0, 0x268(%r15)
je 0x1c27c74
xorps %xmm0, %xmm0
leaq 0x110(%rsp), %r12
movaps %xmm0, (%r12)
movq $0x0, 0x10(%r12)
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x1c22764
movq (%r12), %rax
cmpq 0x8(%r12), %rax
je 0x1c27c67
leaq 0x20(%rsp), %r12
leaq 0x110(%rsp), %rsi
movq %r12, %rdi
xorl %edx, %edx
callq 0xade0da
movq %rbx, %rdi
movq %r12, %rsi
callq 0xade086
movq (%r12), %rdi
testq %rdi, %rdi
je 0x1c27c67
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x110(%rsp), %rdi
callq 0x802f1a
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdi
movaps %xmm0, (%rdi)
xorl %r14d, %r14d
movq %r14, 0x10(%rdi)
leaq 0x110(%rsp), %rsi
callq 0x1bc1e5c
leaq 0xa0(%rsp), %r12
movq %r14, 0x10(%r12)
xorps %xmm0, %xmm0
movaps %xmm0, (%r12)
leaq 0x110(%rsp), %r13
movq %r13, %rdi
xorl %esi, %esi
callq 0x1f0c7b4
movq %r12, %rdi
movq %r13, %rsi
callq 0x1bd02c8
movq 0x10(%r13), %rax
testq %rax, %rax
je 0x1c27ce0
leaq 0x110(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x110(%rsp), %r12
leaq 0xa0(%rsp), %rsi
movq %r12, %rdi
callq 0x1bc1228
leaq 0x20(%rsp), %rdi
movq %r12, %rsi
callq 0x1bc11d6
movq (%r12), %rdi
testq %rdi, %rdi
movq 0x10(%rsp), %r14
je 0x1c27d19
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x20(%rsp), %r12
leaq 0x110(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x1bc1e18
movb $0x0, (%r13)
leaq 0x138(%rsp), %rax
movq %rax, -0x20(%rax)
movq %rax, -0x18(%rax)
movl $0x20, %ecx
movq %rcx, -0x10(%rax)
xorl %edx, %edx
movl %edx, -0x8(%rax)
leaq 0x280(%rsp), %rax
xorps %xmm0, %xmm0
movups %xmm0, -0x48(%rax)
movl %edx, -0x38(%rax)
movq %rax, -0x30(%rax)
movl $0x1, %esi
movq %rsi, -0x28(%rax)
movups %xmm0, -0x20(%rax)
movl $0x3f800000, %edi # imm = 0x3F800000
movl %edi, -0x10(%rax)
movups %xmm0, -0x8(%rax)
leaq 0x2b8(%rsp), %rax
movq %rax, -0x30(%rax)
movq %rsi, -0x28(%rax)
movups %xmm0, -0x20(%rax)
movl %edi, -0x10(%rax)
leaq 0x2f8(%rsp), %rax
movups %xmm0, -0x48(%rax)
movups %xmm0, -0x38(%rax)
movl %edx, -0x28(%rax)
movq %rax, -0x20(%rax)
movq %rax, -0x18(%rax)
movq %rcx, -0x10(%rax)
movl %edx, -0x8(%rax)
leaq 0x110(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0xaec81a
movq %r13, %rdi
callq 0xaec896
leaq 0x110(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x1f093d4
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1bc10b4
movq %r13, %rdi
callq 0x804aec
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1c22830
testb %bpl, %bpl
je 0x1c27e30
leaq 0x110(%rsp), %rsi
movq %rbx, %rdi
callq 0x1bc1d90
leaq 0x110(%rsp), %rsi
movq %rbx, %rdi
callq 0x1bc29f8
movl $0x10, %edi
callq 0x7808d0
leaq 0x3c5a84f(%rip), %rcx # 0x5882690
addq $0x10, %rcx
movq %rcx, (%rax)
leaq 0x110(%rsp), %r14
movq %rax, (%r14)
movb $0x0, 0x8(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xade086
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1c27e71
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0xa0(%rsp), %rdi
callq 0x803abe
leaq 0x20(%rsp), %rdi
callq 0x804aec
movq %rbx, %rax
addq $0x3f8, %rsp # imm = 0x3F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/Passes/PassBuilderPipelines.cpp
|
llvm::cl::opt<llvm::InliningAdvisorMode, false, llvm::cl::parser<llvm::InliningAdvisorMode>>::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 0x1c29b04
subq $0x18, %rsp
leaq 0x98(%rsi), %rdi
movl 0x80(%rsi), %eax
leaq 0x88(%rsi), %rcx
leaq 0x3c5dbf9(%rip), %r9 # 0x58876e0
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 0x1c29ac8
movl 0x80(%rsi), %eax
cmpl %eax, 0x90(%rsi)
jne 0x1c29ac8
retq
|
/llvm/Support/CommandLine.h
|
llvm::IRChangedTester::handleInitialIR(llvm::Any)
|
void IRChangedTester::handleInitialIR(Any IR) {
// Always test the initial module.
// Unwrap and print directly to avoid filtering problems in general routines.
std::string S;
generateIRRepresentation(IR, "Initial IR", S);
handleIR(S, "Initial IR");
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq (%rsi), %rsi
testq %rsi, %rsi
je 0x1c2c5ca
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *0x10(%rax)
jmp 0x1c2c5d3
movq $0x0, 0x8(%rsp)
movq (%rbx), %rax
leaq 0x330c654(%rip), %rdx # 0x4f38c31
leaq 0x8(%rsp), %r14
leaq 0x10(%rsp), %r8
movl $0xa, %ecx
movq %rbx, %rdi
movq %r14, %rsi
callq *0x18(%rax)
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1c2c603
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
leaq 0x330c61e(%rip), %rdx # 0x4f38c31
leaq 0x10(%rsp), %rbx
movl $0xa, %ecx
movq %rbx, %rsi
callq 0x1c2c38e
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x1c2c63a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x7800d0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/Passes/StandardInstrumentations.cpp
|
llvm::TextChangeReporter<llvm::IRDataT<llvm::EmptyData>>::handleFiltered(llvm::StringRef, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
|
void TextChangeReporter<T>::handleFiltered(StringRef PassID,
std::string &Name) {
SmallString<20> Banner =
formatv("*** IR Dump After {0} on {1} filtered out ***\n", PassID, Name);
Out << Banner;
}
|
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
leaq 0x58(%rsp), %rdx
leaq 0x330649c(%rip), %rsi # 0x4f38e0d
movq %rsi, -0x40(%rdx)
movq $0x2e, -0x38(%rdx)
movq %rdx, -0x30(%rdx)
movq $0x2, -0x28(%rdx)
leaq 0x38(%rsp), %rdx
leaq 0x3c55453(%rip), %rsi # 0x5887de8
addq $0x10, %rsi
movq %rsi, (%rdx)
movq %rcx, 0x8(%rdx)
leaq 0x48(%rsp), %rcx
leaq 0x3c4dcf4(%rip), %rsi # 0x58806a0
addq $0x10, %rsi
movq %rsi, (%rcx)
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rdx, 0x18(%rcx)
leaq 0x68(%rsp), %r14
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x1c3cf66
movq 0x28(%rbx), %rdi
movq (%r14), %rsi
movq 0x8(%r14), %rdx
callq 0x2b7d704
movq (%r14), %rdi
leaq 0x80(%rsp), %rax
cmpq %rax, %rdi
je 0x1c329f6
callq 0x780910
addq $0x98, %rsp
popq %rbx
popq %r14
retq
nop
|
/Passes/StandardInstrumentations.cpp
|
(anonymous namespace)::makeHTMLReady[abi:cxx11](llvm::StringRef)
|
std::string makeHTMLReady(StringRef SR) {
std::string S;
while (true) {
StringRef Clean =
SR.take_until([](char C) { return C == '<' || C == '>'; });
S.append(Clean.str());
SR = SR.drop_front(Clean.size());
if (SR.size() == 0)
return S;
S.append(SR[0] == '<' ? "<" : ">");
SR = SR.drop_front();
}
llvm_unreachable("problems converting string to HTML");
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x18(%rsp), %rbp
xorl %r13d, %r13d
movq $-0x1, %r12
testq %r15, %r15
je 0x1c389d6
xorl %eax, %eax
movb (%r14,%rax), %cl
andb $-0x3, %cl
cmpb $0x3c, %cl
je 0x1c389d3
incq %rax
cmpq %rax, %r15
jne 0x1c389bd
jmp 0x1c389d6
movq %rax, %r12
cmpq %r12, %r15
cmovbq %r15, %r12
movq %rbp, 0x8(%rsp)
testq %r14, %r14
je 0x1c389fa
leaq (%r14,%r12), %rdx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x7fa87c
jmp 0x1c38a08
movq $0x0, 0x10(%rsp)
movb $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x780d70
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1c38a31
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7800d0
addq %r12, %r14
subq %r12, %r15
je 0x1c38a60
cmpb $0x3c, (%r14)
leaq 0x3300b21(%rip), %rsi # 0x4f39565
leaq 0x3300b15(%rip), %rax # 0x4f39560
cmoveq %rax, %rsi
movq %rbx, %rdi
callq 0x780c80
incq %r14
leaq -0x1(%r15), %rax
jmp 0x1c38a66
movb $0x1, %r13b
movq %r15, %rax
testq %r15, %r15
movq %rax, %r15
jne 0x1c389af
testb $0x1, %r13b
jne 0x1c38a90
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x1c38a90
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x7800d0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/Passes/StandardInstrumentations.cpp
|
llvm::IRComparer<llvm::DCData>::analyzeIR(llvm::Any, llvm::IRDataT<llvm::DCData>&)
|
void IRComparer<T>::analyzeIR(Any IR, IRDataT<T> &Data) {
if (const Module *M = getModuleForComparison(IR)) {
// Create data for each existing/interesting function in the module.
for (const Function &F : *M)
generateFunctionData(Data, F);
return;
}
if (const auto *F = unwrapIR<Function>(IR)) {
generateFunctionData(Data, *F);
return;
}
if (const auto *L = unwrapIR<Loop>(IR)) {
auto *F = L->getHeader()->getParent();
generateFunctionData(Data, *F);
return;
}
if (const auto *MF = unwrapIR<MachineFunction>(IR)) {
generateFunctionData(Data, *MF);
return;
}
llvm_unreachable("Unknown IR unit");
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x1c38ee4
movq (%rsi), %rax
leaq 0x18(%rsp), %rdi
callq *0x10(%rax)
jmp 0x1c38eed
movq $0x0, 0x18(%rsp)
leaq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0x1c30ff4
movq %rax, %r15
movq (%r12), %rdi
testq %rdi, %rdi
je 0x1c38f0c
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x18(%rsp)
testq %r15, %r15
je 0x1c38f49
leaq 0x18(%r15), %r12
movq 0x20(%r15), %r13
cmpq %r12, %r13
je 0x1c38f40
leaq -0x38(%r13), %rsi
testq %r13, %r13
cmoveq %r13, %rsi
movq %rbx, %rdi
callq 0x1c42414
movq 0x8(%r13), %r13
jmp 0x1c38f22
testq %r15, %r15
jne 0x1c39042
movq (%r14), %rsi
testq %rsi, %rsi
je 0x1c38f5e
movq (%rsi), %rax
leaq 0x10(%rsp), %rdi
callq *0x10(%rax)
jmp 0x1c38f67
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1c38f80
movq (%rdi), %rax
callq *0x18(%rax)
cmpq 0x3cc2dda(%rip), %rax # 0x58fbd58
je 0x1c38f84
xorl %eax, %eax
jmp 0x1c38f8d
movq 0x10(%rsp), %rax
addq $0x8, %rax
testq %rax, %rax
je 0x1c38f97
movq (%rax), %r15
jmp 0x1c38f9a
xorl %r15d, %r15d
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1c38faa
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x10(%rsp)
testq %r15, %r15
je 0x1c38fc0
movq %rbx, %rdi
movq %r15, %rsi
jmp 0x1c3903d
movq (%r14), %rsi
testq %rsi, %rsi
je 0x1c38fd5
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *0x10(%rax)
jmp 0x1c38fde
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1c38ff7
movq (%rdi), %rax
callq *0x18(%rax)
cmpq 0x3cc285b(%rip), %rax # 0x58fb850
je 0x1c38ffb
xorl %eax, %eax
jmp 0x1c39004
movq 0x8(%rsp), %rax
addq $0x8, %rax
testq %rax, %rax
je 0x1c3900e
movq (%rax), %r15
jmp 0x1c39011
xorl %r15d, %r15d
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1c39021
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rsp)
testq %r15, %r15
je 0x1c39050
movq 0x20(%r15), %rax
movq (%rax), %rax
movq 0x48(%rax), %rsi
movq %rbx, %rdi
callq 0x1c42414
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq (%r14), %rsi
testq %rsi, %rsi
je 0x1c39063
movq (%rsi), %rax
movq %rsp, %rdi
callq *0x10(%rax)
jmp 0x1c3906b
movq $0x0, (%rsp)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1c39083
movq (%rdi), %rax
callq *0x18(%rax)
cmpq 0x3cc282f(%rip), %rax # 0x58fb8b0
je 0x1c39087
xorl %eax, %eax
jmp 0x1c3908f
movq (%rsp), %rax
addq $0x8, %rax
testq %rax, %rax
je 0x1c39099
movq (%rax), %r14
jmp 0x1c3909c
xorl %r14d, %r14d
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1c390ab
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%rsp)
testq %r14, %r14
je 0x1c39042
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1c42800
jmp 0x1c39042
|
/Passes/StandardInstrumentations.cpp
|
llvm::SmallString<80u> llvm::formatv_object_base::sstr<80u>() const
|
SmallString<N> sstr() const {
SmallString<N> Result;
raw_svector_ostream Stream(Result);
Stream << *this;
return Result;
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rdi), %rax
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movq $0x50, 0x10(%rdi)
leaq 0x8(%rsp), %r15
movl $0x2, 0x8(%r15)
movb $0x0, 0x28(%r15)
movl $0x1, 0x2c(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movq %rax, 0x20(%r15)
leaq 0x3cbe09b(%rip), %rax # 0x58f9ff8
addq $0x10, %rax
movq %rax, (%r15)
movq %rdi, 0x30(%r15)
movq %r15, %rdi
callq 0x7fa22e
movq %r15, %rdi
movq %r14, %rsi
callq 0x2b7d838
movq %r15, %rdi
callq 0x2b7e98e
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/llvm/Support/FormatVariadic.h
|
llvm::unique_function<void (llvm::StringRef, llvm::PreservedAnalyses const&)> const* llvm::SmallVectorTemplateCommon<llvm::unique_function<void (llvm::StringRef, llvm::PreservedAnalyses const&)>, void>::reserveForParamAndGetAddressImpl<llvm::SmallVectorTemplateBase<llvm::unique_function<void (llvm::StringRef, llvm::PreservedAnalyses const&)>, false>>(llvm::SmallVectorTemplateBase<llvm::unique_function<void (llvm::StringRef, llvm::PreservedAnalyses const&)>, false>*, llvm::unique_function<void (llvm::StringRef, llvm::PreservedAnalyses const&)> const&, unsigned long)
|
static const T *reserveForParamAndGetAddressImpl(U *This, const T &Elt,
size_t N) {
size_t NewSize = This->size() + N;
if (LLVM_LIKELY(NewSize <= This->capacity()))
return &Elt;
bool ReferencesStorage = false;
int64_t Index = -1;
if (!U::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 0x1c3d6b0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %r14
movq (%rdi), %rax
shlq $0x5, %rcx
addq %rax, %rcx
cmpq %rbx, %rax
setbe %sil
cmpq %rbx, %rcx
seta %bpl
andb %sil, %bpl
movq $-0x1, %r15
cmpb $0x1, %bpl
je 0x1c3d6f7
movq %r14, %rdi
movq %rdx, %rsi
callq 0x1c3d704
testb %bpl, %bpl
je 0x1c3d6a2
shlq $0x5, %r15
addq (%r14), %r15
movq %r15, %rbx
jmp 0x1c3d6a2
movq %rbx, %r15
subq %rax, %r15
sarq $0x5, %r15
jmp 0x1c3d6db
nop
|
/llvm/ADT/SmallVector.h
|
llvm::StringMap<llvm::BlockDataT<llvm::DCData>, llvm::MallocAllocator>::StringMap(llvm::StringMap<llvm::BlockDataT<llvm::DCData>, llvm::MallocAllocator> const&)
|
explicit StringMapImpl(unsigned itemSize) : ItemSize(itemSize) {}
|
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movabsq $0x6000000000, %rax # imm = 0x6000000000
movq %rax, 0x10(%rdi)
cmpl $0x0, 0xc(%rsi)
je 0x1c435cf
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rsi), %esi
callq 0x2b56054
movq (%r14), %rax
movl 0x8(%r14), %r15d
movq (%rbx), %rcx
movq 0xc(%rbx), %rdx
movq %rdx, 0xc(%r14)
testq %r15, %r15
je 0x1c435c1
leaq (%rax,%r15,8), %r12
addq $0x8, %r12
leaq (%rcx,%r15,8), %r13
addq $0x8, %r13
shlq $0x2, %r15
xorl %ebp, %ebp
movq (%rbx), %rax
movq (%rax,%rbp,2), %rcx
testq %rcx, %rcx
je 0x1c4358c
cmpq $-0x8, %rcx
jne 0x1c43595
movq (%r14), %rax
movq %rcx, (%rax,%rbp,2)
jmp 0x1c435b8
leaq 0x60(%rcx), %rdi
movq (%rcx), %rsi
addq $0x8, %rcx
movq %r14, %rdx
callq 0x1c435d0
movq (%r14), %rcx
movq %rax, (%rcx,%rbp,2)
movl (%r13,%rbp), %eax
movl %eax, (%r12,%rbp)
addq $0x4, %rbp
cmpq %rbp, %r15
jne 0x1c4357a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/llvm/ADT/StringMap.h
|
llvm::StringMapEntryStorage<llvm::FuncDataT<llvm::DCData>>::StringMapEntryStorage<llvm::FuncDataT<llvm::DCData>&>(unsigned long, llvm::FuncDataT<llvm::DCData>&)
|
StringMapEntryStorage(size_t keyLength, InitTy &&...initVals)
: StringMapEntryBase(keyLength),
second(std::forward<InitTy>(initVals)...) {}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq %rsi, (%rdi)
addq $0x8, %rdi
movq %rdx, %rsi
callq 0x897b2c
leaq 0x20(%r14), %rdi
leaq 0x18(%rbx), %rsi
callq 0x1c43516
leaq 0x38(%r14), %rdi
leaq 0x48(%r14), %rax
movq %rax, 0x38(%r14)
movq 0x30(%rbx), %rsi
movq 0x38(%rbx), %rdx
addq %rsi, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7fc9f8
nop
|
/llvm/ADT/StringMapEntry.h
|
void llvm::detail::UniqueFunctionBase<void, llvm::StringRef, llvm::Any, llvm::PreservedAnalyses const&>::CallImpl<llvm::ChangeReporter<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::registerRequiredCallbacks(llvm::PassInstrumentationCallbacks&)::'lambda'(llvm::StringRef, llvm::Any, llvm::PreservedAnalyses const&)>(void*, llvm::StringRef, llvm::Any&, llvm::PreservedAnalyses const&)
|
static ReturnT CallImpl(void *CallableAddr,
AdjustedParamT<ParamTs>... Params) {
auto &Func = *reinterpret_cast<CalledAsT *>(CallableAddr);
return Func(std::forward<ParamTs>(Params)...);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
movq (%rcx), %rbx
movq $0x0, (%rcx)
movq 0x8(%rdi), %r12
testq %rbx, %rbx
je 0x1c45599
movq (%rbx), %rax
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq *0x10(%rax)
jmp 0x1c455a2
movq $0x0, 0x8(%rsp)
movq (%r13), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2a8ba8c
movq %rdx, %r9
leaq 0x8(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x1c31b48
movq (%r13), %rdi
testq %rdi, %rdi
je 0x1c455dc
movq (%rdi), %rax
callq *0x8(%rax)
testq %rbx, %rbx
je 0x1c455ea
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/llvm/ADT/FunctionExtras.h
|
llvm::unique_function<void (llvm::StringRef, llvm::PreservedAnalyses const&)>& llvm::SmallVectorTemplateBase<llvm::unique_function<void (llvm::StringRef, llvm::PreservedAnalyses const&)>, false>::growAndEmplaceBack<llvm::ChangeReporter<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::registerRequiredCallbacks(llvm::PassInstrumentationCallbacks&)::'lambda'(llvm::StringRef, llvm::PreservedAnalyses const&)>(llvm::ChangeReporter<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::registerRequiredCallbacks(llvm::PassInstrumentationCallbacks&)::'lambda'(llvm::StringRef, llvm::PreservedAnalyses const&)&&)
|
T &growAndEmplaceBack(ArgTypes &&... Args) {
// Grow manually in case one of Args is an internal reference.
size_t NewCapacity;
T *NewElts = mallocForGrow(0, NewCapacity);
::new ((void *)(NewElts + this->size())) T(std::forward<ArgTypes>(Args)...);
moveElementsForGrow(NewElts);
takeAllocationForGrow(NewElts, NewCapacity);
this->set_size(this->size() + 1);
return this->back();
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %rsp, %r8
movl $0x20, %ecx
movq %r15, %rsi
xorl %edx, %edx
callq 0x2b4ec3c
movq %rax, %r14
movl 0x8(%rbx), %ebp
shlq $0x5, %rbp
movq (%r13), %r13
movq $0x0, 0x18(%rax,%rbp)
movl $0x8, %r12d
movl $0x8, %edi
movl $0x8, %esi
callq 0x2b410ec
movq %rax, (%r14,%rbp)
movq %r12, 0x8(%r14,%rbp)
movq %r12, 0x10(%r14,%rbp)
movq %r13, (%rax)
leaq 0x3cc12f9(%rip), %rax # 0x5906ab8
movq %rax, 0x18(%r14,%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1c3d75c
movq %rsp, %rax
movq (%rax), %r12
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x1c457e2
callq 0x780910
movq %r14, (%rbx)
movl %r12d, 0xc(%rbx)
movl 0x8(%rbx), %eax
incl %eax
movl %eax, 0x8(%rbx)
shlq $0x5, %rax
addq %r14, %rax
addq $-0x20, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/llvm/ADT/SmallVector.h
|
std::pair<llvm::StringMapIterator<llvm::FuncDataT<llvm::EmptyData>>, bool> llvm::StringMap<llvm::FuncDataT<llvm::EmptyData>, llvm::MallocAllocator>::try_emplace_with_hash<llvm::FuncDataT<llvm::EmptyData>>(llvm::StringRef, unsigned int, llvm::FuncDataT<llvm::EmptyData>&&)
|
std::pair<iterator, bool> try_emplace_with_hash(StringRef Key,
uint32_t FullHashValue,
ArgsTy &&...Args) {
unsigned BucketNo = LookupBucketFor(Key, FullHashValue);
StringMapEntryBase *&Bucket = TheTable[BucketNo];
if (Bucket && Bucket != getTombstoneVal())
return std::make_pair(iterator(TheTable + BucketNo, false),
false); // Already exists in map.
if (Bucket == getTombstoneVal())
--NumTombstones;
Bucket =
MapEntryTy::create(Key, getAllocator(), std::forward<ArgsTy>(Args)...);
++NumItems;
assert(NumItems + NumTombstones <= NumBuckets);
BucketNo = RehashTable(BucketNo);
return std::make_pair(iterator(TheTable + BucketNo, false), true);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
callq 0x2b56116
movl %eax, %ebp
movq (%r14), %rax
movl %ebp, %ecx
leaq (%rax,%rcx,8), %rbx
movq (%rbx), %rax
cmpq $-0x8, %rax
je 0x1c4679f
testq %rax, %rax
je 0x1c467a3
jmp 0x1c4678d
addq $0x8, %rbx
movq (%rbx), %rax
testq %rax, %rax
je 0x1c46789
cmpq $-0x8, %rax
je 0x1c46789
xorl %edx, %edx
jmp 0x1c467e4
decl 0x10(%r14)
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x1c467f6
movq %rax, (%rbx)
incl 0xc(%r14)
movq %r14, %rdi
movl %ebp, %esi
callq 0x2b5638e
movl %eax, %ebx
shlq $0x3, %rbx
addq (%r14), %rbx
movq (%rbx), %rax
testq %rax, %rax
je 0x1c467dc
cmpq $-0x8, %rax
jne 0x1c467e2
addq $0x8, %rbx
jmp 0x1c467ce
movb $0x1, %dl
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/llvm/ADT/StringMap.h
|
llvm::funcReturnsFirstArgOfCall(llvm::CallInst const&)
|
inline const ParentTy *getNodeBaseParent() const { return Parent; }
|
movq 0x28(%rdi), %rax
movq 0x30(%rax), %rcx
leaq -0x18(%rcx), %rax
testq %rcx, %rcx
cmoveq %rcx, %rax
movzbl (%rax), %edx
addl $-0x1e, %edx
xorl %ecx, %ecx
cmpl $0xb, %edx
cmovaeq %rcx, %rax
cmpb $0x1e, (%rax)
jne 0x1c481f7
movl 0x4(%rax), %ecx
andq $0x7ffffff, %rcx # imm = 0x7FFFFFF
je 0x1c481f5
shll $0x5, %ecx
subq %rcx, %rax
movq (%rax), %rcx
jmp 0x1c481f7
xorl %ecx, %ecx
testq %rcx, %rcx
je 0x1c4820c
movl 0x4(%rdi), %eax
shll $0x5, %eax
subq %rax, %rdi
cmpq (%rdi), %rcx
sete %al
retq
xorl %eax, %eax
retq
|
/llvm/ADT/ilist_node_base.h
|
llvm::cl::opt<llvm::cl::boolOrDefault, false, llvm::cl::parser<llvm::cl::boolOrDefault>>::opt<char [25], llvm::cl::OptionHidden>(char const (&) [25], llvm::cl::OptionHidden const&)
|
explicit opt(const Mods &... Ms)
: Option(llvm::cl::Optional, NotHidden), Parser(*this) {
apply(this, Ms...);
done();
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
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 0x3cae8f7(%rip), %rax # 0x58f7968
addq $0x10, %rax
movq %rax, 0x88(%rbx)
leaq 0x3b0db45(%rip), %rax # 0x5756bc8
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x3cae9c7(%rip), %rax # 0x58f7a58
addq $0x10, %rax
movq %rax, 0x98(%rbx)
movups %xmm0, 0xa0(%rbx)
leaq -0x132d394(%rip), %rax # 0x91bd16
movq %rax, 0xb8(%rbx)
leaq -0x132d3a0(%rip), %rax # 0x91bd18
movq %rax, 0xb0(%rbx)
movq %r15, %rdi
callq 0x7802c0
movq %rbx, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x2b1f336
movl (%r14), %eax
movzwl 0xa(%rbx), %ecx
shll $0x5, %eax
andl $0x60, %eax
andl $-0x61, %ecx
orl %eax, %ecx
movw %cx, 0xa(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2b1e814
|
/llvm/Support/CommandLine.h
|
bool llvm::DenseMapBase<llvm::DenseMap<llvm::Instruction const*, llvm::SmallVector<std::pair<llvm::VariableID, llvm::at::AssignmentInfo>, 1u>, llvm::DenseMapInfo<llvm::Instruction const*, void>, llvm::detail::DenseMapPair<llvm::Instruction const*, llvm::SmallVector<std::pair<llvm::VariableID, llvm::at::AssignmentInfo>, 1u>>>, llvm::Instruction const*, llvm::SmallVector<std::pair<llvm::VariableID, llvm::at::AssignmentInfo>, 1u>, llvm::DenseMapInfo<llvm::Instruction const*, void>, llvm::detail::DenseMapPair<llvm::Instruction const*, llvm::SmallVector<std::pair<llvm::VariableID, llvm::at::AssignmentInfo>, 1u>>>::LookupBucketFor<llvm::Instruction const*>(llvm::Instruction const* const&, llvm::detail::DenseMapPair<llvm::Instruction const*, llvm::SmallVector<std::pair<llvm::VariableID, llvm::at::AssignmentInfo>, 1u>> const*&) const
|
unsigned getNumBuckets() const {
return NumBuckets;
}
|
movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x1c513b1
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 $0x6, %rbx
leaq (%rdi,%rbx), %r11
movq (%rdi,%rbx), %rbx
cmpq %rbx, (%rsi)
jne 0x1c51378
movq %r11, (%rdx)
movb $0x1, %al
xorl %r11d, %r11d
testb %r11b, %r11b
jne 0x1c51355
jmp 0x1c513ae
cmpq $-0x1000, %rbx # imm = 0xF000
jne 0x1c51392
testq %r9, %r9
cmovneq %r9, %r11
movq %r11, (%rdx)
xorl %r11d, %r11d
xorl %eax, %eax
jmp 0x1c51371
xorq $-0x2000, %rbx # imm = 0xE000
orq %r9, %rbx
cmoveq %r11, %r9
addl %r10d, %r8d
incl %r10d
andl %ecx, %r8d
movb $0x1, %r11b
jmp 0x1c51371
popq %rbx
jmp 0x1c513ba
movq $0x0, (%rdx)
xorl %eax, %eax
andb $0x1, %al
retq
nop
|
/llvm/ADT/DenseMap.h
|
llvm::DenseMapBase<llvm::DenseMap<llvm::Instruction const*, llvm::SmallVector<std::pair<llvm::VariableID, llvm::at::AssignmentInfo>, 1u>, llvm::DenseMapInfo<llvm::Instruction const*, void>, llvm::detail::DenseMapPair<llvm::Instruction const*, llvm::SmallVector<std::pair<llvm::VariableID, llvm::at::AssignmentInfo>, 1u>>>, llvm::Instruction const*, llvm::SmallVector<std::pair<llvm::VariableID, llvm::at::AssignmentInfo>, 1u>, llvm::DenseMapInfo<llvm::Instruction const*, void>, llvm::detail::DenseMapPair<llvm::Instruction const*, llvm::SmallVector<std::pair<llvm::VariableID, llvm::at::AssignmentInfo>, 1u>>>::moveFromOldBuckets(llvm::detail::DenseMapPair<llvm::Instruction const*, llvm::SmallVector<std::pair<llvm::VariableID, llvm::at::AssignmentInfo>, 1u>>*, llvm::detail::DenseMapPair<llvm::Instruction const*, llvm::SmallVector<std::pair<llvm::VariableID, llvm::at::AssignmentInfo>, 1u>>*)
|
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), %ecx
testq %rcx, %rcx
je 0x1c51651
movq (%r15), %rax
movabsq $0x3ffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFF
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 $0x40, %rax
xorl %edx, %edx
movdqa 0xf63a46(%rip), %xmm1 # 0x2bb5020
movdqa 0xf63a4e(%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 0x1c5162e
movq $-0x1000, -0x40(%rax) # imm = 0xF000
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %esi
testb $0x1, %sil
je 0x1c51644
movq $-0x1000, (%rax) # imm = 0xF000
addq $0x2, %rdx
subq $-0x80, %rax
cmpq %rdx, %rcx
jne 0x1c515ea
cmpq %rbx, %r14
je 0x1c516ce
movl $0x1000, %r13d # imm = 0x1000
movq %rsp, %r12
movabsq $0x100000000, %rbp # imm = 0x100000000
movq (%r14), %rax
orq %r13, %rax
cmpq $-0x1000, %rax # imm = 0xF000
je 0x1c516c5
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x1c5132c
movq (%rsp), %rdi
movq (%r14), %rax
movq %rax, (%rdi)
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
movq %rbp, 0x10(%rdi)
cmpl $0x0, 0x10(%r14)
je 0x1c516af
addq $0x8, %rdi
leaq 0x8(%r14), %rsi
callq 0x1c516de
incl 0x8(%r15)
movq 0x8(%r14), %rdi
leaq 0x18(%r14), %rax
cmpq %rdi, %rax
je 0x1c516c5
callq 0x780910
addq $0x40, %r14
cmpq %rbx, %r14
jne 0x1c51669
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/llvm/ADT/DenseMap.h
|
llvm::SmallVectorImpl<std::pair<llvm::VariableID, llvm::at::AssignmentInfo>>::operator=(llvm::SmallVectorImpl<std::pair<llvm::VariableID, llvm::at::AssignmentInfo>>&&)
|
SmallVectorImpl<T> &SmallVectorImpl<T>::operator=(SmallVectorImpl<T> &&RHS) {
// Avoid self-assignment.
if (this == &RHS) return *this;
// If the RHS isn't small, clear this vector and then steal its buffer.
if (!RHS.isSmall()) {
this->assignRemote(std::move(RHS));
return *this;
}
// If we already have sufficient space, assign the common elements, then
// destroy any excess.
size_t RHSSize = RHS.size();
size_t CurSize = this->size();
if (CurSize >= RHSSize) {
// Assign common elements.
iterator NewEnd = this->begin();
if (RHSSize)
NewEnd = std::move(RHS.begin(), RHS.end(), NewEnd);
// Destroy excess elements and trim the bounds.
this->destroy_range(NewEnd, this->end());
this->set_size(RHSSize);
// Clear the RHS.
RHS.clear();
return *this;
}
// If we have to grow to have enough elements, destroy the current elements.
// This allows us to avoid copying them during the grow.
// FIXME: this may not actually make any sense if we can efficiently move
// elements.
if (this->capacity() < RHSSize) {
// Destroy current elements.
this->clear();
CurSize = 0;
this->grow(RHSSize);
} else if (CurSize) {
// Otherwise, use assignment for the already-constructed elements.
std::move(RHS.begin(), RHS.begin()+CurSize, this->begin());
}
// Move-construct the new elements in place.
this->uninitialized_move(RHS.begin()+CurSize, RHS.end(),
this->begin()+CurSize);
// Set end.
this->set_size(RHSSize);
RHS.clear();
return *this;
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x1c517e6
movq %rsi, %r14
movq (%rsi), %rax
leaq 0x10(%rsi), %rcx
cmpq %rcx, %rax
je 0x1c5170e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1c517f0
jmp 0x1c517e6
movl 0x8(%r14), %r15d
movl 0x8(%rbx), %ecx
cmpl %r15d, %ecx
jae 0x1c5173d
cmpl %r15d, 0xc(%rbx)
jae 0x1c51778
movl $0x0, 0x8(%rbx)
leaq 0x10(%rbx), %rsi
movl $0x28, %ecx
movq %rbx, %rdi
movq %r15, %rdx
callq 0x2b4ed86
jmp 0x1c517b1
testl %r15d, %r15d
je 0x1c517da
movq (%rbx), %rcx
leaq 0x1(%r15), %rdx
xorl %esi, %esi
movl (%rax,%rsi), %edi
movl %edi, (%rcx,%rsi)
movups 0x8(%rax,%rsi), %xmm0
movups 0x11(%rax,%rsi), %xmm1
movups %xmm0, 0x8(%rcx,%rsi)
movups %xmm1, 0x11(%rcx,%rsi)
decq %rdx
addq $0x28, %rsi
cmpq $0x1, %rdx
jg 0x1c5174f
jmp 0x1c517da
testq %rcx, %rcx
je 0x1c517b1
movq (%rbx), %rdx
leaq 0x1(%rcx), %rsi
xorl %edi, %edi
movl (%rax,%rdi), %r8d
movl %r8d, (%rdx,%rdi)
movups 0x8(%rax,%rdi), %xmm0
movups 0x11(%rax,%rdi), %xmm1
movups %xmm0, 0x8(%rdx,%rdi)
movups %xmm1, 0x11(%rdx,%rdi)
decq %rsi
addq $0x28, %rdi
cmpq $0x1, %rsi
jg 0x1c51786
jmp 0x1c517b3
xorl %ecx, %ecx
movl 0x8(%r14), %eax
subq %rcx, %rax
je 0x1c517da
shlq $0x3, %rcx
leaq (%rcx,%rcx,4), %rdi
movq (%r14), %rsi
addq %rdi, %rsi
addq (%rbx), %rdi
shlq $0x3, %rax
leaq (%rax,%rax,4), %rdx
callq 0x780890
movl %r15d, 0x8(%rbx)
movl $0x0, 0x8(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
|
/llvm/ADT/SmallVector.h
|
bool llvm::DenseMapBase<llvm::DenseMap<llvm::BasicBlock const*, llvm::DenseMap<unsigned int, llvm::IntervalMap<unsigned int, unsigned int, 16u, llvm::IntervalMapHalfOpenInfo<unsigned int>>, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::IntervalMap<unsigned int, unsigned int, 16u, llvm::IntervalMapHalfOpenInfo<unsigned int>>>>, llvm::DenseMapInfo<llvm::BasicBlock const*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock const*, llvm::DenseMap<unsigned int, llvm::IntervalMap<unsigned int, unsigned int, 16u, llvm::IntervalMapHalfOpenInfo<unsigned int>>, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::IntervalMap<unsigned int, unsigned int, 16u, llvm::IntervalMapHalfOpenInfo<unsigned int>>>>>>, llvm::BasicBlock const*, llvm::DenseMap<unsigned int, llvm::IntervalMap<unsigned int, unsigned int, 16u, llvm::IntervalMapHalfOpenInfo<unsigned int>>, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::IntervalMap<unsigned int, unsigned int, 16u, llvm::IntervalMapHalfOpenInfo<unsigned int>>>>, llvm::DenseMapInfo<llvm::BasicBlock const*, void>, llvm::detail::DenseMapPair<llvm::BasicBlock const*, llvm::DenseMap<unsigned int, llvm::IntervalMap<unsigned int, unsigned int, 16u, llvm::IntervalMapHalfOpenInfo<unsigned int>>, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::IntervalMap<unsigned int, unsigned int, 16u, llvm::IntervalMapHalfOpenInfo<unsigned int>>>>>>::LookupBucketFor<llvm::BasicBlock const*>(llvm::BasicBlock const* const&, llvm::detail::DenseMapPair<llvm::BasicBlock const*, llvm::DenseMap<unsigned int, llvm::IntervalMap<unsigned int, unsigned int, 16u, llvm::IntervalMapHalfOpenInfo<unsigned int>>, llvm::DenseMapInfo<unsigned int, void>, llvm::detail::DenseMapPair<unsigned int, llvm::IntervalMap<unsigned int, unsigned int, 16u, llvm::IntervalMapHalfOpenInfo<unsigned int>>>>> const*&) const
|
unsigned getNumBuckets() const {
return NumBuckets;
}
|
movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x1c57365
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 $0x5, %rbx
leaq (%rdi,%rbx), %r11
movq (%rdi,%rbx), %rbx
cmpq %rbx, (%rsi)
jne 0x1c5732c
movq %r11, (%rdx)
movb $0x1, %al
xorl %r11d, %r11d
testb %r11b, %r11b
jne 0x1c57309
jmp 0x1c57362
cmpq $-0x1000, %rbx # imm = 0xF000
jne 0x1c57346
testq %r9, %r9
cmovneq %r9, %r11
movq %r11, (%rdx)
xorl %r11d, %r11d
xorl %eax, %eax
jmp 0x1c57325
xorq $-0x2000, %rbx # imm = 0xE000
orq %r9, %rbx
cmoveq %r11, %r9
addl %r10d, %r8d
incl %r10d
andl %ecx, %r8d
movb $0x1, %r11b
jmp 0x1c57325
popq %rbx
jmp 0x1c5736e
movq $0x0, (%rdx)
xorl %eax, %eax
andb $0x1, %al
retq
nop
|
/llvm/ADT/DenseMap.h
|
FunctionVarLocsBuilder::getWedge(llvm::PointerUnion<llvm::Instruction const*, llvm::DbgRecord const*>) const
|
const SmallVectorImpl<VarLocInfo> *getWedge(VarLocInsertPt Before) const {
auto R = VarLocsBeforeInst.find(Before);
if (R == VarLocsBeforeInst.end())
return nullptr;
return &R->second;
}
|
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rcx
leaq 0x8(%rsp), %r8
movq %rsi, (%r8)
leaq 0x48(%rdi), %rsi
xorl %ebx, %ebx
movq %rcx, %rax
xorl %edx, %edx
divq 0x50(%rdi)
movq %rsi, %rdi
movq %rdx, %rsi
movq %r8, %rdx
callq 0x1c569a4
testq %rax, %rax
je 0x1c5979b
movq (%rax), %rbx
leaq 0x10(%rbx), %rax
testq %rbx, %rbx
cmoveq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
|
/CodeGen/AssignmentTrackingAnalysis.cpp
|
(anonymous namespace)::AtomicExpandImpl::expandAtomicCASToLibcall(llvm::AtomicCmpXchgInst*)
|
void AtomicExpandImpl::expandAtomicCASToLibcall(AtomicCmpXchgInst *I) {
static const RTLIB::Libcall Libcalls[6] = {
RTLIB::ATOMIC_COMPARE_EXCHANGE, RTLIB::ATOMIC_COMPARE_EXCHANGE_1,
RTLIB::ATOMIC_COMPARE_EXCHANGE_2, RTLIB::ATOMIC_COMPARE_EXCHANGE_4,
RTLIB::ATOMIC_COMPARE_EXCHANGE_8, RTLIB::ATOMIC_COMPARE_EXCHANGE_16};
unsigned Size = getAtomicOpSize(I);
bool expanded = expandAtomicOpToLibcall(
I, Size, I->getAlign(), I->getPointerOperand(), I->getNewValOperand(),
I->getCompareOperand(), I->getSuccessOrdering(), I->getFailureOrdering(),
Libcalls);
if (!expanded)
report_fatal_error("expandAtomicOpToLibcall shouldn't fail for CAS");
}
|
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x1c6223f
movzwl 0x2(%rbx), %ecx
movl %ecx, %edx
shrl $0x8, %edx
andb $0x3f, %dl
movq -0x20(%rbx), %r9
movq -0x60(%rbx), %r8
movq -0x40(%rbx), %rsi
movl %ecx, %edi
shrl $0x2, %edi
andl $0x7, %edi
shrl $0x5, %ecx
andl $0x7, %ecx
leaq 0x32d91b8(%rip), %r10 # 0x4f3a140
movq %r10, 0x28(%rsp)
movq $0x6, 0x30(%rsp)
movups 0x28(%rsp), %xmm0
movups %xmm0, 0x18(%rsp)
movl %ecx, 0x10(%rsp)
movl %edi, 0x8(%rsp)
movq %rsi, (%rsp)
movzbl %dl, %ecx
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
callq 0x1c61728
testb %al, %al
je 0x1c60fc8
addq $0x38, %rsp
popq %rbx
popq %r14
retq
leaq 0x32d8df7(%rip), %rdi # 0x4f39dc6
movl $0x1, %esi
callq 0x2b31b17
nop
|
/CodeGen/AtomicExpandPass.cpp
|
llvm::BreakFalseDeps::processDefs(llvm::MachineInstr*)
|
void BreakFalseDeps::processDefs(MachineInstr *MI) {
assert(!MI->isDebugInstr() && "Won't process debug values");
const MCInstrDesc &MCID = MI->getDesc();
// Break dependence on undef uses. Do this before updating LiveRegs below.
// This can remove a false dependence with no additional instructions.
for (unsigned i = MCID.getNumDefs(), e = MCID.getNumOperands(); i != e; ++i) {
MachineOperand &MO = MI->getOperand(i);
if (!MO.isReg() || !MO.getReg() || !MO.isUse() || !MO.isUndef())
continue;
unsigned Pref = TII->getUndefRegClearance(*MI, i, TRI);
if (Pref) {
bool HadTrueDependency = pickBestRegisterForUndef(MI, i, Pref);
// We don't need to bother trying to break a dependency if this
// instruction has a true dependency on that register through another
// operand - we'll have to wait for it to be available regardless.
if (!HadTrueDependency && shouldBreakDependence(MI, i, Pref))
UndefReads.push_back(std::make_pair(MI, i));
}
}
// The code below allows the target to create a new instruction to break the
// dependence. That opposes the goal of minimizing size, so bail out now.
if (MF->getFunction().hasMinSize())
return;
for (unsigned i = 0,
e = MI->isVariadic() ? MI->getNumOperands() : MCID.getNumDefs();
i != e; ++i) {
MachineOperand &MO = MI->getOperand(i);
if (!MO.isReg() || !MO.getReg())
continue;
if (MO.isUse())
continue;
// Check clearance before partial register updates.
unsigned Pref = TII->getPartialRegUpdateClearance(*MI, i, TRI);
if (Pref && shouldBreakDependence(MI, i, Pref))
TII->breakPartialRegDependency(*MI, i, TRI);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rsi), %rax
movzbl 0x4(%rax), %ebp
movq %rax, 0x10(%rsp)
movzwl 0x2(%rax), %r15d
cmpl %r15d, %ebp
jne 0x1c657a2
movq 0x38(%r14), %rax
movq (%rax), %rdi
movl $0x11, %esi
callq 0x2a40a66
testb %al, %al
jne 0x1c6590a
movq 0x10(%rbx), %rax
testb $0x2, 0x10(%rax)
jne 0x1c65870
movq 0x10(%rsp), %rax
movzbl 0x4(%rax), %eax
jmp 0x1c6587d
leaq 0x190(%r14), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rbx), %rax
movl %ebp, %r12d
shlq $0x5, %r12
movl (%rax,%r12), %ecx
testb %cl, %cl
je 0x1c657ca
incl %ebp
cmpl %ebp, %r15d
jne 0x1c657ae
jmp 0x1c6576d
andl $0x11000000, %ecx # imm = 0x11000000
cmpl $0x10000000, %ecx # imm = 0x10000000
jne 0x1c657c1
addq %r12, %rax
cmpl $0x0, 0x4(%rax)
je 0x1c657c1
movq 0x40(%r14), %rdi
movq 0x48(%r14), %rcx
movq (%rdi), %rax
movq %rbx, %rsi
movl %ebp, %edx
callq *0x458(%rax)
testl %eax, %eax
je 0x1c657c1
movl %eax, %r13d
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movl %eax, %ecx
callq 0x1c654b4
testb %al, %al
jne 0x1c657c1
movq 0x20(%rbx), %rax
movl 0x4(%rax,%r12), %edx
movq 0x1e8(%r14), %rdi
movq %rbx, %rsi
callq 0x1df9b0c
cmpl %r13d, %eax
jae 0x1c657c1
movq %rbx, 0x18(%rsp)
movl %ebp, 0x20(%rsp)
movq 0x198(%r14), %rsi
cmpq 0x1a0(%r14), %rsi
je 0x1c6585c
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x198(%r14)
jmp 0x1c657c1
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0xef1276
jmp 0x1c657c1
movzwl 0x28(%rbx), %ecx
movzbl 0x2a(%rbx), %eax
shll $0x10, %eax
orl %ecx, %eax
testl %eax, %eax
je 0x1c6590a
movl %eax, %r12d
movl $0x4, %r13d
xorl %r15d, %r15d
movq 0x20(%rbx), %rax
movl -0x4(%rax,%r13), %ecx
testb %cl, %cl
je 0x1c658ac
incq %r15
addq $0x20, %r13
cmpq %r15, %r12
jne 0x1c65891
jmp 0x1c6590a
btl $0x18, %ecx
jae 0x1c6589e
cmpl $0x0, (%rax,%r13)
je 0x1c6589e
movq 0x40(%r14), %rdi
movq 0x48(%r14), %rcx
movq (%rdi), %rax
movq %rbx, %rsi
movl %r15d, %edx
callq *0x450(%rax)
testl %eax, %eax
je 0x1c6589e
movl %eax, %ebp
movq 0x20(%rbx), %rax
movl (%rax,%r13), %edx
movq 0x1e8(%r14), %rdi
movq %rbx, %rsi
callq 0x1df9b0c
cmpl %ebp, %eax
jae 0x1c6589e
movq 0x40(%r14), %rdi
movq 0x48(%r14), %rcx
movq (%rdi), %rax
movq %rbx, %rsi
movl %r15d, %edx
callq *0x460(%rax)
jmp 0x1c6589e
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/CodeGen/BreakFalseDeps.cpp
|
llvm::DenseMap<llvm::UniqueBBID, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::UniqueBBID, void>, llvm::detail::DenseSetPair<llvm::UniqueBBID>>::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 0x1c68dd8
decl %ecx
je 0x1c68ddc
bsrl %ecx, %edx
xorl $0x1f, %edx
jmp 0x1c68de1
xorl %ebp, %ebp
jmp 0x1c68df7
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 0x1c68e22
movq $0x0, 0x8(%rbx)
testq %rax, %rax
je 0x1c68e46
movq (%rbx), %rdi
shlq $0x3, %rax
movl $0xff, %esi
movq %rax, %rdx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x780240
movq (%rbx), %rdi
shlq $0x3, %rax
movl $0x4, %edx
movq %rax, %rsi
callq 0x2b410f1
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1c685fe
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
|
/llvm/ADT/DenseMap.h
|
llvm::SmallVectorImpl<std::pair<llvm::AssertingVH<llvm::GetElementPtrInst>, long>>::operator=(llvm::SmallVectorImpl<std::pair<llvm::AssertingVH<llvm::GetElementPtrInst>, long>>&&)
|
SmallVectorImpl<T> &SmallVectorImpl<T>::operator=(SmallVectorImpl<T> &&RHS) {
// Avoid self-assignment.
if (this == &RHS) return *this;
// If the RHS isn't small, clear this vector and then steal its buffer.
if (!RHS.isSmall()) {
this->assignRemote(std::move(RHS));
return *this;
}
// If we already have sufficient space, assign the common elements, then
// destroy any excess.
size_t RHSSize = RHS.size();
size_t CurSize = this->size();
if (CurSize >= RHSSize) {
// Assign common elements.
iterator NewEnd = this->begin();
if (RHSSize)
NewEnd = std::move(RHS.begin(), RHS.end(), NewEnd);
// Destroy excess elements and trim the bounds.
this->destroy_range(NewEnd, this->end());
this->set_size(RHSSize);
// Clear the RHS.
RHS.clear();
return *this;
}
// If we have to grow to have enough elements, destroy the current elements.
// This allows us to avoid copying them during the grow.
// FIXME: this may not actually make any sense if we can efficiently move
// elements.
if (this->capacity() < RHSSize) {
// Destroy current elements.
this->clear();
CurSize = 0;
this->grow(RHSSize);
} else if (CurSize) {
// Otherwise, use assignment for the already-constructed elements.
std::move(RHS.begin(), RHS.begin()+CurSize, this->begin());
}
// Move-construct the new elements in place.
this->uninitialized_move(RHS.begin()+CurSize, RHS.end(),
this->begin()+CurSize);
// Set end.
this->set_size(RHSSize);
RHS.clear();
return *this;
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x1c7fe4e
movq %rsi, %r14
movq (%rsi), %rax
leaq 0x10(%rsi), %rcx
cmpq %rcx, %rax
je 0x1c7fd94
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1c7fe58
jmp 0x1c7fe4e
movl 0x8(%r14), %r15d
movl 0x8(%rbx), %edi
cmpl %r15d, %edi
jae 0x1c7fdc3
cmpl %r15d, 0xc(%rbx)
jae 0x1c7fdf2
movl $0x0, 0x8(%rbx)
leaq 0x10(%rbx), %rsi
movl $0x10, %ecx
movq %rbx, %rdi
movq %r15, %rdx
callq 0x2b4ed86
jmp 0x1c7fe21
testl %r15d, %r15d
je 0x1c7fe42
movq (%rbx), %rcx
leaq 0x1(%r15), %rdx
xorl %esi, %esi
movq (%rax,%rsi), %rdi
movq %rdi, (%rcx,%rsi)
movq 0x8(%rax,%rsi), %rdi
movq %rdi, 0x8(%rcx,%rsi)
decq %rdx
addq $0x10, %rsi
cmpq $0x1, %rdx
jg 0x1c7fdd1
jmp 0x1c7fe42
testq %rdi, %rdi
je 0x1c7fe21
movq (%rbx), %rcx
leaq 0x1(%rdi), %rdx
xorl %esi, %esi
movq (%rax,%rsi), %r8
movq %r8, (%rcx,%rsi)
movq 0x8(%rax,%rsi), %r8
movq %r8, 0x8(%rcx,%rsi)
decq %rdx
addq $0x10, %rsi
cmpq $0x1, %rdx
jg 0x1c7fe00
jmp 0x1c7fe23
xorl %edi, %edi
movl 0x8(%r14), %edx
subq %rdi, %rdx
je 0x1c7fe42
shlq $0x4, %rdi
movq (%r14), %rsi
addq %rdi, %rsi
addq (%rbx), %rdi
shlq $0x4, %rdx
callq 0x780890
movl %r15d, 0x8(%rbx)
movl $0x0, 0x8(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
|
/llvm/ADT/SmallVector.h
|
bool llvm::DenseMapBase<llvm::DenseMap<llvm::Instruction*, llvm::PointerIntPair<llvm::Type*, 2u, (anonymous namespace)::ExtType, llvm::PointerLikeTypeTraits<llvm::Type*>, llvm::PointerIntPairInfo<llvm::Type*, 2u, llvm::PointerLikeTypeTraits<llvm::Type*>>>, llvm::DenseMapInfo<llvm::Instruction*, void>, llvm::detail::DenseMapPair<llvm::Instruction*, llvm::PointerIntPair<llvm::Type*, 2u, (anonymous namespace)::ExtType, llvm::PointerLikeTypeTraits<llvm::Type*>, llvm::PointerIntPairInfo<llvm::Type*, 2u, llvm::PointerLikeTypeTraits<llvm::Type*>>>>>, llvm::Instruction*, llvm::PointerIntPair<llvm::Type*, 2u, (anonymous namespace)::ExtType, llvm::PointerLikeTypeTraits<llvm::Type*>, llvm::PointerIntPairInfo<llvm::Type*, 2u, llvm::PointerLikeTypeTraits<llvm::Type*>>>, llvm::DenseMapInfo<llvm::Instruction*, void>, llvm::detail::DenseMapPair<llvm::Instruction*, llvm::PointerIntPair<llvm::Type*, 2u, (anonymous namespace)::ExtType, llvm::PointerLikeTypeTraits<llvm::Type*>, llvm::PointerIntPairInfo<llvm::Type*, 2u, llvm::PointerLikeTypeTraits<llvm::Type*>>>>>::LookupBucketFor<llvm::Instruction const*>(llvm::Instruction const* const&, llvm::detail::DenseMapPair<llvm::Instruction*, llvm::PointerIntPair<llvm::Type*, 2u, (anonymous namespace)::ExtType, llvm::PointerLikeTypeTraits<llvm::Type*>, llvm::PointerIntPairInfo<llvm::Type*, 2u, llvm::PointerLikeTypeTraits<llvm::Type*>>>> const*&) const
|
unsigned getNumBuckets() const {
return NumBuckets;
}
|
movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x1c80e57
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 0x1c80e1e
movq %r11, (%rdx)
movb $0x1, %al
xorl %r11d, %r11d
testb %r11b, %r11b
jne 0x1c80dfb
jmp 0x1c80e54
cmpq $-0x1000, %rbx # imm = 0xF000
jne 0x1c80e38
testq %r9, %r9
cmovneq %r9, %r11
movq %r11, (%rdx)
xorl %r11d, %r11d
xorl %eax, %eax
jmp 0x1c80e17
xorq $-0x2000, %rbx # imm = 0xE000
orq %r9, %rbx
cmoveq %r11, %r9
addl %r10d, %r8d
incl %r10d
andl %ecx, %r8d
movb $0x1, %r11b
jmp 0x1c80e17
popq %rbx
jmp 0x1c80e60
movq $0x0, (%rdx)
xorl %eax, %eax
andb $0x1, %al
retq
nop
|
/llvm/ADT/DenseMap.h
|
llvm::TargetLoweringBase::isExtLoad(llvm::LoadInst const*, llvm::Instruction const*, llvm::DataLayout const&) const
|
bool isExtLoad(const LoadInst *Load, const Instruction *Ext,
const DataLayout &DL) const {
EVT VT = getValueType(DL, Ext->getType());
EVT LoadVT = getValueType(DL, Load->getType());
// If the load has other users and the truncate is not free, the ext
// probably isn't free.
if (!Load->hasOneUse() && (isTypeLegal(LoadVT) || !isTypeLegal(VT)) &&
!isTruncateFree(Ext->getType(), Load->getType()))
return false;
// Check whether the target supports casts folded into loads.
unsigned LType;
if (isa<ZExtInst>(Ext))
LType = ISD::ZEXTLOAD;
else {
assert(isa<SExtInst>(Ext) && "Unexpected ext type!");
LType = ISD::SEXTLOAD;
}
return isLoadExtLegal(LType, VT, LoadVT);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq 0x8(%rdx), %rdx
movq %rcx, %rsi
xorl %ecx, %ecx
callq 0x920138
movl %eax, %ebp
movq 0x8(%r12), %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x920138
movl %eax, %r15d
movq 0x10(%r12), %rax
testq %rax, %rax
je 0x1c820fe
cmpq $0x0, 0x8(%rax)
je 0x1c82146
testb %r15b, %r15b
je 0x1c8211c
movzbl %r15b, %eax
cmpq $0x0, 0x68(%rbx,%rax,8)
setne %al
testb %bpl, %bpl
sete %cl
orb %al, %cl
je 0x1c82121
jmp 0x1c8212d
testb %bpl, %bpl
je 0x1c8212d
movzbl %bpl, %eax
cmpq $0x0, 0x68(%rbx,%rax,8)
jne 0x1c82146
movq 0x8(%r14), %rsi
movq 0x8(%r12), %rdx
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x548(%rax)
testb %al, %al
je 0x1c82156
testb %bpl, %bpl
sete %al
testb %r15b, %r15b
sete %cl
orb %al, %cl
je 0x1c8215a
xorl %eax, %eax
jmp 0x1c8218a
movzbl %bpl, %eax
imulq $0x192, %rax, %rax # imm = 0x192
addq %rax, %rbx
cmpb $0x44, (%r14)
movzbl %r15b, %eax
movzwl 0x18db8(%rbx,%rax,2), %eax
movl $0xf000, %ecx # imm = 0xF000
movl $0xf00, %edx # imm = 0xF00
cmovel %ecx, %edx
testl %eax, %edx
sete %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
|
/llvm/CodeGen/TargetLowering.h
|
std::pair<std::pair<std::pair<unsigned int, unsigned int>, llvm::GCRelocateInst*>*, bool> llvm::MapVector<std::pair<unsigned int, unsigned int>, llvm::GCRelocateInst*, llvm::DenseMap<std::pair<unsigned int, unsigned int>, unsigned int, llvm::DenseMapInfo<std::pair<unsigned int, unsigned int>, void>, llvm::detail::DenseMapPair<std::pair<unsigned int, unsigned int>, unsigned int>>, llvm::SmallVector<std::pair<std::pair<unsigned int, unsigned int>, llvm::GCRelocateInst*>, 0u>>::try_emplace<llvm::GCRelocateInst*>(std::pair<unsigned int, unsigned int>&&, llvm::GCRelocateInst*&&)
|
std::pair<iterator, bool> try_emplace(KeyT &&Key, Ts &&...Args) {
auto [It, Inserted] = Map.insert(std::make_pair(Key, 0));
if (Inserted) {
It->second = Vector.size();
Vector.emplace_back(std::piecewise_construct,
std::forward_as_tuple(std::move(Key)),
std::forward_as_tuple(std::forward<Ts>(Args)...));
return std::make_pair(std::prev(end()), true);
}
return std::make_pair(begin() + It->second, false);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x10(%rsp), %rcx
movq %rax, -0x8(%rcx)
movl $0x0, (%rcx)
leaq 0x20(%rsp), %r12
leaq 0x8(%rsp), %rdx
movq %r12, %rdi
movq %rbx, %rsi
callq 0xf17a36
leaq 0x18(%rbx), %rdi
cmpb $0x1, 0x10(%r12)
jne 0x1c8b63c
movl 0x20(%rbx), %eax
movq 0x20(%rsp), %rcx
movl %eax, 0x8(%rcx)
leaq 0x8(%rsp), %rdx
movq %r15, (%rdx)
leaq 0x18(%rsp), %rcx
movq %r14, (%rcx)
leaq 0xf646ef(%rip), %rsi # 0x2befd10
callq 0x1c8b65a
movq 0x18(%rbx), %rax
movl 0x20(%rbx), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
addq $-0x10, %rax
movb $0x1, %dl
jmp 0x1c8b64d
movq 0x20(%rsp), %rax
movl 0x8(%rax), %eax
shlq $0x4, %rax
addq (%rdi), %rax
xorl %edx, %edx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/llvm/ADT/MapVector.h
|
llvm::SmallVectorTemplateBase<std::pair<std::pair<unsigned int, unsigned int>, llvm::GCRelocateInst*>, true>::push_back(std::pair<std::pair<unsigned int, unsigned int>, llvm::GCRelocateInst*>)
|
void push_back(ValueParamT Elt) {
const T *EltPtr = reserveForParamAndGetAddress(Elt);
memcpy(reinterpret_cast<void *>(this->end()), EltPtr, sizeof(T));
this->set_size(this->size() + 1);
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl 0x8(%rdi), %edx
cmpl 0xc(%rdi), %edx
jae 0x1c8b6ea
movq (%r14), %rax
movl 0x8(%r14), %ecx
shlq $0x4, %rcx
movq %r15, (%rax,%rcx)
movq %rbx, 0x8(%rax,%rcx)
incl 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
incq %rdx
leaq 0x10(%r14), %rsi
movl $0x10, %ecx
movq %r14, %rdi
callq 0x2b4ed86
jmp 0x1c8b6cc
|
/llvm/ADT/SmallVector.h
|
llvm::cl::opt<llvm::CodeGenFileType, false, llvm::cl::parser<llvm::CodeGenFileType>>::handleOccurrence(unsigned int, llvm::StringRef, llvm::StringRef)
|
bool handleOccurrence(unsigned pos, StringRef ArgName,
StringRef Arg) override {
typename ParserClass::parser_data_type Val =
typename ParserClass::parser_data_type();
if (Parser.parse(*this, ArgName, Arg, Val))
return true; // Parse error!
this->setValue(Val);
this->setPosition(pos);
Callback(Val);
return false;
}
|
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xc(%rsp), %rax
movl $0x0, (%rax)
addq $0x98, %rdi
movq %rax, (%rsp)
movq %rbx, %rsi
callq 0x1c91a36
movl %eax, %r14d
testb %al, %al
jne 0x1c91880
movl 0xc(%rsp), %eax
movl %eax, 0x80(%rbx)
movw %bp, 0xc(%rbx)
cmpq $0x0, 0x248(%rbx)
je 0x1c9188c
leaq 0x238(%rbx), %rdi
leaq 0xc(%rsp), %rsi
callq *0x250(%rbx)
movl %r14d, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x7807b0
nop
|
/llvm/Support/CommandLine.h
|
llvm::cl::opt<llvm::FramePointerKind, false, llvm::cl::parser<llvm::FramePointerKind>>::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 0x1c91ca0
subq $0x18, %rsp
leaq 0x98(%rsi), %rdi
movl 0x80(%rsi), %eax
leaq 0x88(%rsi), %rcx
leaq 0x3bf715d(%rip), %r9 # 0x5888de0
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 0x1c91c64
movl 0x80(%rsi), %eax
cmpl %eax, 0x90(%rsi)
jne 0x1c91c64
retq
|
/llvm/Support/CommandLine.h
|
llvm::cl::parser<llvm::DebuggerKind>::parse(llvm::cl::Option&, llvm::StringRef, llvm::StringRef, llvm::DebuggerKind&)
|
bool parse(Option &O, StringRef ArgName, StringRef Arg, DataType &V) {
StringRef ArgVal;
if (Owner.hasArgStr())
ArgVal = Arg;
else
ArgVal = ArgName;
for (size_t i = 0, e = Values.size(); i != e; ++i)
if (Values[i].Name == ArgVal) {
V = Values[i].V.getValue();
return false;
}
return O.error("Cannot find option named '" + ArgVal + "'!");
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq 0x8(%rdi), %rax
cmpq $0x0, 0x18(%rax)
cmovneq %r8, %r15
cmovneq %r9, %r14
movl 0x18(%rdi), %eax
testq %rax, %rax
je 0x1c93095
movq 0x10(%rdi), %r13
shlq $0x4, %rax
leaq (%rax,%rax,2), %r12
xorl %ebp, %ebp
movq 0x8(%r13,%rbp), %rdx
cmpq %r14, %rdx
jne 0x1c9308c
testq %rdx, %rdx
je 0x1c930e5
movq (%r13,%rbp), %rdi
movq %r15, %rsi
callq 0x780c70
testl %eax, %eax
je 0x1c930e5
addq $0x30, %rbp
cmpq %rbp, %r12
jne 0x1c9306c
leaq 0x8(%rsp), %rax
movw $0x503, 0x20(%rax) # imm = 0x503
leaq 0xf23218(%rip), %rcx # 0x2bb62bf
movq %rcx, (%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
leaq 0x30(%rsp), %r14
movq %rax, (%r14)
leaq 0x1b20799(%rip), %rax # 0x37b385a
movq %rax, 0x10(%r14)
movw $0x302, 0x20(%r14) # imm = 0x302
callq 0x2b7e53f
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %rax, %r8
callq 0x2b23e3c
jmp 0x1c930f6
movl 0x28(%r13,%rbp), %eax
movq 0x90(%rsp), %rcx
movl %eax, (%rcx)
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/llvm/Support/CommandLine.h
|
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> llvm::WriteGraph<llvm::EdgeBundles>(llvm::EdgeBundles const&, llvm::Twine const&, bool, llvm::Twine const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
|
std::string WriteGraph(const GraphType &G, const Twine &Name,
bool ShortNames = false,
const Twine &Title = "",
std::string Filename = "") {
int FD;
if (Filename.empty()) {
Filename = createGraphFilename(Name.str(), FD);
} else {
std::error_code EC = sys::fs::openFileForWrite(
Filename, FD, sys::fs::CD_CreateAlways, sys::fs::OF_Text);
// Writing over an existing file is not considered an error.
if (EC == std::errc::file_exists) {
errs() << "file exists, overwriting" << "\n";
} else if (EC) {
errs() << "error writing into file" << "\n";
return "";
} else {
errs() << "writing to the newly created file " << Filename << "\n";
}
}
raw_fd_ostream O(FD, /*shouldClose=*/ true);
if (FD == -1) {
errs() << "error opening file '" << Filename << "' for writing!\n";
return "";
}
llvm::WriteGraph(O, G, ShortNames, Title);
errs() << " done. \n";
return Filename;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r9, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0x0, 0x8(%r9)
je 0x1ca5107
leaq 0x48(%rsp), %r12
movw $0x104, 0x20(%r12) # imm = 0x104
movq %r14, (%r12)
leaq 0x4(%rsp), %rsi
movq %r12, %rdi
xorl %edx, %edx
movl $0x2, %ecx
movl $0x1, %r8d
movl $0x1b6, %r9d # imm = 0x1B6
callq 0x2b8ac52
movl %eax, %ebp
movq %rdx, %r13
movl %eax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
callq 0x7805a0
movl $0x11, (%r12)
movq %rax, 0x8(%r12)
movq (%r13), %rax
leaq 0x48(%rsp), %rdx
movq %r13, %rdi
movl %ebp, %esi
callq *0x30(%rax)
testb %al, %al
jne 0x1ca50d8
movq 0x50(%rsp), %rdi
movl 0x48(%rsp), %edx
movq (%rdi), %rax
leaq 0x8(%rsp), %rsi
callq *0x38(%rax)
testb %al, %al
je 0x1ca5272
callq 0x2b7e53f
leaq 0x325d9b4(%rip), %rsi # 0x4f02a98
movl $0x18, %edx
movq %rax, %rdi
callq 0x7f9ba8
leaq 0x3264155(%rip), %rsi # 0x4f0924d
movl $0x1, %edx
movq %rax, %rdi
callq 0x7f9ba8
jmp 0x1ca5178
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0x2b6085c
leaq 0x48(%rsp), %rsi
movw $0x104, 0x20(%rsi) # imm = 0x104
movq %r12, (%rsi)
leaq 0x8(%rsp), %r12
leaq 0x4(%rsp), %rdx
movq %r12, %rdi
callq 0x2b34de8
movq %r14, %rdi
movq %r12, %rsi
callq 0x780b90
movq (%r12), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x1ca515d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x7800d0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ca5178
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x7800d0
movl 0x4(%rsp), %esi
leaq 0x48(%rsp), %rdi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x2b7e176
cmpl $-0x1, 0x4(%rsp)
je 0x1ca51de
leaq 0x48(%rsp), %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x1ca48e6
callq 0x2b7e53f
leaq 0x325d95f(%rip), %rsi # 0x4f02b11
movl $0x8, %edx
movq %rax, %rdi
callq 0x7f9ba8
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%r14), %rdx
leaq 0x10(%r14), %rax
cmpq %rax, %rdx
je 0x1ca5235
movq %rdx, (%rbx)
movq (%rax), %rcx
movq %rcx, 0x10(%rbx)
jmp 0x1ca523b
callq 0x2b7e53f
leaq 0x325d902(%rip), %rsi # 0x4f02aec
movl $0x14, %edx
movq %rax, %rdi
callq 0x7f9ba8
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rax, %rdi
callq 0x2b7d704
leaq 0x325d8f4(%rip), %rsi # 0x4f02b01
movl $0xf, %edx
movq %rax, %rdi
callq 0x7f9ba8
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x22b6290(%rip), %rdx # 0x3f5b4b8
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x7fa87c
jmp 0x1ca5253
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, (%r14)
movq $0x0, 0x8(%r14)
movb $0x0, 0x10(%r14)
leaq 0x48(%rsp), %rdi
callq 0x2b7eba0
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x8(%rsp), %ebp
callq 0x2b7e53f
testl %ebp, %ebp
je 0x1ca52c2
leaq 0x325d82b(%rip), %rsi # 0x4f02ab1
movl $0x17, %edx
movq %rax, %rdi
callq 0x7f9ba8
leaq 0x3263fb3(%rip), %rsi # 0x4f0924d
movl $0x1, %edx
movq %rax, %rdi
callq 0x7f9ba8
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x22b6203(%rip), %rdx # 0x3f5b4b8
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x7fa87c
jmp 0x1ca525d
leaq 0x325d800(%rip), %rsi # 0x4f02ac9
movl $0x22, %edx
movq %rax, %rdi
callq 0x7f9ba8
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rax, %rdi
callq 0x2b7d704
jmp 0x1ca50f1
nop
|
/llvm/Support/GraphWriter.h
|
llvm::VPIntrinsic::classof(llvm::Value const*)
|
static bool classof(const Value *V) {
return isa<IntrinsicInst>(V) && classof(cast<IntrinsicInst>(V));
}
|
pushq %rbx
cmpb $0x55, (%rdi)
jne 0x1caf859
movq %rdi, %rbx
callq 0x91f89e
testb %al, %al
je 0x1caf859
movq -0x20(%rbx), %rax
movl 0x24(%rax), %edi
popq %rbx
jmp 0x2a5ec70
xorl %eax, %eax
popq %rbx
retq
|
/llvm/IR/IntrinsicInst.h
|
runImpl(llvm::MachineFunction&)
|
static std::pair<bool, bool> runImpl(MachineFunction &MF) {
bool Changed = false;
bool PreserveCFG = true;
const TargetInstrInfo *TII = MF.getSubtarget().getInstrInfo();
const TargetLowering *TLI = MF.getSubtarget().getTargetLowering();
// Iterate through each instruction in the function, looking for pseudos.
for (MachineFunction::iterator I = MF.begin(), E = MF.end(); I != E; ++I) {
MachineBasicBlock *MBB = &*I;
for (MachineBasicBlock::iterator MBBI = MBB->begin(), MBBE = MBB->end();
MBBI != MBBE; ) {
MachineInstr &MI = *MBBI++;
// Set AdjustsStack to true if the instruction selector emits a stack
// frame setup instruction or a stack aligning inlineasm.
if (TII->isFrameInstr(MI) || MI.isStackAligningInlineAsm())
MF.getFrameInfo().setAdjustsStack(true);
// If MI is a pseudo, expand it.
if (MI.usesCustomInsertionHook()) {
Changed = true;
MachineBasicBlock *NewMBB = TLI->EmitInstrWithCustomInserter(MI, MBB);
// The expansion may involve new basic blocks.
if (NewMBB != MBB) {
PreserveCFG = false;
MBB = NewMBB;
I = NewMBB->getIterator();
MBBI = NewMBB->begin();
MBBE = NewMBB->end();
}
}
}
}
TLI->finalizeLowering(MF);
return {Changed, PreserveCFG};
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
movq (%rdi), %rax
callq *0x80(%rax)
movq %rax, %r15
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x90(%rax)
movq %rax, %r14
leaq 0x140(%rbx), %rax
movq %rbx, 0x8(%rsp)
movq 0x148(%rbx), %r12
movq %rax, 0x10(%rsp)
cmpq %rax, %r12
je 0x1cb07ee
movb $0x1, %al
movl %eax, (%rsp)
movl $0x0, 0x4(%rsp)
movq 0x38(%r12), %r13
leaq 0x30(%r12), %rbp
cmpq %rbp, %r13
je 0x1cb07d0
testq %r13, %r13
je 0x1cb0743
testb $0x4, (%r13)
movq %r13, %rax
jne 0x1cb075a
testb $0x8, 0x2c(%r13)
movq %r13, %rax
je 0x1cb075a
movq %r13, %rax
movq 0x8(%rax), %rax
testb $0x8, 0x2c(%rax)
jne 0x1cb0750
movq 0x8(%rax), %rbx
movzwl 0x44(%r13), %eax
cmpl %eax, 0x40(%r15)
je 0x1cb077b
cmpl %eax, 0x44(%r15)
je 0x1cb077b
movq %r13, %rdi
callq 0x1d3e052
testb %al, %al
je 0x1cb0788
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
movb $0x1, 0x41(%rax)
movq 0x10(%r13), %rax
testb $0x8, 0x13(%rax)
je 0x1cb07c4
movq (%r14), %rax
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq *0x9d0(%rax)
movb $0x1, %cl
movl %ecx, 0x4(%rsp)
cmpq %r12, %rax
je 0x1cb07c4
movq 0x38(%rax), %rbx
movq %rax, %rbp
addq $0x30, %rbp
movl $0x0, (%rsp)
movq %rax, %r12
movq %rbx, %r13
cmpq %rbp, %rbx
jne 0x1cb0734
movq 0x8(%r12), %r12
cmpq 0x10(%rsp), %r12
jne 0x1cb0721
movzbl (%rsp), %ebx
shll $0x8, %ebx
movzbl 0x4(%rsp), %ebp
jmp 0x1cb07f4
movw $0x100, %bx # imm = 0x100
xorl %ebp, %ebp
movq (%r14), %rax
movq %r14, %rdi
movq 0x8(%rsp), %rsi
callq *0x6d8(%rax)
movzwl %bp, %eax
orl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/CodeGen/FinalizeISel.cpp
|
llvm::GCFunctionInfo::invalidate(llvm::Function&, llvm::PreservedAnalyses const&, llvm::AnalysisManager<llvm::Function>::Invalidator&)
|
bool GCFunctionInfo::invalidate(Function &F, const PreservedAnalyses &PA,
FunctionAnalysisManager::Invalidator &) {
auto PAC = PA.getChecker<GCFunctionAnalysis>();
return !PAC.preserved() && !PAC.preservedSet<AllAnalysesOn<Function>>();
}
|
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsp, %r14
movq %rdx, (%r14)
leaq 0x3c9d907(%rip), %rsi # 0x594eb58
movq %rsi, 0x8(%r14)
leaq 0x30(%rdx), %rdi
callq 0x90b7be
movq 0x38(%rbx), %rcx
xorl %edx, %edx
cmpq 0x30(%rbx), %rcx
sete %dl
movl 0x40(%rbx,%rdx,4), %edx
leaq (%rcx,%rdx,8), %rcx
cmpq %rcx, %rax
setne 0x10(%r14)
movq %r14, %rdi
callq 0x1a01030
testb %al, %al
je 0x1cb128b
xorl %eax, %eax
jmp 0x1cb1295
movq %rsp, %rdi
callq 0x1a010a4
xorb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
|
/CodeGen/GCMetadata.cpp
|
llvm::DenseMap<llvm::Function const*, llvm::GCFunctionInfo*, llvm::DenseMapInfo<llvm::Function const*, void>, llvm::detail::DenseMapPair<llvm::Function const*, llvm::GCFunctionInfo*>>::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), %eax
movl 0x10(%rdi), %esi
testl %eax, %eax
je 0x1cb2026
decl %eax
je 0x1cb202a
bsrl %eax, %eax
xorl $0x1f, %eax
jmp 0x1cb202f
xorl %ebp, %ebp
jmp 0x1cb2045
movl $0x20, %eax
movb $0x21, %cl
subb %al, %cl
movl $0x1, %eax
shll %cl, %eax
cmpl $0x41, %eax
movl $0x40, %ebp
cmovgel %eax, %ebp
cmpl %esi, %ebp
jne 0x1cb2115
movq $0x0, 0x8(%rbx)
testq %rsi, %rsi
je 0x1cb210e
movq (%rbx), %rax
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
addq %rdx, %rsi
andq %rsi, %rdx
andl $0x1, %esi
negq %rsi
leaq (%rdx,%rsi), %rcx
addq $0x2, %rcx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
addq $0x10, %rax
xorl %edx, %edx
movdqa 0xf02f89(%rip), %xmm1 # 0x2bb5020
movdqa 0xf02f91(%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 0x1cb20eb
movq $-0x1000, -0x10(%rax) # imm = 0xF000
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %esi
testb $0x1, %sil
je 0x1cb2101
movq $-0x1000, (%rax) # imm = 0xF000
addq $0x2, %rdx
addq $0x20, %rax
cmpq %rdx, %rcx
jne 0x1cb20a7
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq (%rbx), %rdi
shlq $0x4, %rsi
movl $0x8, %edx
callq 0x2b410f1
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1cb1930
|
/llvm/ADT/DenseMap.h
|
std::pair<llvm::StringMapIterator<llvm::GCStrategy*>, bool> llvm::StringMap<llvm::GCStrategy*, llvm::MallocAllocator>::try_emplace_with_hash<>(llvm::StringRef, unsigned int)
|
std::pair<iterator, bool> try_emplace_with_hash(StringRef Key,
uint32_t FullHashValue,
ArgsTy &&...Args) {
unsigned BucketNo = LookupBucketFor(Key, FullHashValue);
StringMapEntryBase *&Bucket = TheTable[BucketNo];
if (Bucket && Bucket != getTombstoneVal())
return std::make_pair(iterator(TheTable + BucketNo, false),
false); // Already exists in map.
if (Bucket == getTombstoneVal())
--NumTombstones;
Bucket =
MapEntryTy::create(Key, getAllocator(), std::forward<ArgsTy>(Args)...);
++NumItems;
assert(NumItems + NumTombstones <= NumBuckets);
BucketNo = RehashTable(BucketNo);
return std::make_pair(iterator(TheTable + BucketNo, false), true);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
callq 0x2b56116
movl %eax, %ebp
movq (%r14), %rax
movl %ebp, %ecx
leaq (%rax,%rcx,8), %rbx
movq (%rbx), %rax
cmpq $-0x8, %rax
je 0x1cb2180
testq %rax, %rax
je 0x1cb2184
jmp 0x1cb216e
addq $0x8, %rbx
movq (%rbx), %rax
testq %rax, %rax
je 0x1cb216a
cmpq $-0x8, %rax
je 0x1cb216a
xorl %edx, %edx
jmp 0x1cb21ee
decl 0x10(%r14)
leaq 0x11(%r15), %rdi
movl $0x8, %esi
callq 0x2b410ec
movq %rax, %r13
testq %r15, %r15
je 0x1cb21ac
movq %r13, %rdi
addq $0x10, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x780890
movb $0x0, 0x10(%r13,%r15)
movq %r15, (%r13)
movq $0x0, 0x8(%r13)
movq %r13, (%rbx)
incl 0xc(%r14)
movq %r14, %rdi
movl %ebp, %esi
callq 0x2b5638e
movl %eax, %ebx
shlq $0x3, %rbx
addq (%r14), %rbx
movq (%rbx), %rax
testq %rax, %rax
je 0x1cb21e6
cmpq $-0x8, %rax
jne 0x1cb21ec
addq $0x8, %rbx
jmp 0x1cb21d8
movb $0x1, %dl
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/llvm/ADT/StringMap.h
|
llvm::Pass* llvm::callDefaultCtor<(anonymous namespace)::GCMachineCodeAnalysis, true>()
|
Pass *callDefaultCtor() {
return new PassName();
}
|
pushq %rax
movl $0x48, %edi
callq 0x7808d0
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
leaq 0x3c9bfd5(%rip), %rdx # 0x594eb7d
movq %rdx, 0x10(%rax)
movl $0x2, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movq %rcx, 0x30(%rax)
leaq 0x3bd76a3(%rip), %rcx # 0x588a268
movq %rcx, (%rax)
movups %xmm0, 0x38(%rax)
popq %rcx
retq
|
/llvm/PassSupport.h
|
llvm::LexicalScopes::getOrCreateLexicalScope(llvm::DILocalScope const*, llvm::DILocation const*)
|
LexicalScope *LexicalScopes::getOrCreateLexicalScope(const DILocalScope *Scope,
const DILocation *IA) {
if (IA) {
// Skip scopes inlined from a NoDebug compile unit.
if (Scope->getSubprogram()->getUnit()->getEmissionKind() ==
DICompileUnit::NoDebug)
return getOrCreateLexicalScope(IA);
// Create an abstract scope for inlined function.
getOrCreateAbstractScope(Scope);
// Create an inlined scope for inlined function.
return getOrCreateInlinedScope(Scope, IA);
}
return getOrCreateRegularScope(Scope);
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x1cccc76
movq %rdx, %rbx
movq %r14, %rdi
callq 0x2a0977a
movq -0x10(%rax), %rcx
testb $0x2, %cl
jne 0x1cccc86
addq $-0x10, %rax
addl %ecx, %ecx
andl $0x78, %ecx
subq %rcx, %rax
jmp 0x1cccc8a
movq %r15, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1cccef6
movq -0x20(%rax), %rax
movq 0x28(%rax), %rax
cmpl $0x0, 0x20(%rax)
je 0x1ccccb2
movq %r15, %rdi
movq %r14, %rsi
callq 0x1ccccc2
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x1ccce0c
movq %r15, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1cccad2
|
/CodeGen/LexicalScopes.cpp
|
llvm::DenseMap<llvm::Register, std::vector<unsigned int, std::allocator<unsigned int>>, llvm::DenseMapInfo<llvm::Register, void>, llvm::detail::DenseMapPair<llvm::Register, std::vector<unsigned int, std::allocator<unsigned int>>>>::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 0x1cd3998
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, %ecx
movl %ecx, %eax
shrl $0x8, %eax
orl %ecx, %eax
movl %eax, %ebp
shrl $0x10, %ebp
orl %eax, %ebp
incl %ebp
jmp 0x1cd399a
xorl %ebp, %ebp
movl %ebp, 0x10(%rbx)
testl %ebp, %ebp
je 0x1cd39b3
movl %ebp, %edi
shlq $0x5, %rdi
movl $0x8, %esi
callq 0x2b410ec
jmp 0x1cd39b5
xorl %eax, %eax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
testl %ebp, %ebp
je 0x1cd3adf
movl 0x10(%rbx), %ecx
testq %rcx, %rcx
je 0x1cd3adf
movabsq $0x7ffffffffffffff, %rdx # imm = 0x7FFFFFFFFFFFFFF
addq %rdx, %rcx
andq %rcx, %rdx
andl $0x3, %ecx
negq %rcx
addq %rdx, %rcx
addq $0x4, %rcx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
addq $0x60, %rax
xorl %edx, %edx
movdqa 0x16c5d77(%rip), %xmm1 # 0x3399780
movdqa 0xee160f(%rip), %xmm2 # 0x2bb5020
movdqa 0xee1617(%rip), %xmm3 # 0x2bb5030
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movq %rdx, %xmm5
pshufd $0x44, %xmm5, %xmm5 # xmm5 = xmm5[0,1,0,1]
movdqa %xmm5, %xmm6
por %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8 # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6 # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %esi
notl %esi
testb $0x1, %sil
je 0x1cd3a6b
movl $0xffffffff, -0x60(%rax) # imm = 0xFFFFFFFF
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %esi
testb $0x1, %sil
je 0x1cd3a81
movl $0xffffffff, -0x40(%rax) # imm = 0xFFFFFFFF
por %xmm1, %xmm5
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7 # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5 # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
pxor %xmm4, %xmm5
pextrw $0x0, %xmm5, %esi
testb $0x1, %sil
je 0x1cd3abd
movl $0xffffffff, -0x20(%rax) # imm = 0xFFFFFFFF
pextrw $0x4, %xmm5, %esi
testb $0x1, %sil
je 0x1cd3ace
movl $0xffffffff, (%rax) # imm = 0xFFFFFFFF
addq $0x4, %rdx
subq $-0x80, %rax
cmpq %rdx, %rcx
jne 0x1cd3a21
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
/llvm/ADT/DenseMap.h
|
llvm::IntervalMap<llvm::SlotIndex, (anonymous namespace)::DbgVariableValue, 4u, llvm::IntervalMapInfo<llvm::SlotIndex>>::iterator::treeInsert(llvm::SlotIndex, llvm::SlotIndex, (anonymous namespace)::DbgVariableValue)
|
void IntervalMap<KeyT, ValT, N, Traits>::
iterator::treeInsert(KeyT a, KeyT b, ValT y) {
using namespace IntervalMapImpl;
Path &P = this->path;
if (!P.valid())
P.legalizeForInsert(this->map->height);
// Check if this insertion will extend the node to the left.
if (P.leafOffset() == 0 && Traits::startLess(a, P.leaf<Leaf>().start(0))) {
// Node is growing to the left, will it affect a left sibling node?
if (NodeRef Sib = P.getLeftSibling(P.height())) {
Leaf &SibLeaf = Sib.get<Leaf>();
unsigned SibOfs = Sib.size() - 1;
if (SibLeaf.value(SibOfs) == y &&
Traits::adjacent(SibLeaf.stop(SibOfs), a)) {
// This insertion will coalesce with the last entry in SibLeaf. We can
// handle it in two ways:
// 1. Extend SibLeaf.stop to b and be done, or
// 2. Extend a to SibLeaf, erase the SibLeaf entry and continue.
// We prefer 1., but need 2 when coalescing to the right as well.
Leaf &CurLeaf = P.leaf<Leaf>();
P.moveLeft(P.height());
if (Traits::stopLess(b, CurLeaf.start(0)) &&
(y != CurLeaf.value(0) || !Traits::adjacent(b, CurLeaf.start(0)))) {
// Easy, just extend SibLeaf and we're done.
setNodeStop(P.height(), SibLeaf.stop(SibOfs) = b);
return;
} else {
// We have both left and right coalescing. Erase the old SibLeaf entry
// and continue inserting the larger interval.
a = SibLeaf.start(SibOfs);
treeErase(/* UpdateRoot= */false);
}
}
} else {
// No left sibling means we are at begin(). Update cached bound.
this->map->rootBranchStart() = a;
}
}
// When we are inserting at the end of a leaf node, we must update stops.
unsigned Size = P.leafSize();
bool Grow = P.leafOffset() == Size;
Size = P.leaf<Leaf>().insertFrom(P.leafOffset(), Size, a, b, y);
// Leaf insertion unsuccessful? Overflow and try again.
if (Size > Leaf::Capacity) {
overflow<Leaf>(P.height());
Grow = P.leafOffset() == P.leafSize();
Size = P.leaf<Leaf>().insertFrom(P.leafOffset(), P.leafSize(), a, b, y);
assert(Size <= Leaf::Capacity && "overflow() didn't make room");
}
// Inserted, update offset and leaf size.
P.setSize(P.height(), Size);
// Insert was the last node entry, update stops.
if (Grow)
setNodeStop(P.height(), b);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %r12
movq %rsi, 0x30(%rsp)
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
cmpl $0x0, 0x10(%rdi)
movq %rcx, 0x28(%rsp)
je 0x1cd4dd8
movq (%r14), %rax
movl 0xc(%rax), %edx
cmpl 0x8(%rax), %edx
jb 0x1cd4dee
movq (%rbx), %rax
movl 0xa0(%rax), %esi
movq %r14, %rdi
callq 0x16f0b8e
movq 0x28(%rsp), %rcx
movq %r14, 0x38(%rsp)
movq 0x8(%rbx), %rax
movl 0x10(%rbx), %esi
movq %rsi, %rdx
shlq $0x4, %rdx
cmpl $0x0, -0x4(%rax,%rdx)
movq %rbx, 0x8(%rsp)
jne 0x1cd4f98
addq %rdx, %rax
movq -0x10(%rax), %rax
movq 0x30(%rsp), %rdx
movq %rdx, %rdi
andq $-0x8, %rdi
shrl %edx
andl $0x3, %edx
orl 0x18(%rdi), %edx
movq (%rax), %rax
movq %rax, %rdi
andq $-0x8, %rdi
shrl %eax
andl $0x3, %eax
orl 0x18(%rdi), %eax
cmpl %eax, %edx
jae 0x1cd4f98
decl %esi
movq 0x38(%rsp), %rdi
callq 0x2b363aa
testq %rax, %rax
je 0x1cd4f83
movq %rax, %rbx
movq %rax, %r13
andq $-0x40, %rbx
andl $0x3f, %r13d
leaq (,%r13,2), %rdx
addq %r13, %rdx
movb 0x48(%rbx,%rdx,8), %al
movl %eax, %r8d
andb $0x3f, %r8b
movq 0x28(%rsp), %rcx
movb 0x8(%rcx), %sil
movl %esi, %edi
andb $0x3f, %dil
cmpb %dil, %r8b
setne %dil
xorb %al, %sil
cmpb $0x40, %sil
setae %sil
orb %dil, %sil
jne 0x1cd4f98
leaq (%rbx,%rdx,8), %rdx
addq $0x40, %rdx
movq 0x10(%rdx), %rsi
cmpq 0x10(%rcx), %rsi
jne 0x1cd4f98
testb %r8b, %r8b
je 0x1cd4ee2
movq (%rdx), %rdi
movq (%rcx), %rsi
shlb $0x2, %al
movzbl %al, %edx
callq 0x780c70
movq 0x28(%rsp), %rcx
testl %eax, %eax
jne 0x1cd4f98
movl %r13d, %ebp
shll $0x4, %ebp
movq 0x30(%rsp), %rax
cmpq %rax, 0x8(%rbx,%rbp)
jne 0x1cd4f98
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rax
movl 0x10(%rcx), %ecx
leal -0x1(%rcx), %esi
shlq $0x4, %rcx
movq -0x10(%rax,%rcx), %r15
movq 0x38(%rsp), %rdi
callq 0x2b3640e
movq (%r15), %r14
movq %r12, %rax
andq $-0x8, %rax
movl %r12d, %ecx
shrl %ecx
andl $0x3, %ecx
orl 0x18(%rax), %ecx
movq %r14, %rax
andq $-0x8, %rax
movl %r14d, %edx
shrl %edx
andl $0x3, %edx
orl 0x18(%rax), %edx
cmpl %edx, %ecx
ja 0x1cd53ec
addq $0x40, %r15
movq 0x28(%rsp), %rdi
movq %r15, %rsi
callq 0x1cd56a9
cmpq %r12, %r14
setne %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x1cd53ec
leaq (%rbx,%rbp), %rax
addq $0x8, %rax
movq 0x8(%rsp), %rdi
movl 0x10(%rdi), %esi
movq %r12, (%rax)
jmp 0x1cd53d0
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x30(%rsp), %rcx
movq %rcx, (%rax)
movq 0x28(%rsp), %rcx
movq 0x8(%rsp), %rdx
movq 0x8(%rdx), %rax
movl 0x10(%rdx), %edx
shlq $0x4, %rdx
leaq (%rax,%rdx), %rbx
addq $-0x4, %rbx
movl -0x4(%rbx), %ebp
cmpl %ebp, (%rbx)
sete %r14b
movq -0xc(%rbx), %r15
leaq 0xc0(%rsp), %r13
movq %r13, %rdi
movq %rcx, %rsi
callq 0x1cd485e
movq %r15, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movq 0x30(%rsp), %rcx
movq %r12, %r8
movq %r13, %r9
callq 0x1cd540a
movl %eax, %ebx
movq (%r13), %rdi
testq %rdi, %rdi
je 0x1cd4ff8
callq 0x7802b0
movq $0x0, 0xc0(%rsp)
cmpl $0x5, %ebx
jb 0x1cd5385
movq %r12, 0x58(%rsp)
movq 0x8(%rsp), %rax
movl 0x10(%rax), %ebp
decl %ebp
movq 0x8(%rax), %rax
movq %rbp, %r14
shlq $0x4, %r14
movl 0xc(%rax,%r14), %r12d
movq 0x38(%rsp), %rdi
movl %ebp, %esi
callq 0x2b363aa
testq %rax, %rax
movq %rax, 0x98(%rsp)
je 0x1cd5069
movl %eax, %ecx
andl $0x3f, %ecx
leal 0x1(%rcx), %r13d
movl %r13d, 0x10(%rsp)
addl %ecx, %r12d
incl %r12d
andq $-0x40, %rax
movq %rax, 0x70(%rsp)
movl $0x1, %ebx
jmp 0x1cd506e
xorl %r13d, %r13d
xorl %ebx, %ebx
movq 0x38(%rsp), %rdi
movq (%rdi), %rax
movl 0x8(%rax,%r14), %ecx
movl %ebx, %edx
movl %ecx, 0x10(%rsp,%rdx,4)
addl %ecx, %r13d
movq (%rax,%r14), %rax
leal 0x1(%rbx), %r15d
movq %rax, 0x70(%rsp,%rdx,8)
movl %ebp, %esi
callq 0x2b364f0
testq %rax, %rax
je 0x1cd50c1
movl %eax, %ecx
andl $0x3f, %ecx
leal 0x1(%rcx), %edx
movl %r15d, %esi
movl %edx, 0x10(%rsp,%rsi,4)
addl %ecx, %r13d
incl %r13d
andq $-0x40, %rax
orl $0x2, %ebx
movq %rax, 0x70(%rsp,%rsi,8)
movl %ebx, %r15d
movq 0x8(%rsp), %rdx
leal 0x1(%r13), %eax
leal (,%r15,4), %ecx
movq $0x0, 0x68(%rsp)
cmpl %ecx, %eax
jbe 0x1cd511d
leal -0x1(%r15), %ebx
cmpl $0x1, %r15d
cmovel %r15d, %ebx
movl 0x10(%rsp,%rbx,4), %eax
movl %r15d, %ecx
movl %eax, 0x10(%rsp,%rcx,4)
movq 0x70(%rsp,%rbx,8), %rax
movq %rax, 0x70(%rsp,%rcx,8)
movl $0x0, 0x10(%rsp,%rbx,4)
movq (%rdx), %rdi
callq 0x1cd5bd8
movq %rbx, 0x68(%rsp)
movq %rax, 0x70(%rsp,%rbx,8)
incl %r15d
movl $0x1, (%rsp)
leaq 0x10(%rsp), %rcx
leaq 0x40(%rsp), %r8
movl %r15d, %edi
movl %r13d, %esi
movl $0x4, %edx
movl %r12d, %r9d
callq 0x2b36626
movq %rax, 0xa0(%rsp)
movl %r15d, %eax
decl %eax
movl %eax, %eax
movq %rax, 0x60(%rsp)
je 0x1cd51ad
movq 0x60(%rsp), %r14
movl 0x10(%rsp,%r14,4), %eax
cmpl 0x40(%rsp,%r14,4), %eax
je 0x1cd51a8
movq %r14, %r12
subq $0x1, %r12
jb 0x1cd51a8
movq 0x70(%rsp,%r14,8), %rdi
movl 0x10(%rsp,%r14,4), %esi
movq 0x70(%rsp,%r12,8), %rdx
movl 0x10(%rsp,%r12,4), %ecx
movl 0x40(%rsp,%r14,4), %r8d
subl %esi, %r8d
callq 0x1cd623a
subl %eax, 0x10(%rsp,%r12,4)
addl 0x10(%rsp,%r14,4), %eax
movl %eax, 0x10(%rsp,%r14,4)
cmpl 0x40(%rsp,%r14,4), %eax
jb 0x1cd516b
decq %r14
jne 0x1cd515c
cmpl $0x2, %r15d
jb 0x1cd521a
movl $0x1, %r13d
xorl %r12d, %r12d
movl 0x10(%rsp,%r12,4), %eax
cmpl 0x40(%rsp,%r12,4), %eax
je 0x1cd520d
movl %r13d, %r14d
cmpl %r14d, %r15d
je 0x1cd520d
movl %r14d, %ebx
movq 0x70(%rsp,%rbx,8), %rdi
movl 0x10(%rsp,%rbx,4), %esi
movq 0x70(%rsp,%r12,8), %rdx
movl 0x10(%rsp,%r12,4), %ecx
movl %ecx, %r8d
subl 0x40(%rsp,%r12,4), %r8d
callq 0x1cd623a
addl %eax, 0x10(%rsp,%rbx,4)
movl 0x10(%rsp,%r12,4), %ecx
subl %eax, %ecx
movl %ecx, 0x10(%rsp,%r12,4)
incl %r14d
cmpl 0x40(%rsp,%r12,4), %ecx
jb 0x1cd51cb
incq %r12
incl %r13d
cmpq 0x60(%rsp), %r12
jne 0x1cd51bc
cmpq $0x0, 0x98(%rsp)
movq 0x38(%rsp), %r12
je 0x1cd5234
movq %r12, %rdi
movl %ebp, %esi
callq 0x2b3640e
xorl %r13d, %r13d
movq 0x8(%rsp), %rbx
movq 0x68(%rsp), %r8
testl %r8d, %r8d
sete %dil
movl %r13d, %eax
movq 0x70(%rsp,%rax,8), %rdx
movl 0x40(%rsp,%rax,4), %esi
leal -0x1(%rsi), %eax
movq %rax, %rcx
shlq $0x4, %rcx
movq 0x8(%rdx,%rcx), %rcx
cmpl %r8d, %r13d
setne %r8b
orb %dil, %r8b
jne 0x1cd5287
andq $-0x40, %rdx
orq %rax, %rdx
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1cd5c46
movzbl %al, %eax
addl %eax, %ebp
jmp 0x1cd52c4
movl %ebp, %edi
movq (%r12), %rdx
shlq $0x4, %rdi
movl %esi, 0x8(%rdx,%rdi)
testl %ebp, %ebp
je 0x1cd52b7
leal -0x1(%rbp), %esi
shlq $0x4, %rsi
movl 0xc(%rdx,%rsi), %edi
movq (%rdx,%rsi), %rdx
movq (%rdx,%rdi,8), %rsi
andq $-0x40, %rsi
orq %rax, %rsi
movq %rsi, (%rdx,%rdi,8)
movq %rbx, %rdi
movl %ebp, %esi
movq %rcx, %rdx
callq 0x1cd5700
leal 0x1(%r13), %r14d
cmpl %r15d, %r14d
je 0x1cd52da
movq %r12, %rdi
movl %ebp, %esi
callq 0x2b3655e
movl %r14d, %r13d
cmpl %r15d, %r14d
jne 0x1cd523c
movq 0xa0(%rsp), %r14
movl %r14d, %ebx
subl %r13d, %ebx
je 0x1cd5301
movq %r12, %rdi
movl %ebp, %esi
callq 0x2b3640e
incl %ebx
jne 0x1cd52f3
shrq $0x20, %r14
movl %ebp, %eax
movq 0x8(%rsp), %rdx
movq 0x8(%rdx), %rcx
shlq $0x4, %rax
movl %r14d, 0xc(%rcx,%rax)
movl 0x10(%rdx), %eax
shlq $0x4, %rax
leaq (%rcx,%rax), %rbx
addq $-0x4, %rbx
movl -0x4(%rbx), %ebp
cmpl %ebp, (%rbx)
sete %r14b
movq -0xc(%rbx), %r15
leaq 0xa8(%rsp), %r12
movq %r12, %rdi
movq 0x28(%rsp), %rsi
callq 0x1cd485e
movq %r15, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movq 0x30(%rsp), %rcx
movq 0x58(%rsp), %r8
movq %r12, %r9
callq 0x1cd540a
movl %eax, %ebx
movq (%r12), %rdi
testq %rdi, %rdi
je 0x1cd5374
callq 0x7802b0
movq $0x0, 0xa8(%rsp)
movq 0x58(%rsp), %r12
movq 0x8(%rsp), %rcx
movl 0x10(%rcx), %eax
leal -0x1(%rax), %edx
movq 0x8(%rcx), %rcx
movq %rdx, %rsi
shlq $0x4, %rsi
movl %ebx, 0x8(%rcx,%rsi)
testl %edx, %edx
je 0x1cd53c3
addl $-0x2, %eax
shlq $0x4, %rax
movl 0xc(%rcx,%rax), %edx
movq (%rcx,%rax), %rax
decl %ebx
movq (%rax,%rdx,8), %rcx
andq $-0x40, %rcx
orq %rbx, %rcx
movq %rcx, (%rax,%rdx,8)
testb %r14b, %r14b
je 0x1cd53da
movq 0x8(%rsp), %rdi
movl 0x10(%rdi), %esi
decl %esi
movq %r12, %rdx
callq 0x1cd5700
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
shll $0x4, %r13d
movq (%rbx,%r13), %rax
movq %rax, 0x30(%rsp)
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x1cd574c
jmp 0x1cd4f93
|
/llvm/ADT/IntervalMap.h
|
llvm::SmallVectorTemplateBase<std::pair<llvm::LiveRange const*, llvm::LiveRange::Segment const*>, true>::push_back(std::pair<llvm::LiveRange const*, llvm::LiveRange::Segment const*>)
|
void push_back(ValueParamT Elt) {
const T *EltPtr = reserveForParamAndGetAddress(Elt);
memcpy(reinterpret_cast<void *>(this->end()), EltPtr, sizeof(T));
this->set_size(this->size() + 1);
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl 0x8(%rdi), %edx
cmpl 0xc(%rdi), %edx
jae 0x1cdd104
movq (%r14), %rax
movl 0x8(%r14), %ecx
shlq $0x4, %rcx
movq %r15, (%rax,%rcx)
movq %rbx, 0x8(%rax,%rcx)
incl 0x8(%r14)
popq %rbx
popq %r14
popq %r15
retq
incq %rdx
leaq 0x10(%r14), %rsi
movl $0x10, %ecx
movq %r14, %rdi
callq 0x2b4ed86
jmp 0x1cdd0e6
|
/llvm/ADT/SmallVector.h
|
llvm::LiveRegMatrix::getOneVReg(unsigned int) const
|
Register LiveRegMatrix::getOneVReg(unsigned PhysReg) const {
const LiveInterval *VRegInterval = nullptr;
for (MCRegUnit Unit : TRI->regunits(PhysReg)) {
if ((VRegInterval = Matrix[Unit].getOneVReg()))
return VRegInterval->reg();
}
return MCRegister::NoRegister;
}
|
pushq %rbp
pushq %r14
pushq %rbx
movq 0x38(%rdi), %rcx
movq 0x38(%rcx), %rax
testq %rax, %rax
je 0x1ce9138
movq %rdi, %rbx
movq 0x8(%rcx), %rcx
movl %esi, %edx
leaq (%rdx,%rdx,2), %rdx
movl 0x10(%rcx,%rdx,8), %ebp
movl %ebp, %ecx
shrl $0xc, %ecx
leaq (%rax,%rcx,2), %r14
andl $0xfff, %ebp # imm = 0xFFF
movl %ebp, %eax
imulq $0xd8, %rax, %rdi
addq 0xc8(%rbx), %rdi
callq 0x1ee0164
testq %rax, %rax
jne 0x1ce913c
movswl (%r14), %ecx
addq $0x2, %r14
addl %ecx, %ebp
xorl %eax, %eax
movl $0x0, %edx
testl %ecx, %ecx
cmoveq %rdx, %r14
jne 0x1ce9103
jmp 0x1ce913f
xorl %eax, %eax
jmp 0x1ce913f
movl 0x70(%rax), %eax
popq %rbx
popq %r14
popq %rbp
retq
|
/CodeGen/LiveRegMatrix.cpp
|
llvm::LiveRegUnits::addLiveOuts(llvm::MachineBasicBlock const&)
|
void LiveRegUnits::addLiveOuts(const MachineBasicBlock &MBB) {
const MachineFunction &MF = *MBB.getParent();
addPristines(MF);
// To get the live-outs we simply merge the live-ins of all successors.
for (const MachineBasicBlock *Succ : MBB.successors())
addBlockLiveIns(*this, *Succ);
// For the return block: Add all callee saved registers.
if (MBB.isReturnBlock()) {
const MachineFrameInfo &MFI = MF.getFrameInfo();
if (MFI.isCalleeSavedInfoValid())
addCalleeSavedRegs(*this, MF);
}
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x20(%rsi), %rbx
movq %rbx, %rsi
callq 0x1ce96e8
movq 0x58(%r15), %r12
movq 0x60(%r15), %r13
cmpq %r13, %r12
je 0x1ce9910
movq (%r12), %rsi
movq %r14, %rdi
callq 0x1ce9944
addq $0x8, %r12
jmp 0x1ce98f9
movq %r15, %rdi
callq 0xbc375c
testb %al, %al
je 0x1ce993a
movq 0x38(%rbx), %rax
cmpb $0x1, 0x78(%rax)
jne 0x1ce993a
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1ce97c3
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/CodeGen/LiveRegUnits.cpp
|
llvm::LiveVariables::FindLastRefOrPartRef(llvm::Register)
|
MachineInstr *LiveVariables::FindLastRefOrPartRef(Register Reg) {
MachineInstr *LastDef = PhysRegDef[Reg];
MachineInstr *LastUse = PhysRegUse[Reg];
if (!LastDef && !LastUse)
return nullptr;
MachineInstr *LastRefOrPartRef = LastUse ? LastUse : LastDef;
unsigned LastRefOrPartRefDist = DistanceMap[LastRefOrPartRef];
unsigned LastPartDefDist = 0;
for (MCPhysReg SubReg : TRI->subregs(Reg)) {
MachineInstr *Def = PhysRegDef[SubReg];
if (Def && Def != LastDef) {
// There was a def of this sub-register in between. This is a partial
// def, keep track of the last one.
unsigned Dist = DistanceMap[Def];
if (Dist > LastPartDefDist)
LastPartDefDist = Dist;
} else if (MachineInstr *Use = PhysRegUse[SubReg]) {
unsigned Dist = DistanceMap[Use];
if (Dist > LastRefOrPartRefDist) {
LastRefOrPartRefDist = Dist;
LastRefOrPartRef = Use;
}
}
}
return LastRefOrPartRef;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %r15d
movq 0x68(%rdi), %rax
movq 0x80(%rdi), %rcx
movq (%rax,%r15,8), %r13
movq (%rcx,%r15,8), %rax
movq %r13, %rcx
orq %rax, %rcx
je 0x1ceb8a1
movl %esi, %ebp
movq %rdi, %rbx
testq %rax, %rax
cmoveq %r13, %rax
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
leaq 0xb0(%rdi), %r14
movq %r14, %rdi
callq 0xe2acc8
movq 0x60(%rbx), %rcx
movq 0x8(%rcx), %rdx
movq 0x38(%rcx), %rcx
leaq (%r15,%r15,2), %rsi
movl 0x4(%rdx,%rsi,8), %edx
movzwl (%rcx,%rdx,2), %r15d
testl %r15d, %r15d
je 0x1ceb89a
leaq (%rcx,%rdx,2), %r12
addq $0x2, %r12
addl %ebp, %r15d
movl 0x8(%rax), %eax
movl %eax, 0xc(%rsp)
xorl %ebp, %ebp
movzwl %r15w, %eax
movq 0x68(%rbx), %rcx
movq (%rcx,%rax,8), %rcx
movq %rcx, 0x20(%rsp)
testq %rcx, %rcx
sete %dl
cmpq %r13, %rcx
sete %cl
orb %dl, %cl
je 0x1ceb879
movq 0x80(%rbx), %rcx
movq (%rcx,%rax,8), %rax
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x1ceb886
movq %r14, %rdi
leaq 0x10(%rsp), %rsi
callq 0xe2acc8
movl 0x8(%rax), %eax
cmpl 0xc(%rsp), %eax
jbe 0x1ceb886
movq 0x10(%rsp), %rcx
movq %rcx, 0x18(%rsp)
movl %eax, 0xc(%rsp)
jmp 0x1ceb886
movq %r14, %rdi
leaq 0x20(%rsp), %rsi
callq 0xe2acc8
movzwl (%r12), %eax
addq $0x2, %r12
addl %eax, %r15d
testl %eax, %eax
cmoveq %rbp, %r12
jne 0x1ceb81d
movq 0x18(%rsp), %rax
jmp 0x1ceb8a3
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/CodeGen/LiveVariables.cpp
|
llvm::LLVMTargetMachine::LLVMTargetMachine(llvm::Target const&, llvm::StringRef, llvm::Triple const&, llvm::StringRef, llvm::StringRef, llvm::TargetOptions const&, llvm::Reloc::Model, llvm::CodeModel::Model, llvm::CodeGenOptLevel)
|
LLVMTargetMachine::LLVMTargetMachine(const Target &T,
StringRef DataLayoutString,
const Triple &TT, StringRef CPU,
StringRef FS, const TargetOptions &Options,
Reloc::Model RM, CodeModel::Model CM,
CodeGenOptLevel OL)
: TargetMachine(T, DataLayoutString, TT, CPU, FS, Options) {
this->RM = RM;
this->CMModel = CM;
this->OptLevel = OL;
if (EnableTrapUnreachable)
this->Options.TrapUnreachable = true;
if (EnableNoTrapAfterNoreturn)
this->Options.NoTrapAfterNoreturn = true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl 0x80(%rsp), %ebp
movl 0x78(%rsp), %r14d
movl 0x70(%rsp), %r15d
movaps 0x60(%rsp), %xmm0
movups %xmm0, 0x10(%rsp)
movaps 0x50(%rsp), %xmm0
movups %xmm0, (%rsp)
callq 0x2395334
leaq 0x3b9c8df(%rip), %rax # 0x588aea8
addq $0x10, %rax
movq %rax, (%rbx)
movl %r15d, 0x248(%rbx)
movl %r14d, 0x24c(%rbx)
movl %ebp, 0x258(%rbx)
cmpb $0x1, 0x3c61bbd(%rip) # 0x59501a8
jne 0x1cee5f4
orb $0x2, 0x33d(%rbx)
cmpb $0x1, 0x3c61c6d(%rip) # 0x5950268
jne 0x1cee604
orb $0x4, 0x33d(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
|
/CodeGen/LLVMTargetMachine.cpp
|
llvm::LLVMTargetMachine::addAsmPrinter(llvm::legacy::PassManagerBase&, llvm::raw_pwrite_stream&, llvm::raw_pwrite_stream*, llvm::CodeGenFileType, llvm::MCContext&)
|
bool LLVMTargetMachine::addAsmPrinter(PassManagerBase &PM,
raw_pwrite_stream &Out,
raw_pwrite_stream *DwoOut,
CodeGenFileType FileType,
MCContext &Context) {
Expected<std::unique_ptr<MCStreamer>> MCStreamerOrErr =
createMCStreamer(Out, DwoOut, FileType, Context);
if (auto Err = MCStreamerOrErr.takeError())
return true;
// Create the AsmPrinter, which takes ownership of AsmStreamer if successful.
FunctionPass *Printer =
getTarget().createAsmPrinter(*this, std::move(*MCStreamerOrErr));
if (!Printer)
return true;
PM.add(Printer);
return false;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1cee71a
testb $0x1, 0x8(%r15)
je 0x1cee6a5
movq 0x8(%rsp), %rdi
movq $0x0, 0x8(%rsp)
jmp 0x1cee6a7
xorl %edi, %edi
testq %rdi, %rdi
je 0x1cee6b7
movq (%rdi), %rax
callq *0x8(%rax)
movb $0x1, %bpl
jmp 0x1cee6e9
movq 0x8(%r14), %rax
movq 0x78(%rax), %rax
testq %rax, %rax
je 0x1cee6d0
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq *%rax
jmp 0x1cee6d2
xorl %eax, %eax
testq %rax, %rax
sete %bpl
je 0x1cee6e9
movq (%rbx), %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x10(%rcx)
xorl %ebp, %ebp
movq 0x8(%rsp), %rdi
testb $0x1, 0x10(%rsp)
je 0x1cee702
testq %rdi, %rdi
je 0x1cee70d
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x1cee70d
testq %rdi, %rdi
je 0x1cee70d
movq (%rdi), %rax
callq *0x38(%rax)
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/CodeGen/LLVMTargetMachine.cpp
|
llvm::TargetTransformInfo::Model<llvm::BasicTTIImpl>::simplifyDemandedVectorEltsIntrinsic(llvm::InstCombiner&, llvm::IntrinsicInst&, llvm::APInt, llvm::APInt&, llvm::APInt&, llvm::APInt&, std::function<void (llvm::Instruction*, unsigned int, llvm::APInt, llvm::APInt&)>)
|
std::optional<Value *> simplifyDemandedVectorEltsIntrinsic(
InstCombiner &IC, IntrinsicInst &II, APInt DemandedElts, APInt &UndefElts,
APInt &UndefElts2, APInt &UndefElts3,
std::function<void(Instruction *, unsigned, APInt, APInt &)>
SimplifyAndSetOp) override {
return Impl.simplifyDemandedVectorEltsIntrinsic(
IC, II, DemandedElts, UndefElts, UndefElts2, UndefElts3,
SimplifyAndSetOp);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, %rbx
movq %r8, 0x18(%rsp)
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq 0x88(%rsp), %rbp
movl 0x8(%rcx), %eax
movl %eax, 0x10(%rsp)
cmpl $0x40, %eax
ja 0x1cef16b
movq (%rcx), %rax
movq %rax, 0x8(%rsp)
jmp 0x1cef178
leaq 0x8(%rsp), %rdi
movq %rcx, %rsi
callq 0x2b11114
movq 0x80(%rsp), %r10
addq $0x8, %r13
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movq 0x10(%rbp), %rax
testq %rax, %rax
je 0x1cef1c2
movq %rbx, %r14
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %rbp, %rsi
movl $0x2, %edx
callq *%rax
movq 0x80(%rsp), %r10
movups 0x10(%rbp), %xmm0
movaps %xmm0, 0x10(%rbx)
movq %r14, %rbx
leaq 0x20(%rsp), %r14
leaq 0x8(%rsp), %rcx
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq 0x18(%rsp), %r8
movq %rbx, %r9
pushq %r14
pushq %r10
callq 0x1cf708a
addq $0x10, %rsp
movq %rax, %rbx
movl %edx, %ebp
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x1cef207
leaq 0x20(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
cmpl $0x41, 0x10(%rsp)
jb 0x1cef21d
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1cef21d
callq 0x7802b0
movq %rbx, %rax
movl %ebp, %edx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/llvm/Analysis/TargetTransformInfo.h
|
llvm::TargetTransformInfoImplCRTPBase<llvm::BasicTTIImpl>::getGEPCost(llvm::Type*, llvm::Value const*, llvm::ArrayRef<llvm::Value const*>, llvm::Type*, llvm::TargetTransformInfo::TargetCostKind)
|
InstructionCost getGEPCost(Type *PointeeType, const Value *Ptr,
ArrayRef<const Value *> Operands, Type *AccessType,
TTI::TargetCostKind CostKind) {
assert(PointeeType && Ptr && "can't get GEPCost of nullptr");
auto *BaseGV = dyn_cast<GlobalValue>(Ptr->stripPointerCasts());
bool HasBaseReg = (BaseGV == nullptr);
auto PtrSizeBits = DL.getPointerTypeSizeInBits(Ptr->getType());
APInt BaseOffset(PtrSizeBits, 0);
int64_t Scale = 0;
auto GTI = gep_type_begin(PointeeType, Operands);
Type *TargetType = nullptr;
// Handle the case where the GEP instruction has a single operand,
// the basis, therefore TargetType is a nullptr.
if (Operands.empty())
return !BaseGV ? TTI::TCC_Free : TTI::TCC_Basic;
for (auto I = Operands.begin(); I != Operands.end(); ++I, ++GTI) {
TargetType = GTI.getIndexedType();
// We assume that the cost of Scalar GEP with constant index and the
// cost of Vector GEP with splat constant index are the same.
const ConstantInt *ConstIdx = dyn_cast<ConstantInt>(*I);
if (!ConstIdx)
if (auto Splat = getSplatValue(*I))
ConstIdx = dyn_cast<ConstantInt>(Splat);
if (StructType *STy = GTI.getStructTypeOrNull()) {
// For structures the index is always splat or scalar constant
assert(ConstIdx && "Unexpected GEP index");
uint64_t Field = ConstIdx->getZExtValue();
BaseOffset += DL.getStructLayout(STy)->getElementOffset(Field);
} else {
// If this operand is a scalable type, bail out early.
// TODO: Make isLegalAddressingMode TypeSize aware.
if (TargetType->isScalableTy())
return TTI::TCC_Basic;
int64_t ElementSize =
GTI.getSequentialElementStride(DL).getFixedValue();
if (ConstIdx) {
BaseOffset +=
ConstIdx->getValue().sextOrTrunc(PtrSizeBits) * ElementSize;
} else {
// Needs scale register.
if (Scale != 0)
// No addressing mode takes two scale registers.
return TTI::TCC_Basic;
Scale = ElementSize;
}
}
}
// If we haven't been provided a hint, use the target type for now.
//
// TODO: Take a look at potentially removing this: This is *slightly* wrong
// as it's possible to have a GEP with a foldable target type but a memory
// access that isn't foldable. For example, this load isn't foldable on
// RISC-V:
//
// %p = getelementptr i32, ptr %base, i32 42
// %x = load <2 x i32>, ptr %p
if (!AccessType)
AccessType = TargetType;
// If the final address of the GEP is a legal addressing mode for the given
// access type, then we can fold it into its users.
if (static_cast<T *>(this)->isLegalAddressingMode(
AccessType, const_cast<GlobalValue *>(BaseGV),
BaseOffset.sextOrTrunc(64).getSExtValue(), HasBaseReg, Scale,
Ptr->getType()->getPointerAddressSpace()))
return TTI::TCC_Free;
// TODO: Instead of returning TCC_Basic here, we should use
// getArithmeticInstrCost. Or better yet, provide a hook to let the target
// model it.
return TTI::TCC_Basic;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r9, 0x70(%rsp)
movq %r8, (%rsp)
movq %rcx, %rbp
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, %rdi
callq 0x2aa0110
movq %rax, %r12
movb (%rax), %al
cmpb $0x4, %al
setb %dl
movl %eax, %ecx
andb $0xf, %cl
movb $0xd, %sil
shrb %cl, %sil
andb %dl, %sil
cmpb $0x1, %al
sete %r14b
xorl %eax, %eax
orb %sil, %r14b
cmoveq %rax, %r12
movq %rbx, 0x10(%rsp)
movq (%rbx), %rdi
movq (%rsp), %rbx
movq 0x8(%r13), %rsi
callq 0x2a006e8
leaq 0x30(%rsp), %rdi
movl %eax, 0x1c(%rsp)
movl %eax, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x91d2c6
andq $-0x7, %r15
orq $0x4, %r15
movq %rbp, 0x78(%rsp)
movq %rbp, 0x50(%rsp)
movq %r15, 0x58(%rsp)
testq %rbx, %rbx
je 0x1cefc7a
movq %r13, 0x60(%rsp)
movq %r12, 0x68(%rsp)
shlq $0x3, %rbx
xorl %r12d, %r12d
leaq 0x50(%rsp), %r14
xorl %ebp, %ebp
movq $0x0, 0x8(%rsp)
movq %rbx, (%rsp)
movq %r14, %rdi
callq 0x91d2e4
movq %rax, %r13
movq 0x78(%rsp), %rax
movq (%rax,%r12), %rdi
cmpb $0x11, (%rdi)
movq %rdi, %r15
je 0x1cefa00
xorl %r15d, %r15d
testq %r15, %r15
jne 0x1cefa1a
callq 0x271143f
testq %rax, %rax
je 0x1cefa17
movq %rax, %r15
cmpb $0x11, (%rax)
je 0x1cefa1a
xorl %r15d, %r15d
movq 0x58(%rsp), %rsi
testb $0x6, %sil
setne %al
andq $-0x8, %rsi
sete %cl
orb %al, %cl
je 0x1cefa44
movq %r13, %rdi
callq 0x2a9a3f6
testb %al, %al
je 0x1cefa58
xorl %eax, %eax
jmp 0x1cefb58
cmpl $0x41, 0x20(%r15)
jb 0x1cefb08
movq 0x18(%r15), %r15
jmp 0x1cefb0c
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movq %r14, %rdi
callq 0x91d32a
movq %rax, %rbx
testq %r15, %r15
je 0x1cefb77
addq $0x18, %r15
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
movl 0x1c(%rsp), %edx
callq 0x2b137a8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2b1194c
movl 0x28(%rsp), %eax
movl %eax, 0x88(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x80(%rsp)
movl $0x0, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x2b11572
cmpl $0x41, 0x88(%rsp)
jb 0x1cefae5
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0x1cefae5
callq 0x7802b0
cmpl $0x41, 0x28(%rsp)
movq (%rsp), %rbx
jb 0x1cefaff
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x1cefaff
callq 0x7802b0
movb $0x1, %al
leaq 0x50(%rsp), %r14
jmp 0x1cefb58
addq $0x18, %r15
movl (%r15), %ebx
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x2a005d4
shlq $0x4, %rbx
movq 0x18(%rax,%rbx), %rcx
movb 0x20(%rax,%rbx), %al
movq %rcx, 0x80(%rsp)
movb %al, 0x88(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x2b60e74
leaq 0x30(%rsp), %rdi
movq %rax, %rsi
callq 0x2b1161a
movb $0x1, %al
movq (%rsp), %rbx
testb %al, %al
je 0x1cefb8d
movq %r14, %rdi
callq 0x91d37a
addq $0x8, %r12
cmpq %r12, %rbx
sete %bpl
jne 0x1cef9e1
jmp 0x1cefb8d
movq 0x8(%rsp), %rcx
testq %rcx, %rcx
sete %al
cmoveq %rbx, %rcx
movq %rcx, 0x8(%rsp)
jmp 0x1cefb54
movb $0x1, %r14b
testb $0x1, %bpl
movq 0x68(%rsp), %r15
movq 0x60(%rsp), %r12
movq 0x70(%rsp), %rax
je 0x1cefc7a
testq %rax, %rax
cmovneq %rax, %r13
leaq 0x40(%rsp), %rbx
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
movl $0x40, %edx
callq 0x2b137a8
movl 0x8(%rbx), %edx
cmpl $0x40, %edx
ja 0x1cefbe8
movq 0x40(%rsp), %rsi
movl %edx, %ecx
negb %cl
shlq %cl, %rsi
sarq %cl, %rsi
xorl %eax, %eax
testl %edx, %edx
cmovneq %rsi, %rax
jmp 0x1cefbf0
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq 0x8(%r12), %rcx
movl $0xfe, %edx
andl 0x8(%rcx), %edx
cmpl $0x12, %edx
jne 0x1cefc09
movq 0x10(%rcx), %rcx
movq (%rcx), %rcx
movl 0x8(%rcx), %r8d
shrl $0x8, %r8d
testq %r15, %r15
xorps %xmm0, %xmm0
leaq 0x80(%rsp), %rdx
movaps %xmm0, (%rdx)
movups %xmm0, 0x18(%rdx)
movq %r15, (%rdx)
movq %rax, 0x8(%rdx)
sete 0x10(%rdx)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rdx)
movq $0x0, 0x20(%rdx)
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movq 0x10(%rax), %rdi
movq (%rdi), %rax
movq %r13, %rcx
xorl %r9d, %r9d
callq *0x4e8(%rax)
movl %eax, %r14d
cmpl $0x41, 0x48(%rsp)
jb 0x1cefc76
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x1cefc76
callq 0x7802b0
xorb $0x1, %r14b
cmpl $0x41, 0x38(%rsp)
jb 0x1cefc90
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x1cefc90
callq 0x7802b0
movzbl %r14b, %eax
xorl %edx, %edx
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/llvm/Analysis/TargetTransformInfoImpl.h
|
llvm::LocalStackSlotAllocationPass::run(llvm::MachineFunction&, llvm::AnalysisManager<llvm::MachineFunction>&)
|
PreservedAnalyses
LocalStackSlotAllocationPass::run(MachineFunction &MF,
MachineFunctionAnalysisManager &) {
bool Changed = LocalStackSlotImpl().runOnMachineFunction(MF);
if (!Changed)
return PreservedAnalyses::all();
auto PA = getMachineFunctionPassPreservedAnalyses();
PA.preserveSet<CFGAnalyses>();
return PA;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq %rsp, %r15
movl $0x90, %edx
movq %r15, %rdi
xorl %esi, %esi
callq 0x780240
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movabsq $0x1000000000, %rax # imm = 0x1000000000
movq %rax, -0x8(%r12)
movq %r15, %rdi
movq %r14, %rsi
callq 0x1cf7f8c
movl %eax, %ebp
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x1cf7f1c
callq 0x780910
testb %bpl, %bpl
je 0x1cf7f3a
movq %rbx, %rdi
callq 0x1d598ca
leaq 0x3cae980(%rip), %rsi # 0x59a68b0
movq %rbx, %rdi
callq 0xc13c14
jmp 0x1cf7f78
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 0x3cae94b(%rip), %rdx # 0x59a68b8
movq %rsp, %rdi
movq %rbx, %rsi
callq 0xade436
movq %rbx, %rax
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
|
/CodeGen/LocalStackSlotAllocation.cpp
|
llvm::MachineBasicBlock::canSplitCriticalEdge(llvm::MachineBasicBlock const*) const
|
bool MachineBasicBlock::canSplitCriticalEdge(
const MachineBasicBlock *Succ) const {
// Splitting the critical edge to a landing pad block is non-trivial. Don't do
// it in this generic function.
if (Succ->isEHPad())
return false;
// Splitting the critical edge to a callbr's indirect block isn't advised.
// Don't do it in this generic function.
if (Succ->isInlineAsmBrIndirectTarget())
return false;
const MachineFunction *MF = getParent();
// Performance might be harmed on HW that implements branching using exec mask
// where both sides of the branches are always executed.
if (MF->getTarget().requiresStructuredCFG())
return false;
// Do we have an Indirect jump with a jumptable that we can rewrite?
int JTI = findJumpTableIndex(*this);
if (JTI >= 0 && !jumpTableHasOtherUses(*MF, *this, JTI))
return true;
// We may need to update this's terminator, but we can't do that if
// analyzeBranch fails.
const TargetInstrInfo *TII = MF->getSubtarget().getInstrInfo();
MachineBasicBlock *TBB = nullptr, *FBB = nullptr;
SmallVector<MachineOperand, 4> Cond;
// AnalyzeBanch should modify this, since we did not allow modification.
if (TII->analyzeBranch(*const_cast<MachineBasicBlock *>(this), TBB, FBB, Cond,
/*AllowModify*/ false))
return false;
// Avoid bugpoint weirdness: A block may end with a conditional branch but
// jumps to the same MBB is either case. We have duplicate CFG edges in that
// case that we can't handle. Since this never happens in properly optimized
// code, just skip those edges.
if (TBB && TBB == FBB) {
LLVM_DEBUG(dbgs() << "Won't split critical edge after degenerate "
<< printMBBReference(*this) << '\n');
return false;
}
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
cmpb $0x0, 0xb8(%rsi)
jne 0x1cfe445
cmpb $0x0, 0xe6(%rsi)
jne 0x1cfe445
movq %rdi, %rbx
movq 0x20(%rdi), %r13
movq 0x8(%r13), %rax
testb $0x1, 0x280(%rax)
jne 0x1cfe445
movq %rbx, %rdi
callq 0x1cfe59e
movabsq $0x400000000, %r12 # imm = 0x400000000
movl %eax, 0xc(%rsp)
testl %eax, %eax
js 0x1cfe526
movq 0x48(%r13), %rax
movl 0xc(%rsp), %ecx
movq 0x8(%rax), %rax
leaq (%rcx,%rcx,2), %rdx
movq (%rax,%rdx,8), %rcx
movq 0x8(%rax,%rdx,8), %rax
cmpq %rax, %rcx
je 0x1cfe45d
addq $0x8, %rcx
xorl %r15d, %r15d
movq -0x8(%rcx), %rdx
testq %rdx, %rdx
cmovneq %rdx, %r15
jne 0x1cfe460
leaq 0x8(%rcx), %rdx
cmpq %rax, %rcx
movq %rdx, %rcx
jne 0x1cfe42a
jmp 0x1cfe460
xorl %r14d, %r14d
movl %r14d, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r15d, %r15d
testq %r15, %r15
je 0x1cfe526
movq %r13, 0x20(%rsp)
movq 0x10(%r13), %rdi
movq (%rdi), %rax
callq *0x80(%rax)
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
movq %r12, -0x8(%rax)
movq 0x40(%r15), %rbp
movq 0x48(%r15), %r12
cmpq %r12, %rbp
setne %r13b
je 0x1cfe4f6
movq (%rbp), %r15
cmpq %rbx, %r15
je 0x1cfe4f0
xorl %eax, %eax
movq %rax, 0x18(%rsp)
movq %rax, 0x10(%rsp)
movl $0x0, 0x30(%rsp)
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
leaq 0x18(%rsp), %rdx
leaq 0x10(%rsp), %rcx
leaq 0x28(%rsp), %r8
xorl %r9d, %r9d
callq *0x100(%rax)
testb %al, %al
je 0x1cfe4f0
movq %r15, %rdi
callq 0x1cfe59e
testl %eax, %eax
js 0x1cfe4f6
cmpl 0xc(%rsp), %eax
je 0x1cfe4f6
addq $0x8, %rbp
jmp 0x1cfe493
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x1cfe50a
callq 0x780910
movb $0x1, %r14b
testb $0x1, %r13b
movabsq $0x400000000, %r12 # imm = 0x400000000
movq 0x20(%rsp), %r13
je 0x1cfe448
movq 0x10(%r13), %rdi
movq (%rdi), %rax
callq *0x80(%rax)
xorl %r14d, %r14d
leaq 0x18(%rsp), %rdx
movq %r14, (%rdx)
leaq 0x10(%rsp), %rcx
movq %r14, (%rcx)
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq %r12, -0x8(%r15)
movq (%rax), %r10
leaq 0x28(%rsp), %r8
movq %rax, %rdi
movq %rbx, %rsi
xorl %r9d, %r9d
callq *0x100(%r10)
testb %al, %al
jne 0x1cfe586
movq 0x18(%rsp), %rax
testq %rax, %rax
sete %cl
cmpq 0x10(%rsp), %rax
setne %r14b
orb %cl, %r14b
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x1cfe448
callq 0x780910
jmp 0x1cfe448
|
/CodeGen/MachineBasicBlock.cpp
|
llvm::iplist_impl<llvm::simple_ilist<llvm::MachineInstr, llvm::ilist_sentinel_tracking<true>>, llvm::ilist_traits<llvm::MachineInstr>>::insert(llvm::ilist_iterator<llvm::ilist_detail::node_options<llvm::MachineInstr, true, true, void, false, void>, false, false>, llvm::MachineInstr*)
|
iterator insert(iterator where, pointer New) {
this->addNodeToList(New); // Notify traits that we added a node...
return base_list_type::insert(where, *New);
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq (%rdi), %rax
movq %rax, 0x18(%rdx)
movq 0x20(%rax), %r15
movq 0x28(%r15), %rsi
movq %rdx, %rdi
callq 0x1d3c84c
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1d33c56
movq (%r14), %rax
andq $-0x8, %rax
movq %r14, 0x8(%rbx)
movq (%rbx), %rcx
andl $0x7, %ecx
orq %rax, %rcx
movq %rcx, (%rbx)
movq %rbx, 0x8(%rax)
movq (%r14), %rax
andl $0x7, %eax
orq %rbx, %rax
movq %rax, (%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
|
/llvm/ADT/ilist.h
|
llvm::MachineBasicBlock::removeFromParent()
|
MachineBasicBlock *MachineBasicBlock::removeFromParent() {
assert(getParent() && "Not embedded in a function!");
getParent()->remove(this);
return this;
}
|
movq %rdi, %rax
movq 0x20(%rdi), %rcx
movl 0x18(%rdi), %edx
movq 0x68(%rcx), %rcx
movq $0x0, (%rcx,%rdx,8)
movl $0xffffffff, 0x18(%rdi) # imm = 0xFFFFFFFF
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movq %rcx, (%rdx)
movq %rdx, 0x8(%rcx)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
retq
|
/CodeGen/MachineBasicBlock.cpp
|
llvm::SmallVectorImpl<llvm::BlockFrequencyInfoImplBase::BlockNode>::assign(unsigned long, llvm::BlockFrequencyInfoImplBase::BlockNode)
|
size_t size() const { return Size; }
|
movl 0xc(%rdi), %eax
cmpq %rsi, %rax
jb 0x1d04104
movq (%rdi), %rax
movl 0x8(%rdi), %ecx
cmpq %rsi, %rcx
cmovaeq %rsi, %rcx
testq %rcx, %rcx
je 0x1d03ff9
movabsq $0x3fffffffffffffff, %r8 # imm = 0x3FFFFFFFFFFFFFFF
addq %r8, %rcx
andq %rcx, %r8
andl $0x3, %ecx
negq %rcx
addq %r8, %rcx
addq $0x4, %rcx
movq %r8, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
xorl %r8d, %r8d
movdqa 0x1695856(%rip), %xmm1 # 0x3399780
movdqa 0xeb10ee(%rip), %xmm2 # 0x2bb5020
movdqa 0xeb10f6(%rip), %xmm3 # 0x2bb5030
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movq %r8, %xmm5
pshufd $0x44, %xmm5, %xmm5 # xmm5 = xmm5[0,1,0,1]
movdqa %xmm5, %xmm6
por %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8 # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6 # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %r9d
notl %r9d
testb $0x1, %r9b
je 0x1d03f8b
movl %edx, (%rax,%r8,4)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %r9d
testb $0x1, %r9b
je 0x1d03fa0
movl %edx, 0x4(%rax,%r8,4)
por %xmm1, %xmm5
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7 # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5 # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
pxor %xmm4, %xmm5
pextrw $0x0, %xmm5, %r9d
testb $0x1, %r9b
je 0x1d03fdb
movl %edx, 0x8(%rax,%r8,4)
pextrw $0x4, %xmm5, %r9d
testb $0x1, %r9b
je 0x1d03fec
movl %edx, 0xc(%rax,%r8,4)
addq $0x4, %r8
cmpq %r8, %rcx
jne 0x1d03f42
movl 0x8(%rdi), %r8d
movq %rsi, %r9
subq %r8, %r9
jbe 0x1d04100
leaq 0x3(%r9), %rcx
andq $-0x4, %rcx
decq %r9
movq %r9, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
leaq (%rax,%r8,4), %rax
addq $0xc, %rax
xorl %r8d, %r8d
movdqa 0x169574f(%rip), %xmm1 # 0x3399780
movdqa 0xeb0fe7(%rip), %xmm2 # 0x2bb5020
movdqa 0xeb0fef(%rip), %xmm3 # 0x2bb5030
pxor %xmm3, %xmm0
pcmpeqd %xmm4, %xmm4
movq %r8, %xmm5
pshufd $0x44, %xmm5, %xmm5 # xmm5 = xmm5[0,1,0,1]
movdqa %xmm5, %xmm6
por %xmm2, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm0, %xmm7
pcmpeqd %xmm0, %xmm6
pshufd $0xf5, %xmm6, %xmm8 # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6 # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
movd %xmm6, %r9d
notl %r9d
testb $0x1, %r9b
je 0x1d04093
movl %edx, -0xc(%rax,%r8,4)
pxor %xmm4, %xmm6
pextrw $0x4, %xmm6, %r9d
testb $0x1, %r9b
je 0x1d040a8
movl %edx, -0x8(%rax,%r8,4)
por %xmm1, %xmm5
pxor %xmm3, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm7 # xmm7 = xmm5[1,1,3,3]
pand %xmm6, %xmm7
pshufd $0xf5, %xmm6, %xmm5 # xmm5 = xmm6[1,1,3,3]
por %xmm7, %xmm5
pxor %xmm4, %xmm5
pextrw $0x0, %xmm5, %r9d
testb $0x1, %r9b
je 0x1d040e3
movl %edx, -0x4(%rax,%r8,4)
pextrw $0x4, %xmm5, %r9d
testb $0x1, %r9b
je 0x1d040f3
movl %edx, (%rax,%r8,4)
addq $0x4, %r8
cmpq %r8, %rcx
jne 0x1d04049
movl %esi, 0x8(%rdi)
retq
|
/llvm/ADT/SmallVector.h
|
(anonymous namespace)::MachineBlockPlacement::shouldTailDuplicate(llvm::MachineBasicBlock*)
|
bool MachineBlockPlacement::shouldTailDuplicate(MachineBasicBlock *BB) {
// Blocks with single successors don't create additional fallthrough
// opportunities. Don't duplicate them. TODO: When conditional exits are
// analyzable, allow them to be duplicated.
bool IsSimple = TailDup.isSimpleBB(BB);
if (BB->succ_size() == 1)
return false;
return TailDup.shouldTailDuplicate(IsSimple, *BB);
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x1e65c2c
movq 0x60(%rbx), %rcx
subq 0x58(%rbx), %rcx
movabsq $0x7fffffff8, %rdx # imm = 0x7FFFFFFF8
andq %rcx, %rdx
cmpq $0x8, %rdx
jne 0x1d0b8c7
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
addq $0x1b8, %r14 # imm = 0x1B8
movzbl %al, %esi
movq %r14, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1e65c82
nop
|
/CodeGen/MachineBlockPlacement.cpp
|
llvm::DenseMapBase<llvm::DenseMap<llvm::MachineBasicBlock const*, (anonymous namespace)::MachineBlockPlacement::precomputeTriangleChains()::TriangleChain, llvm::DenseMapInfo<llvm::MachineBasicBlock const*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock const*, (anonymous namespace)::MachineBlockPlacement::precomputeTriangleChains()::TriangleChain>>, llvm::MachineBasicBlock const*, (anonymous namespace)::MachineBlockPlacement::precomputeTriangleChains()::TriangleChain, llvm::DenseMapInfo<llvm::MachineBasicBlock const*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock const*, (anonymous namespace)::MachineBlockPlacement::precomputeTriangleChains()::TriangleChain>>::grow(unsigned int)
|
void grow(unsigned AtLeast) {
static_cast<DerivedT *>(this)->grow(AtLeast);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
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 $0x5, %rdi
movl $0x8, %esi
callq 0x2b410ec
movq %rax, (%r15)
movq %r14, 0x8(%rsp)
testq %r14, %r14
je 0x1d0bbab
movq $0x0, 0x8(%r15)
movl 0x10(%r15), %ecx
testq %rcx, %rcx
je 0x1d0bb13
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 0xea9584(%rip), %xmm1 # 0x2bb5020
movdqa 0xea958c(%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 0x1d0baf0
movq $-0x1000, -0x20(%rax) # imm = 0xF000
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %esi
testb $0x1, %sil
je 0x1d0bb06
movq $-0x1000, (%rax) # imm = 0xF000
addq $0x2, %rdx
addq $0x40, %rax
cmpq %rdx, %rcx
jne 0x1d0baac
testq %rbx, %rbx
je 0x1d0bb87
movq %rbx, %rbp
shlq $0x5, %rbp
leaq 0x10(%rsp), %r12
movq 0x8(%rsp), %r13
movq (%r13), %r14
movq %r14, %rax
orq $0x1000, %rax # imm = 0x1000
cmpq $-0x1000, %rax # imm = 0xF000
je 0x1d0bb7d
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x1d0b8e4
movq 0x10(%rsp), %rax
movq %r14, (%rax)
movdqu 0x8(%r13), %xmm0
movdqu %xmm0, 0x8(%rax)
movq 0x18(%r13), %rcx
movq %rcx, 0x18(%rax)
pxor %xmm0, %xmm0
movdqu %xmm0, 0x8(%r13)
movq $0x0, 0x18(%r13)
incl 0x8(%r15)
addq $0x20, %r13
addq $-0x20, %rbp
jne 0x1d0bb29
shlq $0x5, %rbx
movl $0x8, %edx
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2b410f1
movq $0x0, 0x8(%r15)
movl 0x10(%r15), %ecx
testq %rcx, %rcx
je 0x1d0bc6c
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 0xea942b(%rip), %xmm1 # 0x2bb5020
movdqa 0xea9433(%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 0x1d0bc49
movq $-0x1000, -0x20(%rax) # imm = 0xF000
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %esi
testb $0x1, %sil
je 0x1d0bc5f
movq $-0x1000, (%rax) # imm = 0xF000
addq $0x2, %rdx
addq $0x40, %rax
cmpq %rdx, %rcx
jne 0x1d0bc05
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/llvm/ADT/DenseMap.h
|
(anonymous namespace)::CopyTracker::clobberRegister(llvm::MCRegister, llvm::TargetRegisterInfo const&, llvm::TargetInstrInfo const&, bool)
|
void clobberRegister(MCRegister Reg, const TargetRegisterInfo &TRI,
const TargetInstrInfo &TII, bool UseCopyInstr) {
for (MCRegUnit Unit : TRI.regunits(Reg)) {
auto I = Copies.find(Unit);
if (I != Copies.end()) {
// When we clobber the source of a copy, we need to clobber everything
// it defined.
markRegsUnavailable(I->second.DefRegs, TRI);
// When we clobber the destination of a copy, we need to clobber the
// whole register it defined.
if (MachineInstr *MI = I->second.MI) {
std::optional<DestSourcePair> CopyOperands =
isCopyInstr(*MI, TII, UseCopyInstr);
MCRegister Def = CopyOperands->Destination->getReg().asMCReg();
MCRegister Src = CopyOperands->Source->getReg().asMCReg();
markRegsUnavailable(Def, TRI);
// Since we clobber the destination of a copy, the semantic of Src's
// "DefRegs" to contain Def is no longer effectual. We will also need
// to remove the record from the copy maps that indicates Src defined
// Def. Failing to do so might cause the target to miss some
// opportunities to further eliminate redundant copy instructions.
// Consider the following sequence during the
// ForwardCopyPropagateBlock procedure:
// L1: r0 = COPY r9 <- TrackMI
// L2: r0 = COPY r8 <- TrackMI (Remove r9 defined r0 from tracker)
// L3: use r0 <- Remove L2 from MaybeDeadCopies
// L4: early-clobber r9 <- Clobber r9 (L2 is still valid in tracker)
// L5: r0 = COPY r8 <- Remove NopCopy
for (MCRegUnit SrcUnit : TRI.regunits(Src)) {
auto SrcCopy = Copies.find(SrcUnit);
if (SrcCopy != Copies.end() && SrcCopy->second.LastSeenUseInCopy) {
// If SrcCopy defines multiple values, we only need
// to erase the record for Def in DefRegs.
for (auto itr = SrcCopy->second.DefRegs.begin();
itr != SrcCopy->second.DefRegs.end(); itr++) {
if (*itr == Def) {
SrcCopy->second.DefRegs.erase(itr);
// If DefReg becomes empty after removal, we can remove the
// SrcCopy from the tracker's copy maps. We only remove those
// entries solely record the Def is defined by Src. If an
// entry also contains the definition record of other Def'
// registers, it cannot be cleared.
if (SrcCopy->second.DefRegs.empty() && !SrcCopy->second.MI) {
Copies.erase(SrcCopy);
}
break;
}
}
}
}
}
// Now we can erase the copy.
Copies.erase(I);
}
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, 0x28(%rsp)
movq 0x38(%rdx), %rax
testq %rax, %rax
je 0x1d19116
movq %rdx, %r13
movq %rdi, %r15
movq 0x8(%rdx), %rcx
movl %esi, %edx
leaq (%rdx,%rdx,2), %rdx
movl 0x10(%rcx,%rdx,8), %r12d
movl %r12d, %ecx
shrl $0xc, %ecx
leaq (%rax,%rcx,2), %r14
andl $0xfff, %r12d # imm = 0xFFF
leaq 0xc(%rsp), %rbx
xorl %ebp, %ebp
movzbl %r8b, %eax
movl %eax, 0x10(%rsp)
movq %r13, 0x18(%rsp)
movl %r12d, 0xc(%rsp)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1d198d2
movl 0x10(%r15), %ecx
shlq $0x6, %rcx
addq (%r15), %rcx
cmpq %rcx, %rax
je 0x1d190ff
movq %rax, %rbp
movq 0x18(%rax), %rsi
movl 0x20(%rax), %edx
movq %r15, %rdi
movq %r13, %rcx
callq 0x1d19988
movq %rbp, 0x20(%rsp)
movq 0x8(%rbp), %rsi
xorl %ebp, %ebp
testq %rsi, %rsi
je 0x1d190c6
leaq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rdx
movl 0x10(%rsp), %ecx
callq 0x1d18d37
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %rcx
movl 0x4(%rax), %eax
movl %eax, 0x8(%rsp)
movl 0x4(%rcx), %ebx
movl $0x1, %edx
movq %r15, %rdi
leaq 0x8(%rsp), %rsi
movq %r13, %rcx
callq 0x1d19988
movq 0x38(%r13), %rax
testq %rax, %rax
je 0x1d190ba
movq 0x18(%rsp), %rcx
movq 0x8(%rcx), %rcx
leaq (%rbx,%rbx,2), %rdx
movl 0x10(%rcx,%rdx,8), %r13d
movl %r13d, %ecx
shrl $0xc, %ecx
leaq (%rax,%rcx,2), %rbx
andl $0xfff, %r13d # imm = 0xFFF
movl %r13d, 0x14(%rsp)
movq %r15, %rdi
leaq 0x14(%rsp), %rsi
callq 0x1d198d2
movq %rax, %rbp
movl 0x10(%r15), %eax
shlq $0x6, %rax
addq (%r15), %rax
cmpq %rax, %rbp
je 0x1d1909f
cmpq $0x0, 0x10(%rbp)
je 0x1d1909f
movl 0x20(%rbp), %eax
testq %rax, %rax
je 0x1d1909f
movq 0x18(%rbp), %rdi
movl 0x8(%rsp), %esi
leaq (,%rax,4), %rdx
xorl %ecx, %ecx
cmpl %esi, (%rdi,%rcx)
je 0x1d1903f
addq $0x4, %rcx
cmpq %rcx, %rdx
jne 0x1d1902f
jmp 0x1d1909f
leaq -0x4(,%rax,4), %rax
cmpq %rcx, %rax
je 0x1d19063
leaq (%rdi,%rcx), %rsi
addq $0x4, %rsi
addq %rcx, %rdi
subq %rcx, %rdx
addq $-0x4, %rdx
callq 0x780120
decl 0x20(%rbp)
jne 0x1d1909f
cmpq $0x0, 0x8(%rbp)
jne 0x1d1909f
movq 0x18(%rbp), %rdi
movq %rbp, %rax
addq $0x28, %rax
cmpq %rax, %rdi
je 0x1d19084
callq 0x780910
movl $0xfffffffe, (%rbp) # imm = 0xFFFFFFFE
movq 0x8(%r15), %xmm0
paddd 0x168a5b7(%rip), %xmm0 # 0x33a3650
movq %xmm0, 0x8(%r15)
movswl (%rbx), %eax
addq $0x2, %rbx
addl %eax, %r13d
movl $0x0, %ecx
testl %eax, %eax
cmoveq %rcx, %rbx
jne 0x1d18fdd
movq 0x18(%rsp), %r13
leaq 0xc(%rsp), %rbx
xorl %ebp, %ebp
movq 0x20(%rsp), %rcx
movq 0x18(%rcx), %rdi
movq %rcx, %rax
addq $0x28, %rax
cmpq %rax, %rdi
je 0x1d190e5
callq 0x780910
movq 0x20(%rsp), %rcx
movl $0xfffffffe, (%rcx) # imm = 0xFFFFFFFE
movq 0x8(%r15), %xmm0
paddd 0x168a557(%rip), %xmm0 # 0x33a3650
movq %xmm0, 0x8(%r15)
movswl (%r14), %eax
addq $0x2, %r14
addl %eax, %r12d
testl %eax, %eax
cmoveq %rbp, %r14
jne 0x1d18f24
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/CodeGen/MachineCopyPropagation.cpp
|
(anonymous namespace)::MachineCopyPropagation::eraseIfRedundant(llvm::MachineInstr&, llvm::MCRegister, llvm::MCRegister)
|
bool MachineCopyPropagation::eraseIfRedundant(MachineInstr &Copy,
MCRegister Src, MCRegister Def) {
// Avoid eliminating a copy from/to a reserved registers as we cannot predict
// the value (Example: The sparc zero register is writable but stays zero).
if (MRI->isReserved(Src) || MRI->isReserved(Def))
return false;
// Search for an existing copy.
MachineInstr *PrevCopy =
Tracker.findAvailCopy(Copy, Def, *TRI, *TII, UseCopyInstr);
if (!PrevCopy)
return false;
auto PrevCopyOperands = isCopyInstr(*PrevCopy, *TII, UseCopyInstr);
// Check that the existing copy uses the correct sub registers.
if (PrevCopyOperands->Destination->isDead())
return false;
if (!isNopCopy(*PrevCopy, Src, Def, TRI, TII, UseCopyInstr))
return false;
LLVM_DEBUG(dbgs() << "MCP: copy is a NOP, removing: "; Copy.dump());
// Copy was redundantly redefining either Src or Def. Remove earlier kill
// flags between Copy and PrevCopy because the value will be reused now.
std::optional<DestSourcePair> CopyOperands =
isCopyInstr(Copy, *TII, UseCopyInstr);
assert(CopyOperands);
Register CopyDef = CopyOperands->Destination->getReg();
assert(CopyDef == Src || CopyDef == Def);
for (MachineInstr &MI :
make_range(PrevCopy->getIterator(), Copy.getIterator()))
MI.clearRegisterKills(CopyDef, TRI);
// Clear undef flag from remaining copy if needed.
if (!CopyOperands->Source->isUndef()) {
PrevCopy->getOperand(PrevCopyOperands->Source->getOperandNo())
.setIsUndef(false);
}
Copy.eraseFromParent();
Changed = true;
++NumDeletes;
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %ecx, %r12d
movl %edx, %r13d
movq 0x48(%rdi), %rax
movq 0x180(%rax), %rax
movl %edx, %ecx
shrl $0x6, %ecx
movq (%rax,%rcx,8), %rcx
btq %r13, %rcx
jb 0x1d1af2c
movl %r12d, %ecx
shrl $0x6, %ecx
movq (%rax,%rcx,8), %rax
btq %r12, %rax
jae 0x1d1af3d
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %r14
movq %rdi, %rbx
addq $0xd8, %rdi
movq 0x38(%rbx), %rcx
movq 0x40(%rbx), %r8
movzbl 0x50(%rbx), %r9d
movl %r12d, %edx
callq 0x1d1b78c
testq %rax, %rax
je 0x1d1af2c
movq %rax, %r15
movq 0x40(%rbx), %rdx
movzbl 0x50(%rbx), %ecx
leaq 0x20(%rsp), %rbp
movq %rbp, %rdi
movq %rax, %rsi
callq 0x1d18d37
movq (%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
shrl $0x1a, %ecx
shrl $0x18, %eax
andl %ecx, %eax
testb $0x1, %al
jne 0x1d1af2c
movq 0x38(%rbx), %rax
movq %rax, (%rsp)
movq 0x40(%rbx), %rdx
movzbl 0x50(%rbx), %ecx
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
movq %r15, %rsi
callq 0x1d18d37
movq (%rbp), %rax
movq 0x8(%rbp), %rcx
movl 0x4(%rcx), %esi
movl 0x4(%rax), %ebp
movl %esi, %eax
xorl %r13d, %eax
movl %ebp, %ecx
xorl %r12d, %ecx
orl %eax, %ecx
jne 0x1d1b048
movq 0x40(%rbx), %rdx
movzbl 0x50(%rbx), %ecx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x1d18d37
cmpq %r14, %r15
je 0x1d1b00c
movq 0x8(%rsp), %rax
movl 0x4(%rax), %ebp
movq %r15, %r12
movq 0x38(%rbx), %rdx
movq %r12, %rdi
movl %ebp, %esi
callq 0x1d412a6
movq 0x8(%r12), %r12
cmpq %r14, %r12
jne 0x1d1aff4
movq 0x10(%rsp), %rax
testb $0x10, 0x3(%rax)
jne 0x1d1b032
movq 0x28(%rsp), %rdi
callq 0x1d531be
movq 0x20(%r15), %rcx
movl %eax, %eax
shlq $0x5, %rax
andl $0xefffffff, (%rcx,%rax) # imm = 0xEFFFFFFF
movq %r14, %rdi
callq 0x1d3deba
movb $0x1, 0xf0(%rbx)
movb $0x1, %al
jmp 0x1d1af2e
movq (%rsp), %rdi
movq 0x8(%rdi), %rax
movq 0x38(%rdi), %rcx
movl %r13d, %edx
leaq (%rdx,%rdx,2), %rdx
movl 0x8(%rax,%rdx,8), %edx
movzwl (%rcx,%rdx,2), %eax
testl %eax, %eax
sete %r8b
je 0x1d1b098
leaq (%rcx,%rdx,2), %rcx
addq $0x2, %rcx
addl %r13d, %eax
movzwl %ax, %edx
cmpl %esi, %edx
je 0x1d1b091
movzwl (%rcx), %edx
addq $0x2, %rcx
addl %edx, %eax
testl %edx, %edx
jne 0x1d1b08f
movl $0x0, %ecx
jne 0x1d1b076
testq %rcx, %rcx
sete %r8b
testb %r8b, %r8b
jne 0x1d1af2c
addq $0x8, %rdi
movl %r13d, %edx
movq %rdi, %r13
callq 0x28f286a
movl %eax, (%rsp)
movq %r13, %rdi
movl %ebp, %esi
movl %r12d, %edx
callq 0x28f286a
cmpl %eax, (%rsp)
jne 0x1d1af2c
jmp 0x1d1afcf
|
/CodeGen/MachineCopyPropagation.cpp
|
llvm::DenseMapBase<llvm::DenseMap<llvm::MachineInstr*, llvm::MachineBasicBlock*, llvm::MachineInstrExpressionTrait, llvm::detail::DenseMapPair<llvm::MachineInstr*, llvm::MachineBasicBlock*>>, llvm::MachineInstr*, llvm::MachineBasicBlock*, llvm::MachineInstrExpressionTrait, llvm::detail::DenseMapPair<llvm::MachineInstr*, llvm::MachineBasicBlock*>>::clear()
|
unsigned getNumEntries() const {
return NumEntries;
}
|
movl 0x8(%rdi), %eax
testl %eax, %eax
jne 0x1d1db0b
cmpl $0x0, 0xc(%rdi)
je 0x1d1dbe4
shll $0x2, %eax
movl 0x10(%rdi), %ecx
cmpl %ecx, %eax
setae %al
cmpl $0x41, %ecx
setb %dl
orb %al, %dl
je 0x1d1dd12
testq %rcx, %rcx
je 0x1d1dbdc
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 0xe974bb(%rip), %xmm1 # 0x2bb5020
movdqa 0xe974c3(%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 0x1d1dbb9
movq $0x0, -0x10(%rax)
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %esi
testb $0x1, %sil
je 0x1d1dbcf
movq $0x0, (%rax)
addq $0x2, %rdx
addq $0x20, %rax
cmpq %rdx, %rcx
jne 0x1d1db75
movq $0x0, 0x8(%rdi)
retq
nop
|
/llvm/ADT/DenseMap.h
|
llvm::SmallVectorTemplateBase<llvm::DomTreeNodeBase<llvm::MachineBasicBlock>*, true>::push_back(llvm::DomTreeNodeBase<llvm::MachineBasicBlock>*)
|
void push_back(ValueParamT Elt) {
const T *EltPtr = reserveForParamAndGetAddress(Elt);
memcpy(reinterpret_cast<void *>(this->end()), EltPtr, sizeof(T));
this->set_size(this->size() + 1);
}
|
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x8(%rdi), %edx
cmpl 0xc(%rdi), %edx
jae 0x1d1de6d
movq (%rbx), %rax
movl 0x8(%rbx), %ecx
movq %r14, (%rax,%rcx,8)
incl 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
incq %rdx
leaq 0x10(%rbx), %rsi
movl $0x8, %ecx
movq %rbx, %rdi
callq 0x2b4ed86
jmp 0x1d1de58
nop
|
/llvm/ADT/SmallVector.h
|
llvm::DenseMap<llvm::MachineInstr*, llvm::MachineBasicBlock*, llvm::MachineInstrExpressionTrait, llvm::detail::DenseMapPair<llvm::MachineInstr*, llvm::MachineBasicBlock*>>::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 0x1d1ecb6
shlq $0x4, %rbx
leaq (%r14,%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1d1ed7e
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 0x1d1ed77
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 0xe96320(%rip), %xmm1 # 0x2bb5020
movdqa 0xe96328(%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 0x1d1ed54
movq $0x0, -0x10(%rax)
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %esi
testb $0x1, %sil
je 0x1d1ed6a
movq $0x0, (%rax)
addq $0x2, %rdx
addq $0x20, %rax
cmpq %rdx, %rcx
jne 0x1d1ed10
popq %rbx
popq %r14
popq %r15
retq
nop
|
/llvm/ADT/DenseMap.h
|
llvm::detail::DenseMapPair<llvm::MachineBasicBlock*, llvm::GenericCycle<llvm::GenericSSAContext<llvm::MachineFunction>>*>* llvm::DenseMapBase<llvm::DenseMap<llvm::MachineBasicBlock*, llvm::GenericCycle<llvm::GenericSSAContext<llvm::MachineFunction>>*, llvm::DenseMapInfo<llvm::MachineBasicBlock*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock*, llvm::GenericCycle<llvm::GenericSSAContext<llvm::MachineFunction>>*>>, llvm::MachineBasicBlock*, llvm::GenericCycle<llvm::GenericSSAContext<llvm::MachineFunction>>*, llvm::DenseMapInfo<llvm::MachineBasicBlock*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock*, llvm::GenericCycle<llvm::GenericSSAContext<llvm::MachineFunction>>*>>::InsertIntoBucketImpl<llvm::MachineBasicBlock*>(llvm::MachineBasicBlock* const&, llvm::MachineBasicBlock* const&, llvm::detail::DenseMapPair<llvm::MachineBasicBlock*, llvm::GenericCycle<llvm::GenericSSAContext<llvm::MachineFunction>>*>*)
|
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 the table.
//
// The later case is tricky. For example, if we had one empty bucket with
// tons of tombstones, failing lookups (e.g. for insertion) would have to
// probe almost the entire table until it found the empty bucket. If the
// table completely filled with tombstones, no lookup would ever succeed,
// causing infinite loops in lookup.
unsigned NewNumEntries = getNumEntries() + 1;
unsigned NumBuckets = getNumBuckets();
if (LLVM_UNLIKELY(NewNumEntries * 4 >= NumBuckets * 3)) {
this->grow(NumBuckets * 2);
LookupBucketFor(Lookup, TheBucket);
NumBuckets = getNumBuckets();
} else if (LLVM_UNLIKELY(NumBuckets-(NewNumEntries+getNumTombstones()) <=
NumBuckets/8)) {
this->grow(NumBuckets);
LookupBucketFor(Lookup, TheBucket);
}
assert(TheBucket);
// Only update the state after we've grown our bucket space appropriately
// so that when growing buckets we have self-consistent entry count.
incrementNumEntries();
// If we are writing over a tombstone, remember this.
const KeyT EmptyKey = getEmptyKey();
if (!KeyInfoT::isEqual(TheBucket->getFirst(), EmptyKey))
decrementNumTombstones();
return TheBucket;
}
|
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 0x1d2219d
notl %ecx
addl %esi, %ecx
subl 0xc(%rbx), %ecx
movl %esi, %edx
shrl $0x3, %edx
cmpl %edx, %ecx
jbe 0x1d2219f
incl 0x8(%rbx)
cmpq $-0x1000, (%rax) # imm = 0xF000
je 0x1d22193
decl 0xc(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
addl %esi, %esi
movq %rbx, %rdi
callq 0x1d221c0
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1d220bc
movq (%r15), %rax
jmp 0x1d22184
nop
|
/llvm/ADT/DenseMap.h
|
llvm::SmallDenseMap<std::pair<llvm::MachineBasicBlock*, llvm::MachineBasicBlock*>, int, 4u, llvm::DenseMapInfo<std::pair<llvm::MachineBasicBlock*, llvm::MachineBasicBlock*>, void>, llvm::detail::DenseMapPair<std::pair<llvm::MachineBasicBlock*, llvm::MachineBasicBlock*>, int>>::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 0x1d2a3ea
movl %esi, %ebp
andl $-0x2, %eax
movl %eax, (%rbx)
movl %esi, %eax
shlq $0x3, %rax
leaq (%rax,%rax,2), %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 0x1d2a429
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 0x1d2a419
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
|
/llvm/ADT/DenseMap.h
|
llvm::DenseMapBase<llvm::DenseMap<llvm::MachineBasicBlock*, std::unique_ptr<llvm::DomTreeNodeBase<llvm::MachineBasicBlock>, std::default_delete<llvm::DomTreeNodeBase<llvm::MachineBasicBlock>>>, llvm::DenseMapInfo<llvm::MachineBasicBlock*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock*, std::unique_ptr<llvm::DomTreeNodeBase<llvm::MachineBasicBlock>, std::default_delete<llvm::DomTreeNodeBase<llvm::MachineBasicBlock>>>>>, llvm::MachineBasicBlock*, std::unique_ptr<llvm::DomTreeNodeBase<llvm::MachineBasicBlock>, std::default_delete<llvm::DomTreeNodeBase<llvm::MachineBasicBlock>>>, llvm::DenseMapInfo<llvm::MachineBasicBlock*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock*, std::unique_ptr<llvm::DomTreeNodeBase<llvm::MachineBasicBlock>, std::default_delete<llvm::DomTreeNodeBase<llvm::MachineBasicBlock>>>>>::moveFromOldBuckets(llvm::detail::DenseMapPair<llvm::MachineBasicBlock*, std::unique_ptr<llvm::DomTreeNodeBase<llvm::MachineBasicBlock>, std::default_delete<llvm::DomTreeNodeBase<llvm::MachineBasicBlock>>>>*, llvm::detail::DenseMapPair<llvm::MachineBasicBlock*, std::unique_ptr<llvm::DomTreeNodeBase<llvm::MachineBasicBlock>, std::default_delete<llvm::DomTreeNodeBase<llvm::MachineBasicBlock>>>>*)
|
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), %ecx
testq %rcx, %rcx
je 0x1d2bad1
movq (%r15), %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 0xe895c6(%rip), %xmm1 # 0x2bb5020
movdqa 0xe895ce(%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 0x1d2baae
movq $-0x1000, -0x10(%rax) # imm = 0xF000
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %esi
testb $0x1, %sil
je 0x1d2bac4
movq $-0x1000, (%rax) # imm = 0xF000
addq $0x2, %rdx
addq $0x20, %rax
cmpq %rdx, %rcx
jne 0x1d2ba6a
cmpq %rbx, %r14
je 0x1d2bb24
movl $0x1000, %r13d # imm = 0x1000
movq %rsp, %r12
xorl %ebp, %ebp
movq (%r14), %rax
orq %r13, %rax
cmpq $-0x1000, %rax # imm = 0xF000
je 0x1d2bb1b
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x1d2b7ac
movq (%rsp), %rax
movq (%r14), %rcx
movq %rcx, (%rax)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rbp, 0x8(%r14)
incl 0x8(%r15)
movq %rbp, 0x8(%r14)
addq $0x10, %r14
cmpq %rbx, %r14
jne 0x1d2bae1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/llvm/ADT/DenseMap.h
|
llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::MachineBasicBlock, false>>::attachNewSubtree(llvm::DominatorTreeBase<llvm::MachineBasicBlock, false>&, llvm::DomTreeNodeBase<llvm::MachineBasicBlock>*)
|
void attachNewSubtree(DomTreeT& DT, const TreeNodePtr AttachTo) {
// Attach the first unreachable block to AttachTo.
NodeToInfo[NumToNode[1]].IDom = AttachTo->getBlock();
// Loop over all of the discovered blocks in the function...
for (NodePtr W : llvm::drop_begin(NumToNode)) {
// Don't replace this with 'count', the insertion side effect is important
if (DT.DomTreeNodes[W]) continue; // Haven't calculated this node yet?
NodePtr ImmDom = getIDom(W);
// Get or calculate the node for the immediate dominator.
TreeNodePtr IDomNode = getNodeForBlock(ImmDom, DT);
// Add a new tree node for this BasicBlock, and link it as a child of
// IDomNode.
DT.createChild(W, IDomNode);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdx), %r15
addq $0x210, %rdi # imm = 0x210
movq (%r14), %rsi
addq $0x8, %rsi
movq %rdi, 0x10(%rsp)
callq 0x1d2c554
movq %r15, 0x18(%rax)
movl 0x8(%r14), %ebp
cmpq $0x1, %rbp
je 0x1d2bfd7
movq (%r14), %r15
shlq $0x3, %rbp
leaq 0x18(%rbx), %r12
movl $0x8, %r13d
movq (%r15,%r13), %rax
movq %rax, 0x8(%rsp)
movq %r12, %rdi
leaq 0x8(%rsp), %rsi
callq 0x1d2b75e
cmpq $0x0, 0x8(%rax)
jne 0x1d2bfce
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0x1d2d702
movl 0x220(%r14), %ecx
shlq $0x6, %rcx
addq 0x210(%r14), %rcx
cmpq %rcx, %rax
je 0x1d2bfb1
movq 0x18(%rax), %rsi
jmp 0x1d2bfb3
xorl %esi, %esi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1d2d67a
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x1d2720c
addq $0x8, %r13
cmpq %r13, %rbp
jne 0x1d2bf68
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/llvm/Support/GenericDomTreeConstruction.h
|
llvm::DenseMap<llvm::MachineBasicBlock*, llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::MachineBasicBlock, false>>::InfoRec, llvm::DenseMapInfo<llvm::MachineBasicBlock*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock*, llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::MachineBasicBlock, false>>::InfoRec>>::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 0x1d29b2a
testl %ebp, %ebp
je 0x1d30539
decl %ebp
je 0x1d3053d
bsrl %ebp, %eax
xorl $0x1f, %eax
jmp 0x1d30542
xorl %ebp, %ebp
jmp 0x1d30558
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 0x1d30628
movq $0x0, 0x8(%rbx)
testq %rcx, %rcx
je 0x1d30623
movq (%rbx), %rax
movabsq $0x3ffffffffffffff, %rdx # imm = 0x3FFFFFFFFFFFFFF
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 $0x40, %rax
xorl %edx, %edx
movdqa 0xe84a74(%rip), %xmm1 # 0x2bb5020
movdqa 0xe84a7c(%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 0x1d30600
movq $-0x1000, -0x40(%rax) # imm = 0xF000
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %esi
testb $0x1, %sil
je 0x1d30616
movq $-0x1000, (%rax) # imm = 0xF000
addq $0x2, %rdx
subq $-0x80, %rax
cmpq %rdx, %rcx
jne 0x1d305bc
popq %rbx
popq %r14
popq %rbp
retq
movq (%rbx), %rdi
shlq $0x6, %r14
movl $0x8, %edx
movq %r14, %rsi
callq 0x2b410f1
movq %rbx, %rdi
movl %ebp, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x1d3064a
|
/llvm/ADT/DenseMap.h
|
llvm::GraphDiff<llvm::MachineBasicBlock*, false>::popUpdateForIncrementalUpdates()
|
cfg::Update<NodePtr> popUpdateForIncrementalUpdates() {
assert(!LegalizedUpdates.empty() && "No updates to apply!");
auto U = LegalizedUpdates.pop_back_val();
unsigned IsInsert =
(U.getKind() == cfg::UpdateKind::Insert) == !UpdatedAreReverseApplied;
auto &SuccDIList = Succ[U.getFrom()];
auto &SuccList = SuccDIList.DI[IsInsert];
assert(SuccList.back() == U.getTo());
SuccList.pop_back();
if (SuccList.empty() && SuccDIList.DI[!IsInsert].empty())
Succ.erase(U.getFrom());
auto &PredDIList = Pred[U.getTo()];
auto &PredList = PredDIList.DI[IsInsert];
assert(PredList.back() == U.getFrom());
PredList.pop_back();
if (PredList.empty() && PredDIList.DI[!IsInsert].empty())
Pred.erase(U.getTo());
return U;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x258(%rdi), %rax
movl 0x260(%rdi), %ecx
leal -0x1(%rcx), %edx
shlq $0x4, %rcx
movq -0x10(%rax,%rcx), %rbp
movq -0x8(%rax,%rcx), %r14
movl %edx, 0x260(%rdi)
testb $0x4, %r14b
sete %r15b
movb 0x250(%rdi), %r12b
xorl %r13d, %r13d
cmpb %r15b, %r12b
setne %r13b
leaq 0x10(%rsp), %rsi
movq %rbp, (%rsi)
callq 0x1d2afcc
movl %r13d, %ecx
shll $0x5, %ecx
decl 0x10(%rax,%rcx)
jne 0x1d30e09
addq $0x8, %rax
xorl %ecx, %ecx
cmpb %r15b, %r12b
sete %cl
shll $0x5, %ecx
cmpl $0x0, 0x8(%rax,%rcx)
jne 0x1d30e09
leaq 0x10(%rsp), %rsi
movq %rbp, (%rsi)
movq %rbx, %rdi
callq 0x1d30eb8
movb %r15b, 0xf(%rsp)
addq $0x128, %rbx # imm = 0x128
movq %r14, %r15
andq $-0x8, %r15
leaq 0x10(%rsp), %rsi
movq %r15, (%rsi)
movq %rbx, %rdi
callq 0x1d2afcc
shll $0x5, %r13d
decl 0x10(%rax,%r13)
jne 0x1d30e5f
addq $0x8, %rax
xorl %ecx, %ecx
cmpb 0xf(%rsp), %r12b
sete %cl
shll $0x5, %ecx
cmpl $0x0, 0x8(%rax,%rcx)
jne 0x1d30e5f
leaq 0x10(%rsp), %rsi
movq %r15, (%rsi)
movq %rbx, %rdi
callq 0x1d30eb8
movq %rbp, %rax
movq %r14, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/llvm/Support/CFGDiff.h
|
llvm::DenseMapBase<llvm::SmallDenseMap<llvm::MachineBasicBlock*, llvm::GraphDiff<llvm::MachineBasicBlock*, false>::DeletesInserts, 4u, llvm::DenseMapInfo<llvm::MachineBasicBlock*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock*, llvm::GraphDiff<llvm::MachineBasicBlock*, false>::DeletesInserts>>, llvm::MachineBasicBlock*, llvm::GraphDiff<llvm::MachineBasicBlock*, false>::DeletesInserts, llvm::DenseMapInfo<llvm::MachineBasicBlock*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock*, llvm::GraphDiff<llvm::MachineBasicBlock*, false>::DeletesInserts>>::erase(llvm::MachineBasicBlock* const&)
|
bool erase(const KeyT &Val) {
BucketT *TheBucket;
if (!LookupBucketFor(Val, TheBucket))
return false; // not in map.
TheBucket->getSecond().~ValueT();
TheBucket->getFirst() = getTombstoneKey();
decrementNumEntries();
incrementNumTombstones();
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
callq 0x1d2b05c
movl %eax, %ebp
testb %al, %al
je 0x1d30f0d
movq 0x8(%rsp), %r14
leaq 0x38(%r14), %r15
xorl %r12d, %r12d
movq 0x28(%r14,%r12), %rdi
leaq (%r15,%r12), %rax
cmpq %rdi, %rax
je 0x1d30ef6
callq 0x780910
addq $-0x20, %r12
cmpq $-0x40, %r12
jne 0x1d30ee3
movq $-0x2000, (%r14) # imm = 0xE000
addl $-0x2, (%rbx)
incl 0x4(%rbx)
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
|
/llvm/ADT/DenseMap.h
|
llvm::DenseMap<llvm::MachineLoop*, llvm::SmallVector<llvm::MachineBasicBlock*, 8u>, llvm::DenseMapInfo<llvm::MachineLoop*, void>, llvm::detail::DenseMapPair<llvm::MachineLoop*, llvm::SmallVector<llvm::MachineBasicBlock*, 8u>>>::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 0x1d48444
testl %ebp, %ebp
je 0x1d4884f
decl %ebp
je 0x1d48853
bsrl %ebp, %eax
xorl $0x1f, %eax
jmp 0x1d48858
xorl %ebp, %ebp
jmp 0x1d4886e
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), %eax
cmpl %eax, %ebp
jne 0x1d48946
movq $0x0, 0x8(%rbx)
testq %rax, %rax
je 0x1d48941
movq (%rbx), %rcx
imulq $0x58, %rax, %rax
addq $-0x58, %rax
movabsq $0x2e8ba2e8ba2e8ba3, %rdx # imm = 0x2E8BA2E8BA2E8BA3
mulq %rdx
movq %rdx, %xmm0
shrq $0x4, %rdx
addq $0x2, %rdx
andq $-0x2, %rdx
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
psrlq $0x4, %xmm0
xorl %eax, %eax
movdqa 0xe6c759(%rip), %xmm1 # 0x2bb5020
movdqa 0xe6c761(%rip), %xmm2 # 0x2bb5030
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movq %rax, %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 0x1d4891a
movq $-0x1000, (%rcx) # imm = 0xF000
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %esi
testb $0x1, %sil
je 0x1d48931
movq $-0x1000, 0x58(%rcx) # imm = 0xF000
addq $0x2, %rax
addq $0xb0, %rcx
cmpq %rax, %rdx
jne 0x1d488d7
popq %rbx
popq %r14
popq %rbp
retq
movq (%rbx), %rdi
imulq $0x58, %r14, %rsi
movl $0x8, %edx
callq 0x2b410f1
movq %rbx, %rdi
movl %ebp, %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x1d48092
nop
|
/llvm/ADT/DenseMap.h
|
(anonymous namespace)::MachineLICMBase::IsLICMCandidate(llvm::MachineInstr&, llvm::MachineLoop*)
|
bool MachineLICMBase::IsLICMCandidate(MachineInstr &I, MachineLoop *CurLoop) {
// Check if it's safe to move the instruction.
bool DontMoveAcrossStore = !HoistConstLoads || !AllowedToHoistLoads[CurLoop];
if ((!I.isSafeToMove(AA, DontMoveAcrossStore)) &&
!(HoistConstStores && isInvariantStore(I, TRI, MRI))) {
LLVM_DEBUG(dbgs() << "LICM: Instruction not safe to move.\n");
return false;
}
// If it is a load then check if it is guaranteed to execute by making sure
// that it dominates all exiting blocks. If it doesn't, then there is a path
// out of the loop which does not execute this load, so we can't hoist it.
// Loads from constant memory are safe to speculate, for example indexed load
// from a jump table.
// Stores and side effects are already checked by isSafeToMove.
if (I.mayLoad() && !mayLoadFromGOTOrConstantPool(I) &&
!IsGuaranteedToExecute(I.getParent(), CurLoop)) {
LLVM_DEBUG(dbgs() << "LICM: Load not guaranteed to execute.\n");
return false;
}
// Convergent attribute has been used on operations that involve inter-thread
// communication which results are implicitly affected by the enclosing
// control flows. It is not safe to hoist or sink such operations across
// control flow.
if (I.isConvergent())
return false;
if (!TII->shouldHoist(I, CurLoop))
return false;
return true;
}
|
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rdx, 0x10(%rsp)
movb $0x1, %al
cmpb $0x1, 0x3c0917f(%rip) # 0x5952218
jne 0x1d490b1
leaq 0x1a8(%r14), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1d48adc
movb 0x8(%rax), %al
xorb $0x1, %al
leaq 0xf(%rsp), %rdx
movb %al, (%rdx)
movq 0x180(%r14), %rsi
movq %rbx, %rdi
callq 0x1d3ed6c
testb %al, %al
je 0x1d4911c
movq %rbx, %rdi
movl $0x1, %esi
callq 0x90f34a
testb %al, %al
je 0x1d491e8
movq 0x30(%rbx), %rax
cmpq $0x8, %rax
jb 0x1d491e8
leaq 0x30(%rbx), %rdx
movq %rax, %rcx
andq $0x7, %rcx
je 0x1d49142
cmpl $0x3, %ecx
setne %cl
andq $-0x8, %rax
sete %sil
orb %cl, %sil
jne 0x1d491e8
cmpl $0x0, (%rax)
jne 0x1d49145
jmp 0x1d491e8
cmpb $0x1, 0x3c09035(%rip) # 0x5952158
jne 0x1d491f9
movq 0x48(%r14), %rsi
movq 0x58(%r14), %rdx
movq %rbx, %rdi
callq 0x1d4921a
testb %al, %al
jne 0x1d490cb
jmp 0x1d491f9
movq %rax, (%rdx)
movq (%rdx), %rsi
xorl %eax, %eax
movl $0x0, %ecx
cmpq $0x8, %rsi
jb 0x1d4918d
movq %rsi, %rax
andq $0x7, %rax
je 0x1d49182
cmpl $0x3, %eax
setne %cl
andq $-0x8, %rsi
sete %dl
xorl %eax, %eax
orb %cl, %dl
movl $0x0, %ecx
jne 0x1d4918d
movslq (%rsi), %rcx
addq $0x10, %rsi
movq %rsi, %rax
jmp 0x1d4918d
movq %rsi, (%rdx)
movl $0x1, %ecx
movq %rdx, %rax
testq %rcx, %rcx
setne %dl
je 0x1d491ce
shlq $0x3, %rcx
xorl %esi, %esi
movq (%rax,%rsi), %rdi
movq (%rdi), %rdi
testb $0x4, %dil
sete %r8b
andq $-0x8, %rdi
sete %r9b
orb %r8b, %r9b
jne 0x1d491c2
movl 0x8(%rdi), %edi
orl $0x2, %edi
cmpl $0x3, %edi
je 0x1d491ce
addq $0x8, %rsi
cmpq %rsi, %rcx
setne %dl
jne 0x1d4919b
testb $0x1, %dl
jne 0x1d491e8
movq 0x18(%rbx), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x1d49326
testb %al, %al
je 0x1d491f9
movq %rbx, %rdi
movl $0x1, %esi
callq 0x158fb86
testb %al, %al
je 0x1d491fd
xorl %eax, %eax
jmp 0x1d49212
movq 0x38(%r14), %rdi
movq 0x10(%rsp), %rdx
movq (%rdi), %rax
movq %rbx, %rsi
callq *0xb0(%rax)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
|
/CodeGen/MachineLICM.cpp
|
(anonymous namespace)::MachineLICMBase::IsProfitableToHoist(llvm::MachineInstr&, llvm::MachineLoop*)
|
bool MachineLICMBase::IsProfitableToHoist(MachineInstr &MI,
MachineLoop *CurLoop) {
if (MI.isImplicitDef())
return true;
// Besides removing computation from the loop, hoisting an instruction has
// these effects:
//
// - The value defined by the instruction becomes live across the entire
// loop. This increases register pressure in the loop.
//
// - If the value is used by a PHI in the loop, a copy will be required for
// lowering the PHI after extending the live range.
//
// - When hoisting the last use of a value in the loop, that value no longer
// needs to be live in the loop. This lowers register pressure in the loop.
if (HoistConstStores && isCopyFeedingInvariantStore(MI, MRI, TRI))
return true;
bool CheapInstr = IsCheapInstruction(MI);
bool CreatesCopy = HasLoopPHIUse(&MI, CurLoop);
// Don't hoist a cheap instruction if it would create a copy in the loop.
if (CheapInstr && CreatesCopy) {
LLVM_DEBUG(dbgs() << "Won't hoist cheap instr with loop PHI use: " << MI);
return false;
}
// Rematerializable instructions should always be hoisted providing the
// register allocator can just pull them down again when needed.
if (isTriviallyReMaterializable(MI))
return true;
// FIXME: If there are long latency loop-invariant instructions inside the
// loop at this point, why didn't the optimizer's LICM hoist them?
for (unsigned i = 0, e = MI.getDesc().getNumOperands(); i != e; ++i) {
const MachineOperand &MO = MI.getOperand(i);
if (!MO.isReg() || MO.isImplicit())
continue;
Register Reg = MO.getReg();
if (!Reg.isVirtual())
continue;
if (MO.isDef() && HasHighOperandLatency(MI, i, Reg, CurLoop)) {
LLVM_DEBUG(dbgs() << "Hoist High Latency: " << MI);
++NumHighLatency;
return true;
}
}
// Estimate register pressure to determine whether to LICM the instruction.
// In low register pressure situation, we can be more aggressive about
// hoisting. Also, favors hoisting long latency instructions even in
// moderately high pressure situation.
// Cheap instructions will only be hoisted if they don't increase register
// pressure at all.
auto Cost = calcRegisterCost(&MI, /*ConsiderSeen=*/false,
/*ConsiderUnseenAsDef=*/false);
// Visit BBs from header to current BB, if hoisting this doesn't cause
// high register pressure, then it's safe to proceed.
if (!CanCauseHighRegPressure(Cost, CheapInstr)) {
LLVM_DEBUG(dbgs() << "Hoist non-reg-pressure: " << MI);
++NumLowRP;
return true;
}
// Don't risk increasing register pressure if it would create copies.
if (CreatesCopy) {
LLVM_DEBUG(dbgs() << "Won't hoist instr with loop PHI use: " << MI);
return false;
}
// Do not "speculate" in high register pressure situation. If an
// instruction is not guaranteed to be executed in the loop, it's best to be
// conservative.
if (AvoidSpeculation &&
(!IsGuaranteedToExecute(MI.getParent(), CurLoop) && !MayCSE(&MI))) {
LLVM_DEBUG(dbgs() << "Won't speculate: " << MI);
return false;
}
// If we have a COPY with other uses in the loop, hoist to allow the users to
// also be hoisted.
// TODO: Handle all isCopyLike?
if (MI.isCopy() || MI.isRegSequence()) {
Register DefReg = MI.getOperand(0).getReg();
if (DefReg.isVirtual() &&
all_of(MI.uses(),
[this](const MachineOperand &UseOp) {
return !UseOp.isReg() || UseOp.getReg().isVirtual() ||
MRI->isConstantPhysReg(UseOp.getReg());
}) &&
IsLoopInvariantInst(MI, CurLoop) &&
any_of(MRI->use_nodbg_instructions(DefReg),
[&CurLoop, this, DefReg, Cost](MachineInstr &UseMI) {
if (!CurLoop->contains(&UseMI))
return false;
// COPY is a cheap instruction, but if moving it won't cause
// high RP we're fine to hoist it even if the user can't be
// hoisted later Otherwise we want to check the user if it's
// hoistable
if (CanCauseHighRegPressure(Cost, false) &&
!CurLoop->isLoopInvariant(UseMI, DefReg))
return false;
return true;
}))
return true;
}
// High register pressure situation, only hoist if the instruction is going
// to be remat'ed.
if (!isTriviallyReMaterializable(MI) &&
!MI.isDereferenceableInvariantLoad()) {
LLVM_DEBUG(dbgs() << "Can't remat / high reg-pressure: " << MI);
return false;
}
return true;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movq %rdx, 0x30(%rsp)
movzwl 0x44(%rsi), %eax
movb $0x1, %bpl
cmpw $0xa, %ax
je 0x1d4ae70
movq %rsi, %r13
movq %rdi, 0x10(%rsp)
cmpb $0x1, 0x3c07bf6(%rip) # 0x5952158
jne 0x1d4a60e
cmpw $0x13, %ax
jne 0x1d4a60e
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rbx
movq 0x58(%rax), %r15
movq %r13, %rdi
callq 0x1d3de64
movq 0x20(%r13), %rcx
movl 0x24(%rcx), %esi
testl %esi, %esi
js 0x1d4a60e
movq (%rbx), %rcx
movq %rbx, %rdi
movq %rax, %rdx
callq *0xa0(%rcx)
testb %al, %al
je 0x1d4a60e
movq 0x20(%r13), %rax
movl 0x4(%rax), %esi
movq %r15, %rdi
callq 0x986158
testq %rax, %rax
je 0x1d4a60e
movq %rax, %r12
movq %r13, %r14
movq 0x8(%r12), %r13
movq %r13, %rdi
movl $0x1, %esi
callq 0x90f36e
testb %al, %al
je 0x1d4a5eb
movq %r13, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1d4921a
testb %al, %al
jne 0x1d4ae70
movq 0x8(%r12), %rax
movq %r14, %r13
movq 0x18(%r12), %r12
testq %r12, %r12
je 0x1d4a60e
testb $0x1, 0x3(%r12)
jne 0x1d4a5f3
cmpq %rax, 0x8(%r12)
je 0x1d4a5f3
jmp 0x1d4a5bc
movq 0x10(%rsp), %r15
movq 0x38(%r15), %rdi
movq (%rdi), %rax
movq %r13, %rsi
callq *0xa0(%rax)
movb $0x1, %bl
testb %al, %al
movq %r13, 0x18(%rsp)
jne 0x1d4a736
movzwl 0x44(%r13), %eax
cmpl $0xb, %eax
je 0x1d4a736
cmpl $0x13, %eax
je 0x1d4a736
movq 0x10(%r13), %rax
movzbl 0x4(%rax), %ebp
testl %ebp, %ebp
sete %al
movzwl 0x28(%r13), %ecx
movzbl 0x2a(%r13), %r14d
shll $0x10, %r14d
orl %ecx, %r14d
testl $0xffffff, %r14d # imm = 0xFFFFFF
sete %cl
orb %al, %cl
je 0x1d4a67c
xorl %ebx, %ebx
jmp 0x1d4a736
leaq 0x60(%r15), %rax
movq %rax, 0x20(%rsp)
andl $0xffffff, %r14d # imm = 0xFFFFFF
decq %r14
movl $0x4, %r12d
xorl %r15d, %r15d
movl $0x10000ff, %edi # imm = 0x10000FF
xorl %ebx, %ebx
xorl %r13d, %r13d
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rcx
movl -0x4(%rcx,%r12), %edx
andl %edi, %edx
movl $0x4, %eax
cmpl $0x1000000, %edx # imm = 0x1000000
jne 0x1d4a707
decl %ebp
movl (%rcx,%r12), %ecx
decl %ecx
cmpl $0x3fffffff, %ecx # imm = 0x3FFFFFFF
jb 0x1d4a707
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rdi
movq (%rdi), %rax
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movl %r15d, %ecx
callq *0x430(%rax)
movl $0x10000ff, %edi # imm = 0x10000FF
movzbl %r13b, %r13d
testb %al, %al
movl $0x1, %ecx
cmovnel %ecx, %r13d
xorb $0x1, %al
movzbl %al, %eax
testb $0x3, %al
jne 0x1d4a729
testl %ebp, %ebp
sete %al
cmpq %r15, %r14
leaq 0x1(%r15), %r15
sete %bl
orb %al, %bl
addq $0x20, %r12
cmpb $0x1, %bl
jne 0x1d4a6a2
andb %r13b, %bl
movq 0x18(%rsp), %r13
movq 0x10(%rsp), %r15
movl %ebx, 0x3c(%rsp)
movq 0x30(%rsp), %rbx
leaq 0xe8(%rsp), %rax
movq %rax, -0x10(%rax)
movabsq $0x800000000, %rcx # imm = 0x800000000
movq %rcx, -0x8(%rax)
leaq 0xd8(%rsp), %rdi
movl $0x1, %esi
movq %r13, %rdx
callq 0x1d4b7e2
movq %rbx, 0x20(%rsp)
leaq 0x38(%rbx), %rax
movq %rax, 0x28(%rsp)
leaq 0x1f0(%r15), %rax
movq %rax, 0x40(%rsp)
movl $0x10000ff, %r14d # imm = 0x10000FF
movq 0xd8(%rsp), %rax
movl 0xe0(%rsp), %ecx
movq -0x8(%rax,%rcx,8), %rax
decl %ecx
movl %ecx, 0xe0(%rsp)
movq 0x20(%rax), %r12
movzwl 0x28(%rax), %ecx
movzbl 0x2a(%rax), %eax
shll $0x10, %eax
orl %ecx, %eax
movq %r12, %r13
testl %eax, %eax
je 0x1d4a7e4
movl %eax, %ecx
shll $0x5, %ecx
movq %r12, %r13
movl (%r13), %edx
andl %r14d, %edx
cmpl $0x1000000, %edx # imm = 0x1000000
je 0x1d4a7e4
addq $0x20, %r13
addq $-0x20, %rcx
jne 0x1d4a7cb
shll $0x5, %eax
addq %rax, %r12
cmpq %r12, %r13
je 0x1d4aa3a
movl 0x4(%r13), %esi
movl $0x5, %ebp
testl %esi, %esi
jns 0x1d4a9fb
movq 0x58(%r15), %rdi
callq 0x986158
testq %rax, %rax
je 0x1d4a9eb
movq %rax, %rbx
movq 0x8(%rbx), %r15
movzwl 0x44(%r15), %eax
testl $0xffbf, %eax # imm = 0xFFBF
je 0x1d4a87b
xorl %ebp, %ebp
cmpw $0x13, %ax
jne 0x1d4a9bf
movq 0x18(%r15), %rsi
movq 0x28(%rsp), %rdi
callq 0x90b7be
movq 0x20(%rsp), %rsi
movq 0x40(%rsi), %rcx
xorl %edx, %edx
cmpq 0x38(%rsi), %rcx
sete %dl
movl 0x48(%rsi,%rdx,4), %edx
leaq (%rcx,%rdx,8), %rcx
cmpq %rcx, %rax
je 0x1d4a9bf
leaq 0xd8(%rsp), %rdi
movq %r15, %rsi
callq 0xb379c4
jmp 0x1d4a9bf
movq 0x18(%r15), %rsi
movq 0x28(%rsp), %rdi
callq 0x90b7be
movq 0x20(%rsp), %rsi
movq 0x40(%rsi), %rcx
xorl %edx, %edx
cmpq 0x38(%rsi), %rcx
sete %dl
movl 0x48(%rsi,%rdx,4), %edx
leaq (%rcx,%rdx,8), %rcx
movl $0x1, %ebp
cmpq %rcx, %rax
jne 0x1d4a9bf
movq 0x18(%r15), %rax
movq 0x20(%rsp), %rcx
movq %rcx, 0x48(%rsp)
movq %rax, 0x58(%rsp)
movq %rcx, 0x78(%rsp)
movq 0x40(%rsp), %r15
movq %r15, %rdi
leaq 0x78(%rsp), %rbp
movq %rbp, %rsi
leaq 0xc8(%rsp), %rdx
callq 0x1d4ba3e
testb %al, %al
je 0x1d4a927
movq %r15, %rdi
leaq 0x48(%rsp), %rsi
callq 0x1d4bad0
movq %rax, %r15
movq 0x8(%rax), %rdi
movl 0x10(%rax), %eax
leaq (%rdi,%rax,8), %rsi
leaq 0x58(%rsp), %rdx
callq 0x1d0f258
movl 0x10(%r15), %ecx
shlq $0x3, %rcx
addq 0x8(%r15), %rcx
cmpq %rcx, %rax
setne %bpl
jmp 0x1d4a9af
leaq 0x88(%rsp), %rax
movq %rax, 0x78(%rsp)
movabsq $0x800000000, %rax # imm = 0x800000000
movq %rax, 0x80(%rsp)
movq 0x48(%rsp), %rdi
movq %rbp, %rsi
callq 0x1d4cf54
movq %r15, %rdi
leaq 0x48(%rsp), %rsi
callq 0x1d4bad0
leaq 0x8(%rax), %rdi
movq %rbp, %rsi
callq 0x15a0034
movq 0x78(%rsp), %rdi
movl 0x80(%rsp), %eax
leaq (%rdi,%rax,8), %rsi
leaq 0x58(%rsp), %rdx
callq 0x1d0f258
movq 0x78(%rsp), %rdi
movl 0x80(%rsp), %ecx
leaq (%rdi,%rcx,8), %rcx
cmpq %rcx, %rax
setne %bpl
leaq 0x88(%rsp), %rax
cmpq %rax, %rdi
je 0x1d4a9af
callq 0x780910
testb %bpl, %bpl
movl $0x7, %ebp
movl $0x1, %eax
cmovnel %eax, %ebp
cmpl $0x7, %ebp
je 0x1d4a9c8
testl %ebp, %ebp
jne 0x1d4aa26
movq 0x8(%rbx), %rax
movq 0x10(%rsp), %r15
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
je 0x1d4a9eb
testb $0x1, 0x3(%rbx)
jne 0x1d4a9d1
cmpq %rax, 0x8(%rbx)
je 0x1d4a9d1
jmp 0x1d4a819
movl $0x6, %ebp
cmpl $0x6, %ebp
movl $0x0, %eax
cmovel %eax, %ebp
cmpl $0x5, %ebp
je 0x1d4aa04
testl %ebp, %ebp
jne 0x1d4aa32
addq $0x20, %r13
cmpq %r12, %r13
je 0x1d4aa1b
movl (%r13), %eax
andl %r14d, %eax
cmpl $0x1000000, %eax # imm = 0x1000000
jne 0x1d4aa04
cmpq %r12, %r13
jne 0x1d4a7f3
jmp 0x1d4aa2d
movq 0x10(%rsp), %r15
jmp 0x1d4a9f0
movl $0x4, %ebp
cmpl $0x4, %ebp
setne %bl
jmp 0x1d4aa3c
xorl %ebx, %ebx
testb %bl, %bl
jne 0x1d4aa4e
cmpl $0x0, 0xe0(%rsp)
jne 0x1d4a78e
movq 0xd8(%rsp), %rdi
leaq 0xe8(%rsp), %rax
cmpq %rax, %rdi
je 0x1d4aa68
callq 0x780910
testb %bl, 0x3c(%rsp)
movq 0x18(%rsp), %r12
je 0x1d4aa7a
xorl %ebp, %ebp
jmp 0x1d4ae70
movq %r15, %rdi
movq %r12, %rsi
callq 0x1d4aeb2
movb $0x1, %bpl
testb %al, %al
jne 0x1d4ae70
movq 0x10(%r12), %rax
movzwl 0x2(%rax), %r13d
testq %r13, %r13
je 0x1d4aca4
movq 0x10(%rsp), %rax
addq $0x60, %rax
movq %rax, 0x70(%rsp)
xorl %r15d, %r15d
movq 0x20(%r12), %rcx
movq %r15, %rdx
shlq $0x5, %rdx
movl (%rcx,%rdx), %eax
movl $0x6, %ebp
testl $0x20000ff, %eax # imm = 0x20000FF
jne 0x1d4ac8b
addq %rdx, %rcx
movl 0x4(%rcx), %r14d
testl %r14d, %r14d
jns 0x1d4ac8b
xorl %ebp, %ebp
btl $0x18, %eax
jae 0x1d4ac8b
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rdi
movl %r14d, %esi
callq 0x96036a
testq %rax, %rax
je 0x1d4ac8b
movq %r13, 0x28(%rsp)
movq 0x10(%rsp), %rax
movq 0x58(%rax), %rdi
movl %r14d, 0x40(%rsp)
movl %r14d, %esi
callq 0x9108c0
testq %rax, %rax
je 0x1d4ac81
movq %rax, %r13
movq 0x20(%rsp), %rax
leaq 0x38(%rax), %r14
movq 0x8(%r13), %r12
movzwl 0x44(%r12), %eax
movl $0x3, %ecx
cmpl $0xb, %eax
je 0x1d4ac54
cmpl $0x13, %eax
je 0x1d4ac54
movq 0x18(%r12), %rsi
movq %r14, %rdi
callq 0x90b7be
movl 0x40(%rsp), %esi
movq 0x20(%rsp), %rdi
movq 0x40(%rdi), %rcx
xorl %edx, %edx
cmpq 0x38(%rdi), %rcx
sete %dl
movl 0x48(%rdi,%rdx,4), %edx
leaq (%rcx,%rdx,8), %rcx
cmpq %rcx, %rax
movl $0x3, %ecx
je 0x1d4ac54
movq %r14, 0x60(%rsp)
movzwl 0x28(%r12), %ecx
movzbl 0x2a(%r12), %eax
shll $0x10, %eax
orl %ecx, %eax
testl %eax, %eax
je 0x1d4ac3f
movq %r12, %r9
movl %eax, %edx
movl $0x4, %r14d
xorl %r12d, %r12d
movq %r9, 0x50(%rsp)
movq %rdx, 0x68(%rsp)
movq 0x20(%r9), %rax
movl $0x6, %ecx
testl $0x10000ff, -0x4(%rax,%r14) # imm = 0x10000FF
jne 0x1d4ac2a
cmpl %esi, (%rax,%r14)
jne 0x1d4ac2a
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rdi
movq 0x58(%rax), %rdx
movq (%rdi), %rax
movl %r12d, (%rsp)
movq 0x70(%rsp), %rsi
movq 0x18(%rsp), %rcx
movl %r15d, %r8d
movq 0x50(%rsp), %r9
callq *0x428(%rax)
movq 0x68(%rsp), %rdx
movq 0x50(%rsp), %r9
movl 0x40(%rsp), %esi
movzbl %al, %ecx
cmpl $0x6, %ecx
je 0x1d4ac33
testl %ecx, %ecx
jne 0x1d4ac44
incq %r12
addq $0x20, %r14
cmpq %r12, %rdx
jne 0x1d4abd3
movl $0x4, %ecx
cmpl $0x4, %ecx
movl $0x2, %eax
cmovel %eax, %ecx
movq 0x60(%rsp), %r14
cmpl $0x3, %ecx
jne 0x1d4ac78
movq 0x8(%r13), %rax
movq 0x18(%r13), %r13
testq %r13, %r13
je 0x1d4ac81
testb $-0x7f, 0x3(%r13)
jne 0x1d4ac5d
cmpq %rax, 0x8(%r13)
je 0x1d4ac5d
jmp 0x1d4ab43
xorl %ebp, %ebp
cmpl $0x2, %ecx
setne %bpl
movq 0x18(%rsp), %r12
movq 0x28(%rsp), %r13
cmpl $0x6, %ebp
je 0x1d4ac98
testl %ebp, %ebp
jne 0x1d4ae03
incq %r15
cmpq %r13, %r15
jne 0x1d4aab4
leaq 0x78(%rsp), %r14
movq %r14, %rdi
movq 0x10(%rsp), %r15
movq %r15, %rsi
movq %r12, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x1d4af5a
movzbl 0x3c(%rsp), %edx
andl $0x1, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1d4b158
movl %eax, %ebp
xorb $0x1, %bpl
orb %bpl, %bl
jne 0x1d4ae56
cmpb $0x1, 0x3c072ee(%rip) # 0x5951fd8
jne 0x1d4ad15
movq 0x18(%r12), %rsi
movq 0x30(%rsp), %rdx
movq %r15, %rdi
callq 0x1d49326
testb %al, %al
jne 0x1d4ad15
movq %r15, %rdi
movq %r12, %rsi
callq 0x1d4b252
testb %al, %al
je 0x1d4ae54
movzwl 0x44(%r12), %eax
andl $-0x2, %eax
cmpw $0x12, %ax
jne 0x1d4ae34
movq 0x20(%r12), %r14
movl 0x4(%r14), %ebx
testl %ebx, %ebx
jns 0x1d4ae08
movq %r12, %rdi
callq 0x1d3dfae
movzbl 0x2a(%r12), %ecx
movzwl 0x28(%r12), %edx
shll $0x5, %edx
shll $0x15, %ecx
orl %edx, %ecx
movl %eax, %eax
shlq $0x5, %rax
addq 0x20(%r12), %rcx
addq %rax, %r14
leaq 0xd8(%rsp), %rdi
movq %r14, (%rdi)
movq %rcx, 0x8(%rdi)
movq %r15, %rsi
callq 0x1d4b3ed
testb %al, %al
je 0x1d4ae08
movq 0x30(%rsp), %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x1d4a4fa
testb %al, %al
je 0x1d4ae08
movq 0x58(%r15), %rdi
movl %ebx, %esi
callq 0x9108c0
leaq 0xc8(%rsp), %r15
movq %rax, (%r15)
movq $0x0, 0x8(%r15)
leaq 0x30(%rsp), %rax
leaq 0x140(%rsp), %rdi
movq %rax, -0x18(%rdi)
movq 0x10(%rsp), %rax
movq %rax, -0x10(%rdi)
movl %ebx, -0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movl $0x0, 0x10(%rdi)
leaq 0x78(%rsp), %rsi
callq 0x1d4c2ba
leaq 0x128(%rsp), %rsi
movq %r15, %rdi
movq 0x10(%rsp), %r15
callq 0x1d4b56b
movl %eax, %ebx
movb $0x1, %al
jmp 0x1d4ae0c
movb $0x1, %bpl
jmp 0x1d4ae70
xorl %eax, %eax
xorl %ebx, %ebx
testb %al, %al
je 0x1d4ae2d
movq 0x140(%rsp), %rdi
movl 0x150(%rsp), %esi
shlq $0x3, %rsi
movl $0x4, %edx
callq 0x2b410f1
movb $0x1, %bpl
testb %bl, %bl
jne 0x1d4ae56
movq %r15, %rdi
movq %r12, %rsi
callq 0x1d4aeb2
testb %al, %al
jne 0x1d4ae4f
movq %r12, %rdi
callq 0x1d3f0c4
testb %al, %al
je 0x1d4ae54
movb $0x1, %bpl
jmp 0x1d4ae56
xorl %ebp, %ebp
movq 0x78(%rsp), %rdi
movl 0x88(%rsp), %esi
shlq $0x3, %rsi
movl $0x4, %edx
callq 0x2b410f1
movl %ebp, %eax
addq $0x158, %rsp # imm = 0x158
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/CodeGen/MachineLICM.cpp
|
std::pair<llvm::DenseMapIterator<llvm::Register, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::Register, void>, llvm::detail::DenseSetPair<llvm::Register>, false>, bool> llvm::DenseMapBase<llvm::SmallDenseMap<llvm::Register, llvm::detail::DenseSetEmpty, 4u, llvm::DenseMapInfo<llvm::Register, void>, llvm::detail::DenseSetPair<llvm::Register>>, llvm::Register, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::Register, void>, llvm::detail::DenseSetPair<llvm::Register>>::try_emplace<llvm::detail::DenseSetEmpty&>(llvm::Register const&, llvm::detail::DenseSetEmpty&)
|
std::pair<iterator, bool> try_emplace(const KeyT &Key, Ts &&... Args) {
BucketT *TheBucket;
if (LookupBucketFor(Key, TheBucket))
return std::make_pair(makeIterator(TheBucket,
shouldReverseIterate<KeyT>()
? getBuckets()
: getBucketsEnd(),
*this, true),
false); // Already in map.
// Otherwise, insert the new element.
TheBucket = InsertIntoBucket(TheBucket, Key, std::forward<Ts>(Args)...);
return std::make_pair(makeIterator(TheBucket,
shouldReverseIterate<KeyT>()
? getBuckets()
: getBucketsEnd(),
*this, true),
true);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r12
movq %rsi, %rdi
movq %rdx, %rsi
movq %r12, %rdx
callq 0x1d4bf6c
movl %eax, %ecx
movq (%r12), %rax
testb %cl, %cl
je 0x1d4bf20
xorl %ecx, %ecx
jmp 0x1d4bf38
movq %r14, %rdi
movq %r15, %rsi
movq %r15, %rdx
movq %rax, %rcx
callq 0x1d4bffe
movl (%r15), %ecx
movl %ecx, (%rax)
movb $0x1, %cl
leaq 0x8(%r14), %rdx
testb $0x1, (%r14)
cmoveq 0x8(%r14), %rdx
movl $0x4, %esi
cmovel 0x10(%r14), %esi
leaq (%rdx,%rsi,4), %rdx
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
movb %cl, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
|
/llvm/ADT/DenseMap.h
|
llvm::DenseMap<llvm::MachineLoop const*, llvm::detail::DenseSetEmpty, llvm::DenseMapInfo<llvm::MachineLoop const*, void>, llvm::detail::DenseSetPair<llvm::MachineLoop const*>>::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 $0x3, %rdi
movl $0x8, %esi
callq 0x2b410ec
movq %rax, (%r15)
testq %r14, %r14
je 0x1d5039a
leaq (%r14,%rbx,8), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1d5045c
shlq $0x3, %rbx
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 0x1d50455
movabsq $0x1fffffffffffffff, %rdx # imm = 0x1FFFFFFFFFFFFFFF
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]
xorl %edx, %edx
movdqa 0xe64c40(%rip), %xmm1 # 0x2bb5020
movdqa 0xe64c48(%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 0x1d50434
movq $-0x1000, (%rax,%rdx,8) # imm = 0xF000
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %esi
testb $0x1, %sil
je 0x1d5044c
movq $-0x1000, 0x8(%rax,%rdx,8) # imm = 0xF000
addq $0x2, %rdx
cmpq %rdx, %rcx
jne 0x1d503f0
popq %rbx
popq %r14
popq %r15
retq
nop
|
/llvm/ADT/DenseMap.h
|
llvm::SmallVectorTemplateBase<std::tuple<llvm::DomTreeNodeBase<llvm::MachineBasicBlock> const*, llvm::DomTreeNodeBase<llvm::MachineBasicBlock>* const*, llvm::DomTreeNodeBase<llvm::MachineBasicBlock>* const*>, false>::grow(unsigned long)
|
void SmallVectorTemplateBase<T, TriviallyCopyable>::grow(size_t MinSize) {
size_t NewCapacity;
T *NewElts = mallocForGrow(MinSize, NewCapacity);
moveElementsForGrow(NewElts);
takeAllocationForGrow(NewElts, NewCapacity);
}
|
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x10(%rdi), %r14
movq %rsp, %r8
movl $0x18, %ecx
movq %r14, %rsi
callq 0x2b4ec3c
movq %rax, %r15
movl 0x8(%rbx), %ecx
testq %rcx, %rcx
je 0x1d50a89
movq (%rbx), %rax
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rcx
xorl %edx, %edx
leaq (%rax,%rdx), %rsi
addq $0x18, %rsi
movq -0x18(%rsi), %rdi
movq %rdi, (%r15,%rdx)
movq -0x10(%rsi), %rdi
movq %rdi, 0x8(%r15,%rdx)
movq -0x8(%rsi), %rdi
movq %rdi, 0x10(%r15,%rdx)
addq $0x18, %rdx
cmpq %rcx, %rsi
jne 0x1d50a5e
movq (%rsp), %r12
movq (%rbx), %rdi
cmpq %r14, %rdi
je 0x1d50a9a
callq 0x780910
movq %r15, (%rbx)
movl %r12d, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
|
/llvm/ADT/SmallVector.h
|
llvm::MachineOperand::ChangeToTargetIndex(unsigned int, long, unsigned int)
|
void MachineOperand::ChangeToTargetIndex(unsigned Idx, int64_t Offset,
unsigned TargetFlags) {
assert((!isReg() || !isTied()) &&
"Cannot change a tied operand into a FrameIndex");
removeRegFromUses();
OpKind = MO_TargetIndex;
setIndex(Idx);
setOffset(Offset);
setTargetFlags(TargetFlags);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
callq 0x1d53384
movl (%r15), %eax
orl $0x7, %eax
movl %ebp, 0x10(%r15)
movl %r14d, 0x4(%r15)
shrq $0x20, %r14
movl %r14d, 0x18(%r15)
shll $0x8, %ebx
andl $0xfff00, %ebx # imm = 0xFFF00
andl $0xfff00007, %eax # imm = 0xFFF00007
orl %ebx, %eax
movl %eax, (%r15)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
|
/CodeGen/MachineOperand.cpp
|
llvm::MachineOperand::ChangeToRegister(llvm::Register, bool, bool, bool, bool, bool, bool)
|
void MachineOperand::ChangeToRegister(Register Reg, bool isDef, bool isImp,
bool isKill, bool isDead, bool isUndef,
bool isDebug) {
MachineRegisterInfo *RegInfo = nullptr;
if (MachineFunction *MF = getMFIfAvailable(*this))
RegInfo = &MF->getRegInfo();
// If this operand is already a register operand, remove it from the
// register's use/def lists.
bool WasReg = isReg();
if (RegInfo && WasReg)
RegInfo->removeRegOperandFromUseList(this);
// Ensure debug instructions set debug flag on register uses.
const MachineInstr *MI = getParent();
if (!isDef && MI && MI->isDebugInstr())
isDebug = true;
// Change this to a register and set the reg#.
assert(!(isDead && !isDef) && "Dead flag on non-def");
assert(!(isKill && isDef) && "Kill flag on def");
OpKind = MO_Register;
SmallContents.RegNo = Reg;
SubReg_TargetFlags = 0;
IsDef = isDef;
IsImp = isImp;
IsDeadOrKill = isKill | isDead;
IsRenamable = false;
IsUndef = isUndef;
IsInternalRead = false;
IsEarlyClobber = false;
IsDebug = isDebug;
// Ensure isOnRegUseList() returns false.
Contents.Reg.Prev = nullptr;
// Preserve the tie when the operand was already a register.
if (!WasReg)
TiedTo = 0;
// If this operand is embedded in a function, add the operand to the
// register's use/def list.
if (RegInfo)
RegInfo->addRegOperandToUseList(this);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, %r15d
movl %r8d, %r12d
movl %ecx, %r13d
movq %rdi, %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x1d53632
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x1d53632
movq 0x20(%rax), %rax
jmp 0x1d53634
xorl %eax, %eax
testq %rax, %rax
je 0x1d5363f
movq 0x28(%rax), %rdi
jmp 0x1d53641
xorl %edi, %edi
movb 0x58(%rsp), %bpl
movb 0x50(%rsp), %r14b
movzbl (%rbx), %r11d
testl %r11d, %r11d
setne %al
testq %rdi, %rdi
sete %r10b
orb %al, %r10b
jne 0x1d5369b
movl %esi, 0xc(%rsp)
movq %rbx, %rsi
movb %r14b, 0xa(%rsp)
movl %edx, %r14d
movq %rdi, 0x10(%rsp)
movb %bpl, 0xb(%rsp)
movl %r11d, %ebp
callq 0x1d8341a
movl %ebp, %r11d
movb 0xb(%rsp), %bpl
movq 0x10(%rsp), %rdi
movl %r14d, %edx
movb 0xa(%rsp), %r14b
movl 0xc(%rsp), %esi
movq 0x8(%rbx), %rax
testq %rax, %rax
sete %r10b
orb %dl, %r10b
jne 0x1d536bb
movl 0x44(%rax), %eax
addl $-0xd, %eax
cmpw $0x5, %ax
setb %al
orb %al, %bpl
movzbl %dl, %eax
shll $0x18, %eax
movl $0xf00000, %r10d # imm = 0xF00000
andl (%rbx), %r10d
movzbl %r13b, %edx
shll $0x19, %edx
orl %eax, %edx
orb %r15b, %r12b
movzbl %r12b, %eax
shll $0x1a, %eax
orl %edx, %eax
movzbl %r14b, %edx
shll $0x1c, %edx
orl %eax, %edx
movzbl %bpl, %eax
shll $0x1f, %eax
orl %edx, %eax
orl %eax, %r10d
movl %esi, 0x4(%rbx)
movl %r10d, (%rbx)
movq $0x0, 0x10(%rbx)
testl %r11d, %r11d
je 0x1d53709
movl %eax, (%rbx)
testq %rdi, %rdi
je 0x1d53724
movq %rbx, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1d833ac
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/CodeGen/MachineOperand.cpp
|
llvm::cl::opt<int, false, llvm::cl::parser<int>>::opt<char [28], llvm::cl::desc, llvm::cl::OptionHidden, llvm::cl::initializer<int>>(char const (&) [28], llvm::cl::desc const&, llvm::cl::OptionHidden const&, llvm::cl::initializer<int> 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 0x7fca88
movl $0x0, 0x80(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%r14)
movb $0x0, 0x94(%r14)
leaq 0x39fc202(%rip), %rax # 0x5757030
addq $0x10, %rax
movq %rax, 0x88(%r14)
leaq 0x3b9ce90(%rip), %rax # 0x58f7cd0
addq $0x10, %rax
movq %rax, (%r14)
leaq 0x3b9cc3a(%rip), %rax # 0x58f7a88
addq $0x10, %rax
movq %rax, 0x98(%r14)
movups %xmm0, 0xa0(%r14)
leaq -0x143f046(%rip), %rax # 0x91be22
movq %rax, 0xb8(%r14)
leaq -0x143f052(%rip), %rax # 0x91be24
movq %rax, 0xb0(%r14)
movq %r14, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x1d6d01e
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2b1e814
|
/llvm/Support/CommandLine.h
|
llvm::SwingSchedulerDAG::calculateResMII()
|
unsigned SwingSchedulerDAG::calculateResMII() {
LLVM_DEBUG(dbgs() << "calculateResMII:\n");
ResourceManager RM(&MF.getSubtarget(), this);
return RM.calculateResMII();
}
|
pushq %r14
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
movq %rdi, %rdx
movq 0x20(%rdi), %rax
movq 0x10(%rax), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x1d63a2e
movq %r14, %rdi
callq 0x1d63b44
movl %eax, %ebx
movq 0x150(%r14), %rdi
leaq 0x160(%rsp), %rax
cmpq %rax, %rdi
je 0x1d5f2f3
callq 0x780910
leaq 0x120(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d5f309
callq 0x780910
leaq 0x70(%rsp), %rdi
callq 0x1d69af2
leaq 0x30(%rsp), %rdi
callq 0x1d69b58
movl %ebx, %eax
addq $0x1e8, %rsp # imm = 0x1E8
popq %rbx
popq %r14
retq
|
/CodeGen/MachinePipeliner.cpp
|
llvm::SmallVectorImpl<llvm::SmallPtrSet<llvm::SUnit*, 4u>>::truncate(unsigned long)
|
void truncate(size_type N) {
assert(this->size() >= N && "Cannot increase size with truncate");
this->destroy_range(this->begin() + N, this->end());
this->set_size(N);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %r15d
cmpq %rsi, %r15
je 0x1d6a212
movq (%r14), %r12
shlq $0x6, %r15
movq %rbx, %r13
shlq $0x6, %r13
movq -0x38(%r12,%r15), %rdi
cmpq -0x40(%r12,%r15), %rdi
je 0x1d6a209
callq 0x780910
addq $-0x40, %r15
cmpq %r15, %r13
jne 0x1d6a1f8
movl %ebx, 0x8(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/llvm/ADT/SmallVector.h
|
llvm::SmallVectorTemplateBase<llvm::SmallVector<int, 4u>, false>::moveElementsForGrow(llvm::SmallVector<int, 4u>*)
|
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), %r12d
testq %r12, %r12
je 0x1d6a474
movq %rsi, %r14
movq (%rbx), %r15
shlq $0x5, %r12
movabsq $0x400000000, %r13 # imm = 0x400000000
leaq 0x10(%r14), %rax
movq %rax, (%r14)
movq %r13, 0x8(%r14)
cmpl $0x0, 0x8(%r15)
je 0x1d6a466
movq %r14, %rdi
movq %r15, %rsi
callq 0xc02f90
addq $0x20, %r15
addq $0x20, %r14
addq $-0x20, %r12
jne 0x1d6a449
movl 0x8(%rbx), %r14d
testq %r14, %r14
je 0x1d6a4a7
movq (%rbx), %rax
shlq $0x5, %r14
leaq (%r14,%rax), %rbx
addq $-0x10, %rbx
negq %r14
movq -0x10(%rbx), %rdi
cmpq %rdi, %rbx
je 0x1d6a49d
callq 0x780910
addq $-0x20, %rbx
addq $0x20, %r14
jne 0x1d6a48f
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/llvm/ADT/SmallVector.h
|
llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::MachineBasicBlock, true>>::RemoveRedundantRoots(llvm::DominatorTreeBase<llvm::MachineBasicBlock, true> const&, llvm::DomTreeBuilder::SemiNCAInfo<llvm::DominatorTreeBase<llvm::MachineBasicBlock, true>>::BatchUpdateInfo*, llvm::SmallVector<llvm::MachineBasicBlock*, 4u>&)
|
static void RemoveRedundantRoots(const DomTreeT &DT, BatchUpdatePtr BUI,
RootsT &Roots) {
assert(IsPostDom && "This function is for postdominators only");
LLVM_DEBUG(dbgs() << "Removing redundant roots\n");
SemiNCAInfo SNCA(BUI);
for (unsigned i = 0; i < Roots.size(); ++i) {
auto &Root = Roots[i];
// Trivial roots are always non-redundant.
if (!HasForwardSuccessors(Root, BUI)) continue;
LLVM_DEBUG(dbgs() << "\tChecking if " << BlockNamePrinter(Root)
<< " remains a root\n");
SNCA.clear();
// Do a forward walk looking for the other roots.
const unsigned Num = SNCA.runDFS<true>(Root, 0, AlwaysDescend, 0);
// Skip the start node and begin from the second one (note that DFS uses
// 1-based indexing).
for (unsigned x = 2; x <= Num; ++x) {
const NodePtr N = SNCA.NumToNode[x];
// If we wound another root in a (forward) DFS walk, remove the current
// root from the set of roots, as it is reverse-reachable from the other
// one.
if (llvm::is_contained(Roots, N)) {
LLVM_DEBUG(dbgs() << "\tForward DFS walk found another root "
<< BlockNamePrinter(N) << "\n\tRemoving root "
<< BlockNamePrinter(Root) << "\n");
std::swap(Root, Roots.back());
Roots.pop_back();
// Root at the back takes the current root's place.
// Start the next loop iteration with the same index.
--i;
break;
}
}
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp # imm = 0x248
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x10(%rsp), %rdx
movq $0x0, -0x8(%rdx)
leaq 0x28(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movabsq $0x4000000000, %rax # imm = 0x4000000000
movq %rax, -0x8(%rcx)
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xbde372
leaq 0x228(%rsp), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movl $0x0, 0x10(%rax)
movq %r14, 0x10(%rsp)
movq %r14, 0x18(%rax)
cmpl $0x0, 0x8(%rbx)
je 0x1d77952
xorl %r15d, %r15d
movl %r15d, %r13d
movq (%rbx), %r14
movq (%r14,%r13,8), %rdi
movq 0x10(%rsp), %rsi
callq 0x1d771a2
testb %al, %al
je 0x1d77945
movq $0x0, 0x8(%rsp)
movl $0x0, 0x20(%rsp)
leaq 0x18(%rsp), %r12
movq %r12, %rdi
leaq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0xbde372
leaq 0x228(%rsp), %rdi
callq 0x1d79080
movq (%r14,%r13,8), %rsi
movq %r12, %rdi
xorl %edx, %edx
leaq -0xbcc(%rip), %rcx # 0x1d76d02
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x1d77594
cmpl $0x2, %eax
jb 0x1d77945
movl %eax, %r12d
movl $0x3, %ebp
leal -0x1(%rbp), %eax
movq 0x18(%rsp), %rcx
movq (%rcx,%rax,8), %rax
movq %rax, 0x8(%rsp)
movq (%rbx), %rdi
movl 0x8(%rbx), %eax
leaq (%rdi,%rax,8), %rsi
leaq 0x8(%rsp), %rdx
callq 0xbc1890
movl 0x8(%rbx), %edx
leaq (,%rdx,8), %rcx
addq (%rbx), %rcx
cmpq %rcx, %rax
je 0x1d77936
movq (%r14,%r13,8), %rsi
movq -0x8(%rcx), %rdi
movq %rdi, (%r14,%r13,8)
movq %rsi, -0x8(%rcx)
decl %edx
movl %edx, 0x8(%rbx)
decl %r15d
cmpq %rcx, %rax
jne 0x1d77945
leal 0x1(%rbp), %eax
cmpl %r12d, %ebp
movl %eax, %ebp
jbe 0x1d778e6
incl %r15d
cmpl %r15d, 0x8(%rbx)
ja 0x1d7786d
leaq 0x228(%rsp), %rdi
callq 0x1d76292
movq 0x228(%rsp), %rdi
movl 0x238(%rsp), %esi
shlq $0x6, %rsi
movl $0x8, %edx
callq 0x2b410f1
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rax
cmpq %rax, %rdi
je 0x1d77990
callq 0x780910
addq $0x248, %rsp # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/llvm/Support/GenericDomTreeConstruction.h
|
llvm::RegionInfoBase<llvm::RegionTraits<llvm::MachineFunction>>::getNextPostDom(llvm::DomTreeNodeBase<llvm::MachineBasicBlock>*, llvm::DenseMap<llvm::MachineBasicBlock*, llvm::MachineBasicBlock*, llvm::DenseMapInfo<llvm::MachineBasicBlock*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock*, llvm::MachineBasicBlock*>>*) const
|
typename Tr::DomTreeNodeT *
RegionInfoBase<Tr>::getNextPostDom(DomTreeNodeT *N, BBtoBBMap *ShortCut) const {
typename BBtoBBMap::iterator e = ShortCut->find(N->getBlock());
if (e == ShortCut->end())
return N->getIDom();
return PDT->getNode(e->second)->getIDom();
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rsi
movq %rdx, %rdi
callq 0x1d7f82a
movl 0x10(%r15), %ecx
shlq $0x4, %rcx
addq (%r15), %rcx
cmpq %rcx, %rax
je 0x1d7f8a6
movq 0x10(%r14), %rdi
movq 0x8(%rax), %rsi
addq $0x30, %rdi
callq 0x9a5526
movq 0x8(%rax), %rbx
movq 0x8(%rbx), %rax
popq %rbx
popq %r14
popq %r15
retq
|
/llvm/Analysis/RegionInfoImpl.h
|
llvm::RegionInfoBase<llvm::RegionTraits<llvm::MachineFunction>>::findRegionsWithEntry(llvm::MachineBasicBlock*, llvm::DenseMap<llvm::MachineBasicBlock*, llvm::MachineBasicBlock*, llvm::DenseMapInfo<llvm::MachineBasicBlock*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock*, llvm::MachineBasicBlock*>>*)
|
void RegionInfoBase<Tr>::findRegionsWithEntry(BlockT *entry,
BBtoBBMap *ShortCut) {
assert(entry);
DomTreeNodeT *N = PDT->getNode(entry);
if (!N)
return;
RegionT *lastRegion = nullptr;
BlockT *lastExit = entry;
// As only a BasicBlock that postdominates entry can finish a region, walk the
// post dominance tree upwards.
while ((N = getNextPostDom(N, ShortCut))) {
BlockT *exit = N->getBlock();
if (!exit)
break;
if (isRegion(entry, exit)) {
RegionT *newRegion = createRegion(entry, exit);
if (lastRegion)
newRegion->addSubRegion(lastRegion);
lastRegion = newRegion;
lastExit = exit;
}
// This can never be a region, so stop the search.
if (!DT->dominates(entry, exit))
break;
}
// Tried to create regions from entry to lastExit. Next time take a
// shortcut from entry to lastExit.
if (lastExit != entry)
insertShortCut(entry, lastExit, ShortCut);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rbx
leaq 0x30(%rbx), %rdi
callq 0x9a5526
movl 0x40(%rbx), %ecx
shlq $0x4, %rcx
addq 0x30(%rbx), %rcx
cmpq %rcx, %rax
je 0x1d7f9b0
movq 0x8(%rax), %r12
jmp 0x1d7f9b3
xorl %r12d, %r12d
testq %r12, %r12
je 0x1d7fa73
xorl %ebx, %ebx
movq %r14, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rsi
movq 0x10(%rsp), %rdx
callq 0x1d7f868
testq %rax, %rax
je 0x1d7fa4b
movq %rax, %r12
movq (%rax), %r13
testq %r13, %r13
je 0x1d7fa1f
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x1d7f5d8
testb %al, %al
je 0x1d7fa23
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x1d7f8d6
movq %rax, %rbp
testq %rbx, %rbx
je 0x1d7fa18
movq %rbp, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x1d7e400
movq %r13, 0x8(%rsp)
jmp 0x1d7fa26
xorl %eax, %eax
jmp 0x1d7fa43
movq %rbx, %rbp
movq 0x8(%r15), %rbx
movq %rbx, %rdi
callq 0x1d29778
movq %rbx, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x1d26d4a
movq %rbp, %rbx
testb %al, %al
jne 0x1d7f9c3
movq 0x8(%rsp), %rdx
cmpq %r14, %rdx
je 0x1d7fa73
movq %r15, %rdi
movq %r14, %rsi
movq 0x10(%rsp), %rcx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1d7f7e6
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/llvm/Analysis/RegionInfoImpl.h
|
llvm::DenseMap<llvm::MachineBasicBlock*, llvm::MachineRegion*, llvm::DenseMapInfo<llvm::MachineBasicBlock*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock*, llvm::MachineRegion*>>::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), %eax
movl 0x10(%rdi), %esi
testl %eax, %eax
je 0x1d81f68
decl %eax
je 0x1d81f6c
bsrl %eax, %eax
xorl $0x1f, %eax
jmp 0x1d81f71
xorl %ebp, %ebp
jmp 0x1d81f87
movl $0x20, %eax
movb $0x21, %cl
subb %al, %cl
movl $0x1, %eax
shll %cl, %eax
cmpl $0x41, %eax
movl $0x40, %ebp
cmovgel %eax, %ebp
cmpl %esi, %ebp
jne 0x1d82057
movq $0x0, 0x8(%rbx)
testq %rsi, %rsi
je 0x1d82050
movq (%rbx), %rax
movabsq $0xfffffffffffffff, %rdx # imm = 0xFFFFFFFFFFFFFFF
addq %rdx, %rsi
andq %rsi, %rdx
andl $0x1, %esi
negq %rsi
leaq (%rdx,%rsi), %rcx
addq $0x2, %rcx
movq %rdx, %xmm0
pshufd $0x44, %xmm0, %xmm0 # xmm0 = xmm0[0,1,0,1]
addq $0x10, %rax
xorl %edx, %edx
movdqa 0xe33047(%rip), %xmm1 # 0x2bb5020
movdqa 0xe3304f(%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 0x1d8202d
movq $-0x1000, -0x10(%rax) # imm = 0xF000
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %esi
testb $0x1, %sil
je 0x1d82043
movq $-0x1000, (%rax) # imm = 0xF000
addq $0x2, %rdx
addq $0x20, %rax
cmpq %rdx, %rcx
jne 0x1d81fe9
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq (%rbx), %rdi
shlq $0x4, %rsi
movl $0x8, %edx
callq 0x2b410f1
movq %rbx, %rdi
movl %ebp, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1d81e1a
|
/llvm/ADT/DenseMap.h
|
llvm::MachineRegisterInfo::setType(llvm::Register, llvm::LLT)
|
void MachineRegisterInfo::setType(Register VReg, LLT Ty) {
VRegToType.grow(VReg);
VRegToType[VReg] = Ty;
}
|
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
leaq 0x1c8(%rdi), %r14
andl $0x7fffffff, %esi # imm = 0x7FFFFFFF
movl 0x1d0(%rdi), %eax
movl %esi, %r15d
cmpl %esi, %eax
ja 0x1d82d68
leaq 0x1(%r15), %rsi
movq 0x1d8(%rdi), %rdx
subq %rax, %rsi
movq %r14, %rdi
callq 0x9603a6
movq (%r14), %rax
movq %rbx, (%rax,%r15,8)
popq %rbx
popq %r14
popq %r15
retq
nop
|
/CodeGen/MachineRegisterInfo.cpp
|
llvm::MachineRegisterInfo::isReservedRegUnit(unsigned int) const
|
bool MachineRegisterInfo::isReservedRegUnit(unsigned Unit) const {
const TargetRegisterInfo *TRI = getTargetRegisterInfo();
for (MCRegUnitRootIterator Root(Unit, TRI); Root.isValid(); ++Root) {
if (all_of(TRI->superregs_inclusive(*Root),
[&](MCPhysReg Super) { return isReserved(Super); }))
return true;
}
return false;
}
|
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0xc8(%rax)
leaq 0x8(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq 0x28(%rcx), %rcx
movl %ebx, %edx
movzwl (%rcx,%rdx,4), %r9d
movzwl 0x2(%rcx,%rdx,4), %edx
movq 0x180(%r14), %rcx
xorl %esi, %esi
movl %r9d, %edi
testw %r9w, %r9w
je 0x1d83f5e
movq 0x8(%rax), %r8
movq 0x38(%rax), %r10
movzwl %di, %r9d
leaq (%r9,%r9,2), %r11
movl 0x8(%r8,%r11,8), %r8d
leaq (%r10,%r8,2), %r8
testq %r10, %r10
je 0x1d83f51
movl %edi, %r10d
movzwl %r10w, %r10d
movq %r10, %r11
shrq $0x6, %r11
movq (%rcx,%r11,8), %r11
btq %r10, %r11
jae 0x1d83f51
movzwl (%r8), %r11d
addq $0x2, %r8
addl %r11d, %r9d
movl %r9d, %r10d
testl %r11d, %r11d
cmoveq %rsi, %r8
jne 0x1d83f25
movl %edx, %r9d
movl $0x0, %edx
testq %r8, %r8
jne 0x1d83efb
testw %di, %di
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
|
/CodeGen/MachineRegisterInfo.cpp
|
llvm::SmallVectorTemplateBase<std::pair<unsigned int, llvm::SmallVector<llvm::Register, 4u>>, false>::moveElementsForGrow(std::pair<unsigned int, llvm::SmallVector<llvm::Register, 4u>>*)
|
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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %rbx
movq (%rdi), %rdi
movl 0x8(%rbx), %eax
leaq (%rax,%rax,4), %rax
leaq (%rdi,%rax,8), %rsi
callq 0x1d8410e
movl 0x8(%rbx), %eax
testq %rax, %rax
je 0x1d84105
movq (%rbx), %rcx
leaq (%rax,%rax,4), %rdx
leaq (%rcx,%rdx,8), %rbx
addq $-0x10, %rbx
shlq $0x3, %rax
leaq (%rax,%rax,4), %r14
negq %r14
movq -0x10(%rbx), %rdi
cmpq %rdi, %rbx
je 0x1d840fb
callq 0x780910
addq $-0x28, %rbx
addq $0x28, %r14
jne 0x1d840ed
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
|
/llvm/ADT/SmallVector.h
|
void llvm::SmallVectorImpl<unsigned short>::append<unsigned short const*, void>(unsigned short const*, unsigned short const*)
|
void append(ItTy in_start, ItTy in_end) {
this->assertSafeToAddRange(in_start, in_end);
size_type NumInputs = std::distance(in_start, in_end);
this->reserve(this->size() + NumInputs);
this->uninitialized_copy(in_start, in_end, this->end());
this->set_size(this->size() + NumInputs);
}
|
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq %rdx, %r15
subq %rsi, %r15
movq %r15, %r13
sarq %r13
movq 0x8(%rdi), %rdx
addq %r13, %rdx
cmpq %rdx, 0x10(%rdi)
jae 0x1d84694
leaq 0x18(%rbx), %rsi
movl $0x2, %ecx
movq %rbx, %rdi
callq 0x2b4efce
cmpq %r12, %r14
je 0x1d846ae
movq 0x8(%rbx), %rdi
addq %rdi, %rdi
addq (%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x780890
addq %r13, 0x8(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
|
/llvm/ADT/SmallVector.h
|
llvm::ScheduleDAGMILive::collectVRegUses(llvm::SUnit&)
|
ScheduleDAGInstrs *MachineScheduler::createMachineScheduler() {
// Select the scheduler, or set the default.
MachineSchedRegistry::ScheduleDAGCtor Ctor = MachineSchedOpt;
if (Ctor != useDefaultMachineSched)
return Ctor(this);
// Get the default scheduler set by the target for this function.
ScheduleDAGInstrs *Scheduler = PassConfig->createMachineScheduler(this);
if (Scheduler)
return Scheduler;
// Default to GenericScheduler.
return createGenericSchedLive(this);
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq (%rsi), %rcx
movzwl 0x28(%rcx), %eax
movq %rcx, (%rsp)
movzbl 0x2a(%rcx), %ebp
shll $0x10, %ebp
orl %eax, %ebp
testl %ebp, %ebp
je 0x1d859e2
movq %rsi, %rbx
movq (%rsp), %rax
movq 0x20(%rax), %r12
shll $0x5, %ebp
addq %r12, %rbp
leaq 0xaf0(%rdi), %r15
movl $0x10000ff, %r13d # imm = 0x10000FF
movq %rdi, 0x8(%rsp)
movl (%r12), %eax
testl $0x300000ff, %eax # imm = 0x300000FF
setne %cl
movl %eax, %edx
andl $0x10fff00, %edx # imm = 0x10FFF00
cmpl $0x1000000, %edx # imm = 0x1000000
sete %dl
orb %cl, %dl
jne 0x1d859d5
movb 0x372(%rdi), %cl
shrl $0x18, %eax
andl $0x1, %eax
testb %cl, %al
jne 0x1d859d5
movl 0x4(%r12), %r14d
testl %r14d, %r14d
jns 0x1d859d5
testb %cl, %cl
je 0x1d85961
movq (%rsp), %rdx
movq 0x20(%rdx), %rax
movzwl 0x28(%rdx), %ecx
movzbl 0x2a(%rdx), %edx
shll $0x10, %edx
orl %ecx, %edx
movq %rax, %rcx
testl %edx, %edx
je 0x1d85909
movl %edx, %esi
shll $0x5, %esi
movq %rax, %rcx
movl (%rcx), %r8d
andl %r13d, %r8d
cmpl $0x1000000, %r8d # imm = 0x1000000
je 0x1d85909
addq $0x20, %rcx
addq $-0x20, %rsi
jne 0x1d858f0
shll $0x5, %edx
addq %rdx, %rax
cmpq %rax, %rcx
je 0x1d85961
xorl %edx, %edx
cmpl %r14d, 0x4(%rcx)
jne 0x1d85931
movl (%rcx), %esi
movl %esi, %r8d
shrl $0x1a, %r8d
shrl $0x18, %esi
andl %r8d, %esi
testb $0x1, %sil
je 0x1d85956
movb $0x1, %sil
testb %sil, %sil
je 0x1d8595c
addq $0x20, %rcx
cmpq %rax, %rcx
je 0x1d8594f
movl (%rcx), %esi
andl %r13d, %esi
cmpl $0x1000000, %esi # imm = 0x1000000
jne 0x1d85939
cmpq %rax, %rcx
jne 0x1d85916
jmp 0x1d8595c
movb $0x1, %dl
xorl %esi, %esi
jmp 0x1d85934
testb $0x1, %dl
jne 0x1d859d5
movl %r14d, %esi
andl $0x7fffffff, %esi # imm = 0x7FFFFFFF
movq %r15, %rdi
callq 0x1d8cb34
movl %edx, %ecx
notl %ecx
movq %rax, %rsi
xorq %r15, %rsi
orq %rsi, %rcx
je 0x1d8599f
movq (%rax), %rcx
movl %edx, %esi
shlq $0x5, %rsi
cmpq %rbx, 0x10(%rcx,%rsi)
je 0x1d8599f
movl 0x1c(%rcx,%rsi), %edx
cmpq %r15, %rax
jne 0x1d85984
cmpl $-0x1, %edx
jne 0x1d85984
cmpq %r15, %rax
movq 0x8(%rsp), %rdi
jne 0x1d859d5
movl %edx, %eax
cmpl $-0x1, %eax
jne 0x1d859d5
movl %r14d, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq %rbx, 0x20(%rsp)
movq %r15, %rdi
leaq 0x10(%rsp), %rsi
callq 0x1d859f2
movq 0x8(%rsp), %rdi
addq $0x20, %r12
cmpq %rbp, %r12
jne 0x1d8587d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/CodeGen/MachineScheduler.cpp
|
(anonymous namespace)::MachineSchedulerBase::scheduleRegions(llvm::ScheduleDAGInstrs&, bool)
|
void MachineSchedulerBase::scheduleRegions(ScheduleDAGInstrs &Scheduler,
bool FixKillFlags) {
// Visit all machine basic blocks.
//
// TODO: Visit blocks in global postorder or postorder within the bottom-up
// loop tree. Then we can optionally compute global RegPressure.
for (MachineFunction::iterator MBB = MF->begin(), MBBEnd = MF->end();
MBB != MBBEnd; ++MBB) {
Scheduler.startBlock(&*MBB);
#ifndef NDEBUG
if (SchedOnlyFunc.getNumOccurrences() && SchedOnlyFunc != MF->getName())
continue;
if (SchedOnlyBlock.getNumOccurrences()
&& (int)SchedOnlyBlock != MBB->getNumber())
continue;
#endif
// Break the block into scheduling regions [I, RegionEnd). RegionEnd
// points to the scheduling boundary at the bottom of the region. The DAG
// does not include RegionEnd, but the region does (i.e. the next
// RegionEnd is above the previous RegionBegin). If the current block has
// no terminator then RegionEnd == MBB->end() for the bottom region.
//
// All the regions of MBB are first found and stored in MBBRegions, which
// will be processed (MBB) top-down if initialized with true.
//
// The Scheduler may insert instructions during either schedule() or
// exitRegion(), even for empty regions. So the local iterators 'I' and
// 'RegionEnd' are invalid across these calls. Instructions must not be
// added to other regions than the current one without updating MBBRegions.
MBBRegionsVector MBBRegions;
getSchedRegions(&*MBB, MBBRegions, Scheduler.doMBBSchedRegionsTopDown());
for (const SchedRegion &R : MBBRegions) {
MachineBasicBlock::iterator I = R.RegionBegin;
MachineBasicBlock::iterator RegionEnd = R.RegionEnd;
unsigned NumRegionInstrs = R.NumRegionInstrs;
// Notify the scheduler of the region, even if we may skip scheduling
// it. Perhaps it still needs to be bundled.
Scheduler.enterRegion(&*MBB, I, RegionEnd, NumRegionInstrs);
// Skip empty scheduling regions (0 or 1 schedulable instructions).
if (I == RegionEnd || I == std::prev(RegionEnd)) {
// Close the current region. Bundle the terminator if needed.
// This invalidates 'RegionEnd' and 'I'.
Scheduler.exitRegion();
continue;
}
LLVM_DEBUG(dbgs() << "********** MI Scheduling **********\n");
LLVM_DEBUG(dbgs() << MF->getName() << ":" << printMBBReference(*MBB)
<< " " << MBB->getName() << "\n From: " << *I
<< " To: ";
if (RegionEnd != MBB->end()) dbgs() << *RegionEnd;
else dbgs() << "End\n";
dbgs() << " RegionInstrs: " << NumRegionInstrs << '\n');
if (DumpCriticalPathLength) {
errs() << MF->getName();
errs() << ":%bb. " << MBB->getNumber();
errs() << " " << MBB->getName() << " \n";
}
// Schedule a region: possibly reorder instructions.
// This invalidates the original region iterators.
Scheduler.schedule();
// Close the current region.
Scheduler.exitRegion();
}
Scheduler.finishBlock();
// FIXME: Ideally, no further passes should rely on kill flags. However,
// thumb2 size reduction is currently an exception, so the PostMIScheduler
// needs to do this.
if (FixKillFlags)
Scheduler.fixupKills(*MBB);
}
Scheduler.finalizeSchedule();
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
movl %edx, 0x3c(%rsp)
movq %rsi, %r12
movq %rdi, 0x48(%rsp)
movq 0x8(%rdi), %rax
movq 0x148(%rax), %r15
addq $0x140, %rax # imm = 0x140
movq %rax, 0x40(%rsp)
cmpq %rax, %r15
je 0x1d8b3d7
leaq 0x68(%rsp), %rbx
leaq 0x20(%rsp), %r13
movq %r12, 0x50(%rsp)
movq (%r12), %rax
movq %r12, %rdi
movq %r15, %rsi
callq *0x50(%rax)
movq %rbx, 0x58(%rsp)
movabsq $0x1000000000, %rax # imm = 0x1000000000
movq %rax, 0x60(%rsp)
movq (%r12), %rax
movq %r12, %rdi
callq *0x48(%rax)
movb %al, 0x7(%rsp)
movq 0x20(%r15), %r14
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x80(%rax)
movq %rax, %rbp
movq $0x0, 0x8(%rsp)
leaq 0x30(%r15), %rax
movq %rax, 0x18(%rsp)
movq %rax, 0x10(%rsp)
cmpq %rax, 0x38(%r15)
je 0x1d8b1fe
movq 0x10(%rsp), %rax
cmpq %rax, 0x10(%rsp)
jne 0x1d8b07b
movq %rax, 0x20(%rsp)
movq %r13, %rdi
callq 0x93f64a
movq 0x20(%rsp), %rbx
movq %rbx, %rdi
movl $0x7, %esi
movl $0x1, %edx
callq 0x90bd50
testb %al, %al
jne 0x1d8b07b
movq (%rbp), %rax
movq %rbp, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq *0x398(%rax)
testb %al, %al
je 0x1d8b085
leaq 0x18(%rsp), %rdi
callq 0x93f64a
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq %rax, 0x38(%r15)
je 0x1d8b11d
xorl %r12d, %r12d
movq %rax, 0x20(%rsp)
movq %r13, %rdi
callq 0x93f64a
movq 0x20(%rsp), %rbx
movq %rbx, %rdi
movl $0x7, %esi
movl $0x1, %edx
callq 0x90bd50
testb %al, %al
jne 0x1d8b0de
movq (%rbp), %rax
movq %rbp, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq *0x398(%rax)
testb %al, %al
je 0x1d8b0e2
xorl %eax, %eax
jmp 0x1d8b102
movl 0x44(%rbx), %eax
movl %eax, %ecx
addl $-0x12, %ecx
cmpw $-0x5, %cx
setb %cl
cmpw $0x17, %ax
setne %al
andb %cl, %al
movzbl %al, %eax
addl %eax, %r12d
movb $0x1, %al
testb %al, %al
je 0x1d8b120
leaq 0x8(%rsp), %rdi
callq 0x93f64a
movq 0x8(%rsp), %rax
cmpq 0x38(%r15), %rax
jne 0x1d8b09c
jmp 0x1d8b120
xorl %r12d, %r12d
testl %r12d, %r12d
je 0x1d8b16c
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rax, 0x20(%rsp)
movq %rcx, 0x28(%rsp)
movl %r12d, 0x30(%rsp)
movl 0x60(%rsp), %edx
movq %r13, %rax
cmpl 0x64(%rsp), %edx
jae 0x1d8b187
movq 0x58(%rsp), %rcx
movl 0x60(%rsp), %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 0x60(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq %rax, 0x38(%r15)
movq 0x50(%rsp), %r12
jne 0x1d8b032
jmp 0x1d8b1fe
movq 0x58(%rsp), %rax
leaq (%rdx,%rdx,2), %rcx
cmpq %r13, %rax
setbe %sil
leaq (%rax,%rcx,8), %rcx
cmpq %r13, %rcx
seta %bl
andb %sil, %bl
movq $-0x1, %r12
cmpb $0x1, %bl
je 0x1d8b1e4
incq %rdx
movl $0x18, %ecx
leaq 0x58(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x2b4ed86
movq %r13, %rax
testb %bl, %bl
je 0x1d8b14b
leaq (%r12,%r12,2), %rax
shlq $0x3, %rax
addq 0x58(%rsp), %rax
jmp 0x1d8b14b
movq %r13, %r12
subq %rax, %r12
sarq $0x3, %r12
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %r12
jmp 0x1d8b1b0
cmpb $0x0, 0x7(%rsp)
je 0x1d8b272
movq 0x58(%rsp), %rax
movl 0x60(%rsp), %ecx
movl %ecx, %edx
leaq (%rdx,%rdx,2), %rdx
testl %ecx, %ecx
setne %sil
leaq (%rax,%rdx,8), %rcx
addq $-0x18, %rcx
cmpq %rax, %rcx
seta %dl
andb %sil, %dl
cmpb $0x1, %dl
jne 0x1d8b272
addq $0x18, %rax
movq -0x8(%rax), %rdx
movq %rdx, 0x30(%rsp)
movups -0x18(%rax), %xmm0
movaps %xmm0, 0x20(%rsp)
movl 0x10(%rcx), %edx
movl %edx, -0x8(%rax)
movups (%rcx), %xmm0
movups %xmm0, -0x18(%rax)
movl 0x30(%rsp), %edx
movl %edx, 0x10(%rcx)
movaps 0x20(%rsp), %xmm0
movups %xmm0, (%rcx)
addq $-0x18, %rcx
leaq 0x18(%rax), %rdx
cmpq %rcx, %rax
movq %rdx, %rax
jb 0x1d8b234
movl 0x60(%rsp), %eax
testq %rax, %rax
je 0x1d8b398
movq 0x58(%rsp), %rbp
leaq (%rax,%rax,2), %rax
leaq (,%rax,8), %rax
addq %rbp, %rax
movq %rax, 0x10(%rsp)
movq (%rbp), %rbx
movq 0x8(%rbp), %r14
movl 0x10(%rbp), %r8d
movq (%r12), %rax
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq *0x60(%rax)
cmpq %r14, %rbx
je 0x1d8b37f
movq %r14, 0x20(%rsp)
movq %r13, %rdi
callq 0x93f64a
cmpq %rbx, 0x20(%rsp)
je 0x1d8b37f
leaq 0x3bc8919(%rip), %rax # 0x5953bf8
cmpb $0x1, 0x80(%rax)
jne 0x1d8b375
callq 0x2b7e53f
movq %rax, %rbx
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x1d3500c
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7f9ba8
callq 0x2b7e53f
movl $0x6, %edx
movq %rax, %rdi
leaq 0x31b6fb9(%rip), %rsi # 0x4f422da
callq 0x7f9ba8
movslq 0x18(%r15), %rsi
movq %rax, %rdi
callq 0x2b7d122
callq 0x2b7e53f
movl $0x1, %edx
movq %rax, %rdi
leaq 0x2b0481c(%rip), %rsi # 0x488fb62
callq 0x7f9ba8
movq %rax, %rbx
movq %r15, %rdi
callq 0x1cfb14a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7f9ba8
movl $0x2, %edx
movq %rax, %rdi
leaq 0x31777a7(%rip), %rsi # 0x4f02b17
callq 0x7f9ba8
movq (%r12), %rax
movq %r12, %rdi
callq *0x70(%rax)
movq (%r12), %rax
movq %r12, %rdi
callq *0x68(%rax)
addq $0x18, %rbp
cmpq 0x10(%rsp), %rbp
jne 0x1d8b298
movq (%r12), %rax
movq %r12, %rdi
callq *0x58(%rax)
cmpb $0x0, 0x3c(%rsp)
je 0x1d8b3b4
movq %r12, %rdi
movq %r15, %rsi
callq 0x1e37612
movq 0x58(%rsp), %rdi
leaq 0x68(%rsp), %rbx
cmpq %rbx, %rdi
je 0x1d8b3c8
callq 0x780910
movq 0x8(%r15), %r15
cmpq 0x40(%rsp), %r15
jne 0x1d8afc9
movq (%r12), %rax
movq %r12, %rdi
callq *0x78(%rax)
addq $0x1e8, %rsp # imm = 0x1E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/CodeGen/MachineScheduler.cpp
|
llvm::DenseMapBase<llvm::DenseMap<llvm::MachineBasicBlock*, llvm::SSAUpdaterImpl<llvm::MachineSSAUpdater>::BBInfo*, llvm::DenseMapInfo<llvm::MachineBasicBlock*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock*, llvm::SSAUpdaterImpl<llvm::MachineSSAUpdater>::BBInfo*>>, llvm::MachineBasicBlock*, llvm::SSAUpdaterImpl<llvm::MachineSSAUpdater>::BBInfo*, llvm::DenseMapInfo<llvm::MachineBasicBlock*, void>, llvm::detail::DenseMapPair<llvm::MachineBasicBlock*, llvm::SSAUpdaterImpl<llvm::MachineSSAUpdater>::BBInfo*>>::moveFromOldBuckets(llvm::detail::DenseMapPair<llvm::MachineBasicBlock*, llvm::SSAUpdaterImpl<llvm::MachineSSAUpdater>::BBInfo*>*, llvm::detail::DenseMapPair<llvm::MachineBasicBlock*, llvm::SSAUpdaterImpl<llvm::MachineSSAUpdater>::BBInfo*>*)
|
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 %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 0x1d9d4d3
movq (%r15), %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 0xe17bc4(%rip), %xmm1 # 0x2bb5020
movdqa 0xe17bcc(%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 0x1d9d4b0
movq $-0x1000, -0x10(%rax) # imm = 0xF000
pxor %xmm3, %xmm4
pextrw $0x4, %xmm4, %esi
testb $0x1, %sil
je 0x1d9d4c6
movq $-0x1000, (%rax) # imm = 0xF000
addq $0x2, %rdx
addq $0x20, %rax
cmpq %rdx, %rcx
jne 0x1d9d46c
cmpq %rbx, %r14
je 0x1d9d51f
movl $0x1000, %r13d # imm = 0x1000
leaq 0x8(%rsp), %r12
movq (%r14), %rax
orq %r13, %rax
cmpq $-0x1000, %rax # imm = 0xF000
je 0x1d9d516
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x1d9d1ac
movq 0x8(%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 0x1d9d4e3
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
|
/llvm/ADT/DenseMap.h
|
llvm::GenericUniformityAnalysisImpl<llvm::GenericSSAContext<llvm::MachineFunction>>::pushUsers(llvm::MachineInstr const&)
|
void llvm::GenericUniformityAnalysisImpl<MachineSSAContext>::pushUsers(
const MachineInstr &Instr) {
assert(!isAlwaysUniform(Instr));
if (Instr.isTerminator())
return;
for (const MachineOperand &op : Instr.all_defs()) {
auto Reg = op.getReg();
if (isDivergent(Reg))
pushUsers(Reg);
}
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
movq %rsi, %rdi
movl $0x9, %esi
movl $0x1, %edx
callq 0x90bd50
testb %al, %al
jne 0x1da1f48
movq 0x20(%r14), %r13
movzwl 0x28(%r14), %ecx
movzbl 0x2a(%r14), %eax
shll $0x10, %eax
orl %ecx, %eax
movl %eax, %ebx
shll $0x5, %ebx
addq %r13, %rbx
testl %eax, %eax
je 0x1da1eeb
shll $0x5, %eax
movl $0x10000ff, %ecx # imm = 0x10000FF
movl (%r13), %edx
andl %ecx, %edx
cmpl $0x1000000, %edx # imm = 0x1000000
je 0x1da1eeb
addq $0x20, %r13
addq $-0x20, %rax
jne 0x1da1ed3
cmpq %rbx, %r13
je 0x1da1f48
movq 0x8(%rsp), %rax
leaq 0x20(%rax), %r14
leaq 0x10(%rsp), %r12
movl $0x10000ff, %r15d # imm = 0x10000FF
movl 0x4(%r13), %ebp
movl %ebp, 0x4(%rsp)
movq %r14, %rdi
leaq 0x4(%rsp), %rsi
movq %r12, %rdx
callq 0xadb920
testb %al, %al
je 0x1da1f2c
movq 0x8(%rsp), %rdi
movl %ebp, %esi
callq 0x1da1e30
addq $0x20, %r13
cmpq %rbx, %r13
je 0x1da1f43
movl (%r13), %eax
andl %r15d, %eax
cmpl $0x1000000, %eax # imm = 0x1000000
jne 0x1da1f2c
cmpq %rbx, %r13
jne 0x1da1f04
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
|
/CodeGen/MachineUniformityAnalysis.cpp
|
(anonymous namespace)::MachineVerifier::report(llvm::Twine const&, llvm::MachineInstr const*)
|
void MachineVerifier::report(const Twine &Msg, const MachineInstr *MI) {
report(Msg.str().c_str(), MI);
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0x2b6085c
movq (%r15), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1dadb76
movq (%r15), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x1db1f3a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x7800d0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
|
/CodeGen/MachineVerifier.cpp
|
(anonymous namespace)::MachineVerifier::addRegWithSubRegs(llvm::SmallVector<llvm::Register, 16u>&, llvm::Register)
|
void addRegWithSubRegs(RegVector &RV, Register Reg) {
RV.push_back(Reg);
if (Reg.isPhysical())
append_range(RV, TRI->subregs(Reg.asMCReg()));
}
|
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, %rdi
movl %edx, %esi
callq 0x962e12
leal -0x1(%r14), %eax
cmpl $0x3ffffffe, %eax # imm = 0x3FFFFFFE
ja 0x1db2681
movq 0x30(%r15), %rax
movq 0x8(%rax), %rcx
movq 0x38(%rax), %rax
movl %r14d, %edx
leaq (%rdx,%rdx,2), %rdx
movl 0x4(%rcx,%rdx,8), %ecx
leaq (%rax,%rcx,2), %rax
addq $0x2, %rax
movswl -0x2(%rax), %ecx
addl %ecx, %r14d
xorl %edx, %edx
testl %ecx, %ecx
cmovneq %rax, %rdx
movl %r14d, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movw %r14w, 0x40(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rsp)
movq $0x0, 0x58(%rsp)
movl 0x8(%rbx), %esi
shlq $0x2, %rsi
addq (%rbx), %rsi
movq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
movups 0x48(%rsp), %xmm0
movups %xmm0, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x30(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x1db2a26
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
|
/CodeGen/MachineVerifier.cpp
|
bool llvm::DenseMapBase<llvm::DenseMap<llvm::Register, llvm::MachineInstr const*, llvm::DenseMapInfo<llvm::Register, void>, llvm::detail::DenseMapPair<llvm::Register, llvm::MachineInstr const*>>, llvm::Register, llvm::MachineInstr const*, llvm::DenseMapInfo<llvm::Register, void>, llvm::detail::DenseMapPair<llvm::Register, llvm::MachineInstr const*>>::LookupBucketFor<llvm::Register>(llvm::Register const&, llvm::detail::DenseMapPair<llvm::Register, llvm::MachineInstr const*> const*&) const
|
unsigned getNumBuckets() const {
return NumBuckets;
}
|
movl 0x10(%rdi), %ecx
testl %ecx, %ecx
je 0x1db3100
pushq %rbx
movq (%rdi), %rdi
movl (%rsi), %esi
leal (%rsi,%rsi,8), %eax
leal (%rsi,%rax,4), %r8d
decl %ecx
andl %ecx, %r8d
movl $0x1, %r10d
xorl %r9d, %r9d
movl %r8d, %ebx
shlq $0x4, %rbx
leaq (%rdi,%rbx), %r11
movl (%rdi,%rbx), %ebx
cmpl %ebx, %esi
jne 0x1db30cb
movq %r11, (%rdx)
movb $0x1, %al
xorl %r11d, %r11d
testb %r11b, %r11b
jne 0x1db30aa
jmp 0x1db30fd
cmpl $-0x1, %ebx
jne 0x1db30e1
testq %r9, %r9
cmovneq %r9, %r11
movq %r11, (%rdx)
xorl %r11d, %r11d
xorl %eax, %eax
jmp 0x1db30c4
testq %r9, %r9
cmovneq %r9, %r11
cmpl $-0x2, %ebx
cmoveq %r11, %r9
addl %r10d, %r8d
incl %r10d
andl %ecx, %r8d
movb $0x1, %r11b
jmp 0x1db30c4
popq %rbx
jmp 0x1db3109
movq $0x0, (%rdx)
xorl %eax, %eax
andb $0x1, %al
retq
|
/llvm/ADT/DenseMap.h
|
(anonymous namespace)::MachineVerifier::report_context(llvm::LiveRange::Segment const&) const
|
void MachineVerifier::report_context(const LiveRange::Segment &S) const {
errs() << "- segment: " << S << '\n';
}
|
pushq %rbx
movq %rdi, %rbx
callq 0x2b7e53f
leaq 0x3192342(%rip), %rsi # 0x4f46c12
movl $0xf, %edx
movq %rax, %rdi
callq 0x7f9ba8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1ce1d48
movq 0x20(%rax), %rcx
cmpq 0x18(%rax), %rcx
jae 0x1db48ff
leaq 0x1(%rcx), %rdx
movq %rdx, 0x20(%rax)
movb $0xa, (%rcx)
popq %rbx
retq
movq %rax, %rdi
movl $0xa, %esi
popq %rbx
jmp 0x2b7d68e
nopl (%rax)
|
/CodeGen/MachineVerifier.cpp
|
llvm::ModuloSchedule::print(llvm::raw_ostream&)
|
void ModuloSchedule::print(raw_ostream &OS) {
for (MachineInstr *MI : ScheduledInstrs)
OS << "[stage " << getStage(MI) << " @" << getCycle(MI) << "c] " << *MI;
}
|
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, 0x20(%rsp)
movq 0x8(%rdi), %r15
movq 0x10(%rdi), %r12
cmpq %r12, %r15
je 0x1db4c37
movq %rdi, %r14
leaq 0x38(%rdi), %rax
movq %rax, 0x18(%rsp)
leaq 0x20(%rdi), %rax
movq %rax, 0x10(%rsp)
movq (%r15), %rbp
movl $0x7, %edx
movq 0x20(%rsp), %rdi
leaq 0x3192147(%rip), %rsi # 0x4f46cb6
callq 0x7f9ba8
movq %rax, %rbx
movq 0x18(%rsp), %rdi
movq %rbp, %rsi
callq 0x1506d54
movl 0x48(%r14), %ecx
shlq $0x4, %rcx
addq 0x38(%r14), %rcx
movq $-0x1, %r13
movq $-0x1, %rsi
cmpq %rcx, %rax
je 0x1db4ba7
movslq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x2b7d122
movl $0x2, %edx
movq %rax, %rdi
leaq 0x14fb374(%rip), %rsi # 0x32aff32
callq 0x7f9ba8
movq %rax, %rbx
movq 0x10(%rsp), %rdi
movq %rbp, %rsi
callq 0x1506d54
movl 0x30(%r14), %ecx
shlq $0x4, %rcx
addq 0x20(%r14), %rcx
cmpq %rcx, %rax
je 0x1db4be8
movslq 0x8(%rax), %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2b7d122
movl $0x3, %edx
movq %rax, %rdi
leaq 0x31920bc(%rip), %rsi # 0x4f46cbe
callq 0x7f9ba8
movq $0x0, (%rsp)
movq %rbp, %rdi
movq %rax, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
movl $0x1, %r9d
callq 0x1d3fca4
addq $0x8, %r15
cmpq %r12, %r15
jne 0x1db4b5b
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
|
/CodeGen/ModuloSchedule.cpp
|
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.