diff options
Diffstat (limited to 'contrib/llvm-project/llvm/lib/Target/Hexagon/HexagonRDFOpt.cpp')
| -rw-r--r-- | contrib/llvm-project/llvm/lib/Target/Hexagon/HexagonRDFOpt.cpp | 341 |
1 files changed, 341 insertions, 0 deletions
diff --git a/contrib/llvm-project/llvm/lib/Target/Hexagon/HexagonRDFOpt.cpp b/contrib/llvm-project/llvm/lib/Target/Hexagon/HexagonRDFOpt.cpp new file mode 100644 index 000000000000..f26e23befde2 --- /dev/null +++ b/contrib/llvm-project/llvm/lib/Target/Hexagon/HexagonRDFOpt.cpp @@ -0,0 +1,341 @@ +//===- HexagonRDFOpt.cpp --------------------------------------------------===// +// +// 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 +// +//===----------------------------------------------------------------------===// + +#include "HexagonInstrInfo.h" +#include "HexagonSubtarget.h" +#include "MCTargetDesc/HexagonBaseInfo.h" +#include "RDFCopy.h" +#include "RDFDeadCode.h" +#include "llvm/ADT/DenseMap.h" +#include "llvm/ADT/STLExtras.h" +#include "llvm/ADT/SetVector.h" +#include "llvm/CodeGen/MachineDominanceFrontier.h" +#include "llvm/CodeGen/MachineDominators.h" +#include "llvm/CodeGen/MachineFunction.h" +#include "llvm/CodeGen/MachineFunctionPass.h" +#include "llvm/CodeGen/MachineInstr.h" +#include "llvm/CodeGen/MachineOperand.h" +#include "llvm/CodeGen/MachineRegisterInfo.h" +#include "llvm/CodeGen/RDFGraph.h" +#include "llvm/CodeGen/RDFLiveness.h" +#include "llvm/CodeGen/RDFRegisters.h" +#include "llvm/InitializePasses.h" +#include "llvm/Pass.h" +#include "llvm/Support/CommandLine.h" +#include "llvm/Support/Compiler.h" +#include "llvm/Support/Debug.h" +#include "llvm/Support/ErrorHandling.h" +#include "llvm/Support/raw_ostream.h" +#include <cassert> +#include <limits> +#include <utility> + +using namespace llvm; +using namespace rdf; + +namespace llvm { + + void initializeHexagonRDFOptPass(PassRegistry&); + FunctionPass *createHexagonRDFOpt(); + +} // end namespace llvm + +static unsigned RDFCount = 0; + +static cl::opt<unsigned> RDFLimit("rdf-limit", + cl::init(std::numeric_limits<unsigned>::max())); +static cl::opt<bool> RDFDump("rdf-dump", cl::init(false)); + +namespace { + + class HexagonRDFOpt : public MachineFunctionPass { + public: + HexagonRDFOpt() : MachineFunctionPass(ID) {} + + void getAnalysisUsage(AnalysisUsage &AU) const override { + AU.addRequired<MachineDominatorTree>(); + AU.addRequired<MachineDominanceFrontier>(); + AU.setPreservesAll(); + MachineFunctionPass::getAnalysisUsage(AU); + } + + StringRef getPassName() const override { + return "Hexagon RDF optimizations"; + } + + bool runOnMachineFunction(MachineFunction &MF) override; + + MachineFunctionProperties getRequiredProperties() const override { + return MachineFunctionProperties().set( + MachineFunctionProperties::Property::NoVRegs); + } + + static char ID; + + private: + MachineDominatorTree *MDT; + MachineRegisterInfo *MRI; + }; + +struct HexagonCP : public CopyPropagation { + HexagonCP(DataFlowGraph &G) : CopyPropagation(G) {} + + bool interpretAsCopy(const MachineInstr *MI, EqualityMap &EM) override; +}; + +struct HexagonDCE : public DeadCodeElimination { + HexagonDCE(DataFlowGraph &G, MachineRegisterInfo &MRI) + : DeadCodeElimination(G, MRI) {} + + bool rewrite(NodeAddr<InstrNode*> IA, SetVector<NodeId> &Remove); + void removeOperand(NodeAddr<InstrNode*> IA, unsigned OpNum); + + bool run(); +}; + +} // end anonymous namespace + +char HexagonRDFOpt::ID = 0; + +INITIALIZE_PASS_BEGIN(HexagonRDFOpt, "hexagon-rdf-opt", + "Hexagon RDF optimizations", false, false) +INITIALIZE_PASS_DEPENDENCY(MachineDominatorTree) +INITIALIZE_PASS_DEPENDENCY(MachineDominanceFrontier) +INITIALIZE_PASS_END(HexagonRDFOpt, "hexagon-rdf-opt", + "Hexagon RDF optimizations", false, false) + +bool HexagonCP::interpretAsCopy(const MachineInstr *MI, EqualityMap &EM) { + auto mapRegs = [&EM] (RegisterRef DstR, RegisterRef SrcR) -> void { + EM.insert(std::make_pair(DstR, SrcR)); + }; + + DataFlowGraph &DFG = getDFG(); + unsigned Opc = MI->getOpcode(); + switch (Opc) { + case Hexagon::A2_combinew: { + const MachineOperand &DstOp = MI->getOperand(0); + const MachineOperand &HiOp = MI->getOperand(1); + const MachineOperand &LoOp = MI->getOperand(2); + assert(DstOp.getSubReg() == 0 && "Unexpected subregister"); + mapRegs(DFG.makeRegRef(DstOp.getReg(), Hexagon::isub_hi), + DFG.makeRegRef(HiOp.getReg(), HiOp.getSubReg())); + mapRegs(DFG.makeRegRef(DstOp.getReg(), Hexagon::isub_lo), + DFG.makeRegRef(LoOp.getReg(), LoOp.getSubReg())); + return true; + } + case Hexagon::A2_addi: { + const MachineOperand &A = MI->getOperand(2); + if (!A.isImm() || A.getImm() != 0) + return false; + LLVM_FALLTHROUGH; + } + case Hexagon::A2_tfr: { + const MachineOperand &DstOp = MI->getOperand(0); + const MachineOperand &SrcOp = MI->getOperand(1); + mapRegs(DFG.makeRegRef(DstOp.getReg(), DstOp.getSubReg()), + DFG.makeRegRef(SrcOp.getReg(), SrcOp.getSubReg())); + return true; + } + } + + return CopyPropagation::interpretAsCopy(MI, EM); +} + +bool HexagonDCE::run() { + bool Collected = collect(); + if (!Collected) + return false; + + const SetVector<NodeId> &DeadNodes = getDeadNodes(); + const SetVector<NodeId> &DeadInstrs = getDeadInstrs(); + + using RefToInstrMap = DenseMap<NodeId, NodeId>; + + RefToInstrMap R2I; + SetVector<NodeId> PartlyDead; + DataFlowGraph &DFG = getDFG(); + + for (NodeAddr<BlockNode*> BA : DFG.getFunc().Addr->members(DFG)) { + for (auto TA : BA.Addr->members_if(DFG.IsCode<NodeAttrs::Stmt>, DFG)) { + NodeAddr<StmtNode*> SA = TA; + for (NodeAddr<RefNode*> RA : SA.Addr->members(DFG)) { + R2I.insert(std::make_pair(RA.Id, SA.Id)); + if (DFG.IsDef(RA) && DeadNodes.count(RA.Id)) + if (!DeadInstrs.count(SA.Id)) + PartlyDead.insert(SA.Id); + } + } + } + + // Nodes to remove. + SetVector<NodeId> Remove = DeadInstrs; + + bool Changed = false; + for (NodeId N : PartlyDead) { + auto SA = DFG.addr<StmtNode*>(N); + if (trace()) + dbgs() << "Partly dead: " << *SA.Addr->getCode(); + Changed |= rewrite(SA, Remove); + } + + return erase(Remove) || Changed; +} + +void HexagonDCE::removeOperand(NodeAddr<InstrNode*> IA, unsigned OpNum) { + MachineInstr *MI = NodeAddr<StmtNode*>(IA).Addr->getCode(); + + auto getOpNum = [MI] (MachineOperand &Op) -> unsigned { + for (unsigned i = 0, n = MI->getNumOperands(); i != n; ++i) + if (&MI->getOperand(i) == &Op) + return i; + llvm_unreachable("Invalid operand"); + }; + DenseMap<NodeId,unsigned> OpMap; + DataFlowGraph &DFG = getDFG(); + NodeList Refs = IA.Addr->members(DFG); + for (NodeAddr<RefNode*> RA : Refs) + OpMap.insert(std::make_pair(RA.Id, getOpNum(RA.Addr->getOp()))); + + MI->RemoveOperand(OpNum); + + for (NodeAddr<RefNode*> RA : Refs) { + unsigned N = OpMap[RA.Id]; + if (N < OpNum) + RA.Addr->setRegRef(&MI->getOperand(N), DFG); + else if (N > OpNum) + RA.Addr->setRegRef(&MI->getOperand(N-1), DFG); + } +} + +bool HexagonDCE::rewrite(NodeAddr<InstrNode*> IA, SetVector<NodeId> &Remove) { + if (!getDFG().IsCode<NodeAttrs::Stmt>(IA)) + return false; + DataFlowGraph &DFG = getDFG(); + MachineInstr &MI = *NodeAddr<StmtNode*>(IA).Addr->getCode(); + auto &HII = static_cast<const HexagonInstrInfo&>(DFG.getTII()); + if (HII.getAddrMode(MI) != HexagonII::PostInc) + return false; + unsigned Opc = MI.getOpcode(); + unsigned OpNum, NewOpc; + switch (Opc) { + case Hexagon::L2_loadri_pi: + NewOpc = Hexagon::L2_loadri_io; + OpNum = 1; + break; + case Hexagon::L2_loadrd_pi: + NewOpc = Hexagon::L2_loadrd_io; + OpNum = 1; + break; + case Hexagon::V6_vL32b_pi: + NewOpc = Hexagon::V6_vL32b_ai; + OpNum = 1; + break; + case Hexagon::S2_storeri_pi: + NewOpc = Hexagon::S2_storeri_io; + OpNum = 0; + break; + case Hexagon::S2_storerd_pi: + NewOpc = Hexagon::S2_storerd_io; + OpNum = 0; + break; + case Hexagon::V6_vS32b_pi: + NewOpc = Hexagon::V6_vS32b_ai; + OpNum = 0; + break; + default: + return false; + } + auto IsDead = [this] (NodeAddr<DefNode*> DA) -> bool { + return getDeadNodes().count(DA.Id); + }; + NodeList Defs; + MachineOperand &Op = MI.getOperand(OpNum); + for (NodeAddr<DefNode*> DA : IA.Addr->members_if(DFG.IsDef, DFG)) { + if (&DA.Addr->getOp() != &Op) + continue; + Defs = DFG.getRelatedRefs(IA, DA); + if (!llvm::all_of(Defs, IsDead)) + return false; + break; + } + + // Mark all nodes in Defs for removal. + for (auto D : Defs) + Remove.insert(D.Id); + + if (trace()) + dbgs() << "Rewriting: " << MI; + MI.setDesc(HII.get(NewOpc)); + MI.getOperand(OpNum+2).setImm(0); + removeOperand(IA, OpNum); + if (trace()) + dbgs() << " to: " << MI; + + return true; +} + +bool HexagonRDFOpt::runOnMachineFunction(MachineFunction &MF) { + if (skipFunction(MF.getFunction())) + return false; + + if (RDFLimit.getPosition()) { + if (RDFCount >= RDFLimit) + return false; + RDFCount++; + } + + MDT = &getAnalysis<MachineDominatorTree>(); + const auto &MDF = getAnalysis<MachineDominanceFrontier>(); + const auto &HII = *MF.getSubtarget<HexagonSubtarget>().getInstrInfo(); + const auto &HRI = *MF.getSubtarget<HexagonSubtarget>().getRegisterInfo(); + MRI = &MF.getRegInfo(); + bool Changed; + + if (RDFDump) + MF.print(dbgs() << "Before " << getPassName() << "\n", nullptr); + + TargetOperandInfo TOI(HII); + DataFlowGraph G(MF, HII, HRI, *MDT, MDF, TOI); + // Dead phi nodes are necessary for copy propagation: we can add a use + // of a register in a block where it would need a phi node, but which + // was dead (and removed) during the graph build time. + G.build(BuildOptions::KeepDeadPhis); + + if (RDFDump) + dbgs() << "Starting copy propagation on: " << MF.getName() << '\n' + << PrintNode<FuncNode*>(G.getFunc(), G) << '\n'; + HexagonCP CP(G); + CP.trace(RDFDump); + Changed = CP.run(); + + if (RDFDump) + dbgs() << "Starting dead code elimination on: " << MF.getName() << '\n' + << PrintNode<FuncNode*>(G.getFunc(), G) << '\n'; + HexagonDCE DCE(G, *MRI); + DCE.trace(RDFDump); + Changed |= DCE.run(); + + if (Changed) { + if (RDFDump) + dbgs() << "Starting liveness recomputation on: " << MF.getName() << '\n'; + Liveness LV(*MRI, G); + LV.trace(RDFDump); + LV.computeLiveIns(); + LV.resetLiveIns(); + LV.resetKills(); + } + + if (RDFDump) + MF.print(dbgs() << "After " << getPassName() << "\n", nullptr); + + return false; +} + +FunctionPass *llvm::createHexagonRDFOpt() { + return new HexagonRDFOpt(); +} |