mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-23 11:13:28 +01:00
78412f523a
After creating a low-overhead loop, the loop update instruction was still
lingering around hurting performance. This removes dead loop update
instructions, which in our case are mostly SUBS instructions.
To support this, some helper functions were added to MachineLoopUtils and
ReachingDefAnalysis to analyse live-ins of loop exit blocks and find uses
before a particular loop instruction, respectively.
This is a first version that removes a SUBS instruction when there are no other
uses inside and outside the loop block, but there are some more interesting
cases in test/CodeGen/Thumb2/LowOverheadLoops/mve-tail-data-types.ll which
shows that there is room for improvement. For example, we can't handle this
case yet:
..
dlstp.32 lr, r2
.LBB0_1:
mov r3, r2
subs r2, #4
vldrh.u32 q2, [r1], #8
vmov q1, q0
vmla.u32 q0, q2, r0
letp lr, .LBB0_1
@ %bb.2:
vctp.32 r3
..
which is a lot more tricky because r2 is not only used by the subs, but also by
the mov to r3, which is used outside the low-overhead loop by the vctp
instruction, and that requires a bit of a different approach, and I will follow
up on this.
Differential Revision: https://reviews.llvm.org/D71007
47 lines
1.7 KiB
C++
47 lines
1.7 KiB
C++
//=- MachineLoopUtils.h - Helper functions for manipulating loops -*- C++ -*-=//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_LIB_CODEGEN_MACHINELOOPUTILS_H
|
|
#define LLVM_LIB_CODEGEN_MACHINELOOPUTILS_H
|
|
|
|
namespace llvm {
|
|
class MachineLoop;
|
|
class MachineBasicBlock;
|
|
class MachineRegisterInfo;
|
|
class TargetInstrInfo;
|
|
|
|
enum LoopPeelDirection {
|
|
LPD_Front, ///< Peel the first iteration of the loop.
|
|
LPD_Back ///< Peel the last iteration of the loop.
|
|
};
|
|
|
|
/// Peels a single block loop. Loop must have two successors, one of which
|
|
/// must be itself. Similarly it must have two predecessors, one of which must
|
|
/// be itself.
|
|
///
|
|
/// The loop block is copied and inserted into the CFG such that two copies of
|
|
/// the loop follow on from each other. The copy is inserted either before or
|
|
/// after the loop based on Direction.
|
|
///
|
|
/// Phis are updated and an unconditional branch inserted at the end of the
|
|
/// clone so as to execute a single iteration.
|
|
///
|
|
/// The trip count of Loop is not updated.
|
|
MachineBasicBlock *PeelSingleBlockLoop(LoopPeelDirection Direction,
|
|
MachineBasicBlock *Loop,
|
|
MachineRegisterInfo &MRI,
|
|
const TargetInstrInfo *TII);
|
|
|
|
/// Return true if PhysReg is live outside the loop, i.e. determine if it
|
|
/// is live in the loop exit blocks, and false otherwise.
|
|
bool isRegLiveInExitBlocks(MachineLoop *Loop, int PhysReg);
|
|
|
|
} // namespace llvm
|
|
|
|
#endif // LLVM_LIB_CODEGEN_MACHINELOOPUTILS_H
|