2013-02-12 05:37:55 +08:00
|
|
|
//===---- HexagonFixupHwLoops.cpp - Fixup HW loops too far from LOOPn. ----===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
// The loop start address in the LOOPn instruction is encoded as a distance
|
2015-04-27 22:16:43 +08:00
|
|
|
// from the LOOPn instruction itself. If the start address is too far from
|
|
|
|
// the LOOPn instruction, the instruction needs to use a constant extender.
|
2013-02-12 05:37:55 +08:00
|
|
|
// This pass will identify and convert such LOOPn instructions to a proper
|
|
|
|
// form.
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
|
|
|
|
#include "llvm/ADT/DenseMap.h"
|
2014-01-07 19:48:04 +08:00
|
|
|
#include "Hexagon.h"
|
|
|
|
#include "HexagonTargetMachine.h"
|
2013-02-12 05:37:55 +08:00
|
|
|
#include "llvm/CodeGen/MachineFunction.h"
|
|
|
|
#include "llvm/CodeGen/MachineFunctionPass.h"
|
|
|
|
#include "llvm/CodeGen/MachineInstrBuilder.h"
|
|
|
|
#include "llvm/CodeGen/Passes.h"
|
|
|
|
#include "llvm/PassSupport.h"
|
|
|
|
#include "llvm/Target/TargetInstrInfo.h"
|
|
|
|
|
|
|
|
using namespace llvm;
|
|
|
|
|
2015-04-27 22:16:43 +08:00
|
|
|
static cl::opt<unsigned> MaxLoopRange(
|
|
|
|
"hexagon-loop-range", cl::Hidden, cl::init(200),
|
|
|
|
cl::desc("Restrict range of loopN instructions (testing only)"));
|
|
|
|
|
2013-02-12 05:37:55 +08:00
|
|
|
namespace llvm {
|
|
|
|
void initializeHexagonFixupHwLoopsPass(PassRegistry&);
|
|
|
|
}
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
struct HexagonFixupHwLoops : public MachineFunctionPass {
|
|
|
|
public:
|
|
|
|
static char ID;
|
|
|
|
|
|
|
|
HexagonFixupHwLoops() : MachineFunctionPass(ID) {
|
|
|
|
initializeHexagonFixupHwLoopsPass(*PassRegistry::getPassRegistry());
|
|
|
|
}
|
|
|
|
|
2014-04-29 15:58:16 +08:00
|
|
|
bool runOnMachineFunction(MachineFunction &MF) override;
|
2013-02-12 05:37:55 +08:00
|
|
|
|
2014-04-29 15:58:16 +08:00
|
|
|
const char *getPassName() const override {
|
|
|
|
return "Hexagon Hardware Loop Fixup";
|
|
|
|
}
|
2013-02-12 05:37:55 +08:00
|
|
|
|
2014-04-29 15:58:16 +08:00
|
|
|
void getAnalysisUsage(AnalysisUsage &AU) const override {
|
2013-02-12 05:37:55 +08:00
|
|
|
AU.setPreservesCFG();
|
|
|
|
MachineFunctionPass::getAnalysisUsage(AU);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
/// \brief Check the offset between each loop instruction and
|
|
|
|
/// the loop basic block to determine if we can use the LOOP instruction
|
|
|
|
/// or if we need to set the LC/SA registers explicitly.
|
|
|
|
bool fixupLoopInstrs(MachineFunction &MF);
|
|
|
|
|
2015-04-27 22:16:43 +08:00
|
|
|
/// \brief Replace loop instruction with the constant extended
|
|
|
|
/// version if the loop label is too far from the loop instruction.
|
|
|
|
void useExtLoopInstr(MachineFunction &MF,
|
|
|
|
MachineBasicBlock::iterator &MII);
|
2013-02-12 05:37:55 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
char HexagonFixupHwLoops::ID = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
INITIALIZE_PASS(HexagonFixupHwLoops, "hwloopsfixup",
|
|
|
|
"Hexagon Hardware Loops Fixup", false, false)
|
|
|
|
|
|
|
|
FunctionPass *llvm::createHexagonFixupHwLoops() {
|
|
|
|
return new HexagonFixupHwLoops();
|
|
|
|
}
|
|
|
|
|
|
|
|
/// \brief Returns true if the instruction is a hardware loop instruction.
|
|
|
|
static bool isHardwareLoop(const MachineInstr *MI) {
|
2014-12-19 08:06:53 +08:00
|
|
|
return MI->getOpcode() == Hexagon::J2_loop0r ||
|
2015-04-27 22:16:43 +08:00
|
|
|
MI->getOpcode() == Hexagon::J2_loop0i ||
|
|
|
|
MI->getOpcode() == Hexagon::J2_loop1r ||
|
|
|
|
MI->getOpcode() == Hexagon::J2_loop1i;
|
2013-02-12 05:37:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
bool HexagonFixupHwLoops::runOnMachineFunction(MachineFunction &MF) {
|
2015-04-27 22:16:43 +08:00
|
|
|
return fixupLoopInstrs(MF);
|
2013-02-12 05:37:55 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// \brief For Hexagon, if the loop label is to far from the
|
|
|
|
/// loop instruction then we need to set the LC0 and SA0 registers
|
|
|
|
/// explicitly instead of using LOOP(start,count). This function
|
|
|
|
/// checks the distance, and generates register assignments if needed.
|
|
|
|
///
|
|
|
|
/// This function makes two passes over the basic blocks. The first
|
|
|
|
/// pass computes the offset of the basic block from the start.
|
|
|
|
/// The second pass checks all the loop instructions.
|
|
|
|
bool HexagonFixupHwLoops::fixupLoopInstrs(MachineFunction &MF) {
|
|
|
|
|
|
|
|
// Offset of the current instruction from the start.
|
|
|
|
unsigned InstOffset = 0;
|
|
|
|
// Map for each basic block to it's first instruction.
|
2015-04-27 22:16:43 +08:00
|
|
|
DenseMap<const MachineBasicBlock *, unsigned> BlockToInstOffset;
|
|
|
|
|
|
|
|
const HexagonInstrInfo *HII =
|
|
|
|
static_cast<const HexagonInstrInfo *>(MF.getSubtarget().getInstrInfo());
|
2013-02-12 05:37:55 +08:00
|
|
|
|
|
|
|
// First pass - compute the offset of each basic block.
|
2015-04-27 22:16:43 +08:00
|
|
|
for (const MachineBasicBlock &MBB : MF) {
|
|
|
|
if (MBB.getAlignment()) {
|
|
|
|
// Although we don't know the exact layout of the final code, we need
|
|
|
|
// to account for alignment padding somehow. This heuristic pads each
|
|
|
|
// aligned basic block according to the alignment value.
|
|
|
|
int ByteAlign = (1u << MBB.getAlignment()) - 1;
|
|
|
|
InstOffset = (InstOffset + ByteAlign) & ~(ByteAlign);
|
|
|
|
}
|
|
|
|
|
|
|
|
BlockToInstOffset[&MBB] = InstOffset;
|
|
|
|
for (const MachineInstr &MI : MBB)
|
|
|
|
InstOffset += HII->getSize(&MI);
|
2013-02-12 05:37:55 +08:00
|
|
|
}
|
|
|
|
|
2015-04-27 22:16:43 +08:00
|
|
|
// Second pass - check each loop instruction to see if it needs to be
|
|
|
|
// converted.
|
2013-02-12 05:37:55 +08:00
|
|
|
InstOffset = 0;
|
|
|
|
bool Changed = false;
|
2015-04-27 22:16:43 +08:00
|
|
|
for (MachineBasicBlock &MBB : MF) {
|
|
|
|
InstOffset = BlockToInstOffset[&MBB];
|
2013-02-12 05:37:55 +08:00
|
|
|
|
|
|
|
// Loop over all the instructions.
|
2015-04-27 22:16:43 +08:00
|
|
|
MachineBasicBlock::iterator MII = MBB.begin();
|
|
|
|
MachineBasicBlock::iterator MIE = MBB.end();
|
2013-02-12 05:37:55 +08:00
|
|
|
while (MII != MIE) {
|
2015-04-27 22:16:43 +08:00
|
|
|
InstOffset += HII->getSize(&*MII);
|
|
|
|
if (MII->isDebugValue()) {
|
|
|
|
++MII;
|
|
|
|
continue;
|
|
|
|
}
|
2013-02-12 05:37:55 +08:00
|
|
|
if (isHardwareLoop(MII)) {
|
|
|
|
assert(MII->getOperand(0).isMBB() &&
|
|
|
|
"Expect a basic block as loop operand");
|
2015-04-27 22:16:43 +08:00
|
|
|
int diff = InstOffset - BlockToInstOffset[MII->getOperand(0).getMBB()];
|
|
|
|
if ((unsigned)abs(diff) > MaxLoopRange) {
|
|
|
|
useExtLoopInstr(MF, MII);
|
|
|
|
MII = MBB.erase(MII);
|
2013-02-12 05:37:55 +08:00
|
|
|
Changed = true;
|
|
|
|
} else {
|
|
|
|
++MII;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
++MII;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return Changed;
|
|
|
|
}
|
|
|
|
|
2015-04-27 22:16:43 +08:00
|
|
|
/// \brief Replace loop instructions with the constant extended version.
|
|
|
|
void HexagonFixupHwLoops::useExtLoopInstr(MachineFunction &MF,
|
|
|
|
MachineBasicBlock::iterator &MII) {
|
2014-08-05 10:39:49 +08:00
|
|
|
const TargetInstrInfo *TII = MF.getSubtarget().getInstrInfo();
|
2013-02-12 05:37:55 +08:00
|
|
|
MachineBasicBlock *MBB = MII->getParent();
|
|
|
|
DebugLoc DL = MII->getDebugLoc();
|
2015-04-27 22:16:43 +08:00
|
|
|
MachineInstrBuilder MIB;
|
|
|
|
unsigned newOp;
|
|
|
|
switch (MII->getOpcode()) {
|
|
|
|
case Hexagon::J2_loop0r:
|
|
|
|
newOp = Hexagon::J2_loop0rext;
|
|
|
|
break;
|
|
|
|
case Hexagon::J2_loop0i:
|
|
|
|
newOp = Hexagon::J2_loop0iext;
|
|
|
|
break;
|
|
|
|
case Hexagon::J2_loop1r:
|
|
|
|
newOp = Hexagon::J2_loop1rext;
|
|
|
|
break;
|
|
|
|
case Hexagon::J2_loop1i:
|
|
|
|
newOp = Hexagon::J2_loop1iext;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
llvm_unreachable("Invalid Hardware Loop Instruction.");
|
2013-02-12 05:37:55 +08:00
|
|
|
}
|
2015-04-27 22:16:43 +08:00
|
|
|
MIB = BuildMI(*MBB, MII, DL, TII->get(newOp));
|
|
|
|
|
|
|
|
for (unsigned i = 0; i < MII->getNumOperands(); ++i)
|
|
|
|
MIB.addOperand(MII->getOperand(i));
|
2013-02-12 05:37:55 +08:00
|
|
|
}
|