Krzysztof Parzyszek | 9a278f1 | 2013-02-11 21:37:55 +0000 | [diff] [blame] | 1 | //===---- HexagonFixupHwLoops.cpp - Fixup HW loops too far from LOOPn. ----===// |
| 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
| 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
| 7 | // |
| 8 | // The loop start address in the LOOPn instruction is encoded as a distance |
Brendon Cahoon | 55bdeb7 | 2015-04-27 14:16:43 +0000 | [diff] [blame] | 9 | // from the LOOPn instruction itself. If the start address is too far from |
| 10 | // the LOOPn instruction, the instruction needs to use a constant extender. |
Krzysztof Parzyszek | 9a278f1 | 2013-02-11 21:37:55 +0000 | [diff] [blame] | 11 | // This pass will identify and convert such LOOPn instructions to a proper |
| 12 | // form. |
| 13 | //===----------------------------------------------------------------------===// |
| 14 | |
Chandler Carruth | 8a8cd2b | 2014-01-07 11:48:04 +0000 | [diff] [blame] | 15 | #include "Hexagon.h" |
| 16 | #include "HexagonTargetMachine.h" |
Chandler Carruth | 6bda14b | 2017-06-06 11:49:48 +0000 | [diff] [blame] | 17 | #include "llvm/ADT/DenseMap.h" |
Krzysztof Parzyszek | 9a278f1 | 2013-02-11 21:37:55 +0000 | [diff] [blame] | 18 | #include "llvm/CodeGen/MachineFunction.h" |
| 19 | #include "llvm/CodeGen/MachineFunctionPass.h" |
| 20 | #include "llvm/CodeGen/MachineInstrBuilder.h" |
| 21 | #include "llvm/CodeGen/Passes.h" |
David Blaikie | 3f833ed | 2017-11-08 01:01:31 +0000 | [diff] [blame] | 22 | #include "llvm/CodeGen/TargetInstrInfo.h" |
Krzysztof Parzyszek | 9a278f1 | 2013-02-11 21:37:55 +0000 | [diff] [blame] | 23 | #include "llvm/PassSupport.h" |
Krzysztof Parzyszek | 9a278f1 | 2013-02-11 21:37:55 +0000 | [diff] [blame] | 24 | |
| 25 | using namespace llvm; |
| 26 | |
Brendon Cahoon | 55bdeb7 | 2015-04-27 14:16:43 +0000 | [diff] [blame] | 27 | static cl::opt<unsigned> MaxLoopRange( |
| 28 | "hexagon-loop-range", cl::Hidden, cl::init(200), |
| 29 | cl::desc("Restrict range of loopN instructions (testing only)")); |
| 30 | |
Krzysztof Parzyszek | 9a278f1 | 2013-02-11 21:37:55 +0000 | [diff] [blame] | 31 | namespace llvm { |
Colin LeMahieu | 56efafc | 2015-06-15 19:05:35 +0000 | [diff] [blame] | 32 | FunctionPass *createHexagonFixupHwLoops(); |
Krzysztof Parzyszek | 9a278f1 | 2013-02-11 21:37:55 +0000 | [diff] [blame] | 33 | void initializeHexagonFixupHwLoopsPass(PassRegistry&); |
| 34 | } |
| 35 | |
| 36 | namespace { |
| 37 | struct HexagonFixupHwLoops : public MachineFunctionPass { |
| 38 | public: |
| 39 | static char ID; |
| 40 | |
| 41 | HexagonFixupHwLoops() : MachineFunctionPass(ID) { |
| 42 | initializeHexagonFixupHwLoopsPass(*PassRegistry::getPassRegistry()); |
| 43 | } |
| 44 | |
Craig Topper | 906c2cd | 2014-04-29 07:58:16 +0000 | [diff] [blame] | 45 | bool runOnMachineFunction(MachineFunction &MF) override; |
Krzysztof Parzyszek | 9a278f1 | 2013-02-11 21:37:55 +0000 | [diff] [blame] | 46 | |
Derek Schuff | 1dbf7a5 | 2016-04-04 17:09:25 +0000 | [diff] [blame] | 47 | MachineFunctionProperties getRequiredProperties() const override { |
| 48 | return MachineFunctionProperties().set( |
Matthias Braun | 1eb4736 | 2016-08-25 01:27:13 +0000 | [diff] [blame] | 49 | MachineFunctionProperties::Property::NoVRegs); |
Derek Schuff | 1dbf7a5 | 2016-04-04 17:09:25 +0000 | [diff] [blame] | 50 | } |
| 51 | |
Mehdi Amini | 117296c | 2016-10-01 02:56:57 +0000 | [diff] [blame] | 52 | StringRef getPassName() const override { |
Craig Topper | 906c2cd | 2014-04-29 07:58:16 +0000 | [diff] [blame] | 53 | return "Hexagon Hardware Loop Fixup"; |
| 54 | } |
Krzysztof Parzyszek | 9a278f1 | 2013-02-11 21:37:55 +0000 | [diff] [blame] | 55 | |
Craig Topper | 906c2cd | 2014-04-29 07:58:16 +0000 | [diff] [blame] | 56 | void getAnalysisUsage(AnalysisUsage &AU) const override { |
Krzysztof Parzyszek | 9a278f1 | 2013-02-11 21:37:55 +0000 | [diff] [blame] | 57 | AU.setPreservesCFG(); |
| 58 | MachineFunctionPass::getAnalysisUsage(AU); |
| 59 | } |
| 60 | |
| 61 | private: |
Krzysztof Parzyszek | 9a278f1 | 2013-02-11 21:37:55 +0000 | [diff] [blame] | 62 | /// \brief Check the offset between each loop instruction and |
| 63 | /// the loop basic block to determine if we can use the LOOP instruction |
| 64 | /// or if we need to set the LC/SA registers explicitly. |
| 65 | bool fixupLoopInstrs(MachineFunction &MF); |
| 66 | |
Brendon Cahoon | 55bdeb7 | 2015-04-27 14:16:43 +0000 | [diff] [blame] | 67 | /// \brief Replace loop instruction with the constant extended |
| 68 | /// version if the loop label is too far from the loop instruction. |
| 69 | void useExtLoopInstr(MachineFunction &MF, |
| 70 | MachineBasicBlock::iterator &MII); |
Krzysztof Parzyszek | 9a278f1 | 2013-02-11 21:37:55 +0000 | [diff] [blame] | 71 | }; |
| 72 | |
| 73 | char HexagonFixupHwLoops::ID = 0; |
Alexander Kornienko | f00654e | 2015-06-23 09:49:53 +0000 | [diff] [blame] | 74 | } |
Krzysztof Parzyszek | 9a278f1 | 2013-02-11 21:37:55 +0000 | [diff] [blame] | 75 | |
| 76 | INITIALIZE_PASS(HexagonFixupHwLoops, "hwloopsfixup", |
| 77 | "Hexagon Hardware Loops Fixup", false, false) |
| 78 | |
| 79 | FunctionPass *llvm::createHexagonFixupHwLoops() { |
| 80 | return new HexagonFixupHwLoops(); |
| 81 | } |
| 82 | |
Krzysztof Parzyszek | 9a278f1 | 2013-02-11 21:37:55 +0000 | [diff] [blame] | 83 | /// \brief Returns true if the instruction is a hardware loop instruction. |
Duncan P. N. Exon Smith | 98226e3 | 2016-07-12 01:55:32 +0000 | [diff] [blame] | 84 | static bool isHardwareLoop(const MachineInstr &MI) { |
| 85 | return MI.getOpcode() == Hexagon::J2_loop0r || |
| 86 | MI.getOpcode() == Hexagon::J2_loop0i || |
| 87 | MI.getOpcode() == Hexagon::J2_loop1r || |
| 88 | MI.getOpcode() == Hexagon::J2_loop1i; |
Krzysztof Parzyszek | 9a278f1 | 2013-02-11 21:37:55 +0000 | [diff] [blame] | 89 | } |
| 90 | |
Krzysztof Parzyszek | 9a278f1 | 2013-02-11 21:37:55 +0000 | [diff] [blame] | 91 | bool HexagonFixupHwLoops::runOnMachineFunction(MachineFunction &MF) { |
Matthias Braun | f1caa28 | 2017-12-15 22:22:58 +0000 | [diff] [blame] | 92 | if (skipFunction(MF.getFunction())) |
Andrew Kaylor | 5b444a2 | 2016-04-26 19:46:28 +0000 | [diff] [blame] | 93 | return false; |
Brendon Cahoon | 55bdeb7 | 2015-04-27 14:16:43 +0000 | [diff] [blame] | 94 | return fixupLoopInstrs(MF); |
Krzysztof Parzyszek | 9a278f1 | 2013-02-11 21:37:55 +0000 | [diff] [blame] | 95 | } |
| 96 | |
Krzysztof Parzyszek | 9a278f1 | 2013-02-11 21:37:55 +0000 | [diff] [blame] | 97 | /// \brief For Hexagon, if the loop label is to far from the |
| 98 | /// loop instruction then we need to set the LC0 and SA0 registers |
| 99 | /// explicitly instead of using LOOP(start,count). This function |
| 100 | /// checks the distance, and generates register assignments if needed. |
| 101 | /// |
| 102 | /// This function makes two passes over the basic blocks. The first |
| 103 | /// pass computes the offset of the basic block from the start. |
| 104 | /// The second pass checks all the loop instructions. |
| 105 | bool HexagonFixupHwLoops::fixupLoopInstrs(MachineFunction &MF) { |
| 106 | |
| 107 | // Offset of the current instruction from the start. |
| 108 | unsigned InstOffset = 0; |
| 109 | // Map for each basic block to it's first instruction. |
Brendon Cahoon | 55bdeb7 | 2015-04-27 14:16:43 +0000 | [diff] [blame] | 110 | DenseMap<const MachineBasicBlock *, unsigned> BlockToInstOffset; |
| 111 | |
| 112 | const HexagonInstrInfo *HII = |
| 113 | static_cast<const HexagonInstrInfo *>(MF.getSubtarget().getInstrInfo()); |
Krzysztof Parzyszek | 9a278f1 | 2013-02-11 21:37:55 +0000 | [diff] [blame] | 114 | |
| 115 | // First pass - compute the offset of each basic block. |
Brendon Cahoon | 55bdeb7 | 2015-04-27 14:16:43 +0000 | [diff] [blame] | 116 | for (const MachineBasicBlock &MBB : MF) { |
| 117 | if (MBB.getAlignment()) { |
| 118 | // Although we don't know the exact layout of the final code, we need |
| 119 | // to account for alignment padding somehow. This heuristic pads each |
| 120 | // aligned basic block according to the alignment value. |
| 121 | int ByteAlign = (1u << MBB.getAlignment()) - 1; |
| 122 | InstOffset = (InstOffset + ByteAlign) & ~(ByteAlign); |
| 123 | } |
| 124 | |
| 125 | BlockToInstOffset[&MBB] = InstOffset; |
| 126 | for (const MachineInstr &MI : MBB) |
Krzysztof Parzyszek | f0b34a5 | 2016-07-29 21:49:42 +0000 | [diff] [blame] | 127 | InstOffset += HII->getSize(MI); |
Krzysztof Parzyszek | 9a278f1 | 2013-02-11 21:37:55 +0000 | [diff] [blame] | 128 | } |
| 129 | |
Brendon Cahoon | 55bdeb7 | 2015-04-27 14:16:43 +0000 | [diff] [blame] | 130 | // Second pass - check each loop instruction to see if it needs to be |
| 131 | // converted. |
Krzysztof Parzyszek | 9a278f1 | 2013-02-11 21:37:55 +0000 | [diff] [blame] | 132 | bool Changed = false; |
Brendon Cahoon | 55bdeb7 | 2015-04-27 14:16:43 +0000 | [diff] [blame] | 133 | for (MachineBasicBlock &MBB : MF) { |
| 134 | InstOffset = BlockToInstOffset[&MBB]; |
Krzysztof Parzyszek | 9a278f1 | 2013-02-11 21:37:55 +0000 | [diff] [blame] | 135 | |
| 136 | // Loop over all the instructions. |
Brendon Cahoon | 55bdeb7 | 2015-04-27 14:16:43 +0000 | [diff] [blame] | 137 | MachineBasicBlock::iterator MII = MBB.begin(); |
| 138 | MachineBasicBlock::iterator MIE = MBB.end(); |
Krzysztof Parzyszek | 9a278f1 | 2013-02-11 21:37:55 +0000 | [diff] [blame] | 139 | while (MII != MIE) { |
Krzysztof Parzyszek | f0b34a5 | 2016-07-29 21:49:42 +0000 | [diff] [blame] | 140 | InstOffset += HII->getSize(*MII); |
Krzysztof Parzyszek | 709e4f9 | 2017-08-10 15:00:30 +0000 | [diff] [blame] | 141 | if (MII->isMetaInstruction()) { |
Brendon Cahoon | 55bdeb7 | 2015-04-27 14:16:43 +0000 | [diff] [blame] | 142 | ++MII; |
| 143 | continue; |
| 144 | } |
Duncan P. N. Exon Smith | 98226e3 | 2016-07-12 01:55:32 +0000 | [diff] [blame] | 145 | if (isHardwareLoop(*MII)) { |
Krzysztof Parzyszek | 9a278f1 | 2013-02-11 21:37:55 +0000 | [diff] [blame] | 146 | assert(MII->getOperand(0).isMBB() && |
| 147 | "Expect a basic block as loop operand"); |
Brendon Cahoon | 55bdeb7 | 2015-04-27 14:16:43 +0000 | [diff] [blame] | 148 | int diff = InstOffset - BlockToInstOffset[MII->getOperand(0).getMBB()]; |
| 149 | if ((unsigned)abs(diff) > MaxLoopRange) { |
| 150 | useExtLoopInstr(MF, MII); |
| 151 | MII = MBB.erase(MII); |
Krzysztof Parzyszek | 9a278f1 | 2013-02-11 21:37:55 +0000 | [diff] [blame] | 152 | Changed = true; |
| 153 | } else { |
| 154 | ++MII; |
| 155 | } |
| 156 | } else { |
| 157 | ++MII; |
| 158 | } |
Krzysztof Parzyszek | 9a278f1 | 2013-02-11 21:37:55 +0000 | [diff] [blame] | 159 | } |
| 160 | } |
| 161 | |
| 162 | return Changed; |
| 163 | } |
| 164 | |
Brendon Cahoon | 55bdeb7 | 2015-04-27 14:16:43 +0000 | [diff] [blame] | 165 | /// \brief Replace loop instructions with the constant extended version. |
| 166 | void HexagonFixupHwLoops::useExtLoopInstr(MachineFunction &MF, |
| 167 | MachineBasicBlock::iterator &MII) { |
Eric Christopher | fc6de42 | 2014-08-05 02:39:49 +0000 | [diff] [blame] | 168 | const TargetInstrInfo *TII = MF.getSubtarget().getInstrInfo(); |
Krzysztof Parzyszek | 9a278f1 | 2013-02-11 21:37:55 +0000 | [diff] [blame] | 169 | MachineBasicBlock *MBB = MII->getParent(); |
| 170 | DebugLoc DL = MII->getDebugLoc(); |
Brendon Cahoon | 55bdeb7 | 2015-04-27 14:16:43 +0000 | [diff] [blame] | 171 | MachineInstrBuilder MIB; |
| 172 | unsigned newOp; |
| 173 | switch (MII->getOpcode()) { |
| 174 | case Hexagon::J2_loop0r: |
| 175 | newOp = Hexagon::J2_loop0rext; |
| 176 | break; |
| 177 | case Hexagon::J2_loop0i: |
| 178 | newOp = Hexagon::J2_loop0iext; |
| 179 | break; |
| 180 | case Hexagon::J2_loop1r: |
| 181 | newOp = Hexagon::J2_loop1rext; |
| 182 | break; |
| 183 | case Hexagon::J2_loop1i: |
| 184 | newOp = Hexagon::J2_loop1iext; |
| 185 | break; |
| 186 | default: |
| 187 | llvm_unreachable("Invalid Hardware Loop Instruction."); |
Krzysztof Parzyszek | 9a278f1 | 2013-02-11 21:37:55 +0000 | [diff] [blame] | 188 | } |
Brendon Cahoon | 55bdeb7 | 2015-04-27 14:16:43 +0000 | [diff] [blame] | 189 | MIB = BuildMI(*MBB, MII, DL, TII->get(newOp)); |
| 190 | |
| 191 | for (unsigned i = 0; i < MII->getNumOperands(); ++i) |
Diana Picus | 116bbab | 2017-01-13 09:58:52 +0000 | [diff] [blame] | 192 | MIB.add(MII->getOperand(i)); |
Krzysztof Parzyszek | 9a278f1 | 2013-02-11 21:37:55 +0000 | [diff] [blame] | 193 | } |