reference, declarationdefinition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

lib/Target/Hexagon/HexagonOptAddrMode.cpp
  167   NodeId OffsetRegRD = 0;
  262         NodeId id = PA.Id;
  287   NodeId LRExtRegRD = 0;
lib/Target/Hexagon/HexagonRDFOpt.cpp
   94   bool rewrite(NodeAddr<InstrNode*> IA, SetVector<NodeId> &Remove);
  153   const SetVector<NodeId> &DeadNodes = getDeadNodes();
  154   const SetVector<NodeId> &DeadInstrs = getDeadInstrs();
  156   using RefToInstrMap = DenseMap<NodeId, NodeId>;
  156   using RefToInstrMap = DenseMap<NodeId, NodeId>;
  159   SetVector<NodeId> PartlyDead;
  175   SetVector<NodeId> Remove = DeadInstrs;
  178   for (NodeId N : PartlyDead) {
  197   DenseMap<NodeId,unsigned> OpMap;
  214 bool HexagonDCE::rewrite(NodeAddr<InstrNode*> IA, SetVector<NodeId> &Remove) {
lib/Target/Hexagon/RDFCopy.cpp
   88 NodeId CopyPropagation::getLocalReachingDef(RegisterRef RefRR,
   95     if (NodeId RD = RA.Addr->getReachingDef())
  106     for (NodeId I : Copies) {
  133   for (NodeId C : Copies) {
  153       NodeId AtCopy = getLocalReachingDef(SR, SA);
  155       for (NodeId N = DA.Addr->getReachedUse(), NextN; N; N = NextN) {
  166         NodeId AtUse = getLocalReachingDef(SR, IA);
lib/Target/Hexagon/RDFCopy.h
   49     std::map<NodeId, EqualityMap> CopyMap;
   50     std::vector<NodeId> Copies;
   54     NodeId getLocalReachingDef(RegisterRef RefRR, NodeAddr<InstrNode*> IA);
lib/Target/Hexagon/RDFDeadCode.cpp
   83       SetQueue<NodeId> &WorkQ) {
   95       SetQueue<NodeId> &WorkQ) {
  106       SetQueue<NodeId> &WorkQ) {
  127   SetQueue<NodeId> WorkQ;
  133     NodeId N = WorkQ.pop_front();
  144     for (NodeId N : LiveNodes) {
  179 bool DeadCodeElimination::erase(const SetVector<NodeId> &Nodes) {
lib/Target/Hexagon/RDFDeadCode.h
   39     bool erase(const SetVector<NodeId> &Nodes);
   43     SetVector<NodeId> getDeadNodes() { return DeadNodes; }
   44     SetVector<NodeId> getDeadInstrs() { return DeadInstrs; }
   49     SetVector<NodeId> LiveNodes;
   50     SetVector<NodeId> DeadNodes;
   51     SetVector<NodeId> DeadInstrs;
   59     void scanInstr(NodeAddr<InstrNode*> IA, SetQueue<NodeId> &WorkQ);
   60     void processDef(NodeAddr<DefNode*> DA, SetQueue<NodeId> &WorkQ);
   61     void processUse(NodeAddr<UseNode*> UA, SetQueue<NodeId> &WorkQ);
lib/Target/Hexagon/RDFGraph.cpp
   67 raw_ostream &operator<< (raw_ostream &OS, const Print<NodeId> &P) {
  119   if (NodeId N = P.Obj.Addr->getReachingDef())
  122   if (NodeId N = P.Obj.Addr->getReachedDef())
  125   if (NodeId N = P.Obj.Addr->getReachedUse())
  128   if (NodeId N = P.Obj.Addr->getSibling())
  136   if (NodeId N = P.Obj.Addr->getReachingDef())
  139   if (NodeId N = P.Obj.Addr->getSibling())
  148   if (NodeId N = P.Obj.Addr->getReachingDef())
  151   if (NodeId N = P.Obj.Addr->getPredecessor())
  154   if (NodeId N = P.Obj.Addr->getSibling())
  377 NodeId NodeAllocator::id(const NodeBase *P) const {
  397   NodeId Nx = Next;
  446 void DefNode::linkToDef(NodeId Self, NodeAddr<DefNode*> DA) {
  453 void UseNode::linkToDef(NodeId Self, NodeAddr<DefNode*> DA) {
  480     NodeId Self = G.id(this);
  512     NodeId MX = MA.Addr->getNext();
  695 void DataFlowGraph::DefStack::start_block(NodeId N) {
  703 void DataFlowGraph::DefStack::clear_block(NodeId N) {
  764 NodeBase *DataFlowGraph::ptr(NodeId N) const {
  771 NodeId DataFlowGraph::id(const NodeBase *P) const {
  998 void DataFlowGraph::markBlock(NodeId B, DefStackMap &DefM) {
 1005 void DataFlowGraph::releaseBlock(NodeId B, DefStackMap &DefM) {
 1133   NodeId Start = RA.Id;
 1198   NodeId Start = RA.Id;
 1519   SetVector<NodeId> PhiQ;
 1546       if (NodeId RD = RA.Addr->getReachingDef()) {
 1722   NodeId RD = UA.Addr->getReachingDef();
 1723   NodeId Sib = UA.Addr->getSibling();
 1738     NodeId S = TA.Addr->getSibling();
 1767   NodeId RD = DA.Addr->getReachingDef();
 1797   NodeId Sib = DA.Addr->getSibling();
 1814       NodeId S = TA.Addr->getSibling();
lib/Target/Hexagon/RDFGraph.h
  336     NodeAddr(T A, NodeId I) : Addr(A), Id(I) {}
  352     NodeId Id = 0;
  383     NodeBase *ptr(NodeId N) const {
  390     NodeId id(const NodeBase *P) const;
  457     NodeId   getNext()  const { return Next; }
  469     void setNext(NodeId N) { Next = N; }
  474     NodeId Next;                // Id of the next node in the circular chain.
  479       NodeId DD, DU;          // Ids of the first reached def and use.
  482       NodeId PredB;           // Id of the predecessor block for a phi use.
  486       NodeId FirstM, LastM;   // Id of the first member and last.
  489       NodeId RD, Sib;         // Ids of the reaching def and the sibling.
  513   using NodeSet = std::set<NodeId>;
  528     NodeId getReachingDef() const {
  531     void setReachingDef(NodeId RD) {
  535     NodeId getSibling() const {
  538     void setSibling(NodeId Sib) {
  559     NodeId getReachedDef() const {
  562     void setReachedDef(NodeId D) {
  565     NodeId getReachedUse() const {
  568     void setReachedUse(NodeId U) {
  572     void linkToDef(NodeId Self, NodeAddr<DefNode*> DA);
  576     void linkToDef(NodeId Self, NodeAddr<DefNode*> DA);
  580     NodeId getPredecessor() const {
  584     void setPredecessor(NodeId B) {
  649     NodeBase *ptr(NodeId N) const;
  650     template <typename T> T ptr(NodeId N) const {
  654     NodeId id(const NodeBase *P) const;
  656     template <typename T> NodeAddr<T> addr(NodeId N) const {
  713       void start_block(NodeId N);
  714       void clear_block(NodeId N);
  721       bool isDelimiter(const StorageType::value_type &P, NodeId N = 0) const {
  737     void markBlock(NodeId B, DefStackMap &DefM);
  738     void releaseBlock(NodeId B, DefStackMap &DefM);
  845     using BlockRefsMap = std::map<NodeId, RegisterSet>;
  942   raw_ostream &operator<<(raw_ostream &OS, const Print<NodeId> &P);
lib/Target/Hexagon/RDFLiveness.cpp
  110   SetVector<NodeId> DefQ;
  111   SetVector<NodeId> Owners;
  124   NodeId Start = RefA.Id;
  126   if (NodeId RD = SNA.Addr->getReachingDef())
  130       if (NodeId RD = NodeAddr<RefNode*>(S).Addr->getReachingDef())
  152       if (NodeId RD = NodeAddr<RefNode*>(S).Addr->getReachingDef())
  158   SetVector<NodeId> Defs;
  159   for (NodeId N : DefQ) {
  207   std::vector<NodeId> Tmp(Owners.begin(), Owners.end());
  230   for (NodeId T : Tmp) {
  282   for (NodeId D : Defs) {
  326   NodeId FindId = IA.Id;
  391   NodeId U = !IsDead ? DefA.Addr->getReachedUse() : 0;
  403   for (NodeId D = DefA.Addr->getReachedDef(), NextD; D != 0; D = NextD) {
  437   std::map<NodeId,std::map<NodeId,RegisterAggr>> PhiUp;
  437   std::map<NodeId,std::map<NodeId,RegisterAggr>> PhiUp;
  438   std::vector<NodeId> PhiUQ;  // Work list of phis for upward propagation.
  439   std::map<NodeId,RegisterAggr> PhiDRs;  // Phi -> registers defined by it.
  450     SetVector<NodeId> DefQ;
  472       NodeId UN = !IsDead ? DA.Addr->getReachedUse() : 0;
  485       NodeId DN = DA.Addr->getReachedDef();
  518       for (std::pair<NodeId,LaneBitmask> I : Uses) {
  565           NodeId RP = D.Addr->getOwner(DFG).Id;
  566           std::map<NodeId,RegisterAggr> &M = PhiUp[PUA.Id];
  621       std::map<NodeId,RegisterAggr> &PUM = PhiUp[UA.Id];
  623       for (const std::pair<NodeId,RegisterAggr> &P : PUM) {
  648           for (std::pair<NodeId,LaneBitmask> V : T.second) {
  773           for (std::pair<NodeId,LaneBitmask> P : RS.second) {
  921 MachineBasicBlock *Liveness::getBlockWithRef(NodeId RN) const {
lib/Target/Hexagon/RDFLiveness.h
   49     using NodeRef = std::pair<NodeId, LaneBitmask>;
   86     const RefMap &getRealUses(NodeId P) const {
  113     using NodeBlockMap = DenseMap<NodeId, MachineBasicBlock *>;
  121     std::map<NodeId, RefMap> RealUseMap;
  136     MachineBasicBlock *getBlockWithRef(NodeId RN) const;