76 // The order in the returned sequence is the order of reaching defs in the
80 // covered by the defs in the list (see FullChain).
82 // (1) Returning the sequence of reaching defs for a particular reference
84 // (2) Returning a partial sequence of reaching defs, where the final goal
85 // is to traverse past phi nodes to the actual defs arising from the code
112   // Dead defs will be treated as if they were live, since they are actually  in getAllReachingDefs()
120   // The initial queue should not have reaching defs for shadows. The  in getAllReachingDefs()
122   // is not aliased to the reaching defs of the related shadows.  in getAllReachingDefs()
133   // Collect all the reaching defs, going up until a phi node is encountered,  in getAllReachingDefs()
134   // or there are no more reaching defs. From this set, the actual set of  in getAllReachingDefs()
135   // reaching defs will be selected.  in getAllReachingDefs()
137   // It is possible that a collection of non-covering (individually) defs  in getAllReachingDefs()
148     // Get the next level of reaching defs. This will include multiple  in getAllReachingDefs()
149     // reaching defs for shadows.  in getAllReachingDefs()
153     // Don't visit sibling defs. They share the same reaching def (which  in getAllReachingDefs()
168   SmallSet<NodeId, 32> Defs;  in getAllReachingDefs()  local
170   // Remove all non-phi defs that are not aliased to RefRR, and separate  in getAllReachingDefs()
171   // the the remaining defs into buckets for containing blocks.  in getAllReachingDefs()
179     Defs.insert(TA.Id);  in getAllReachingDefs()
242   // The vector is a list of instructions, so that defs coming from  in getAllReachingDefs()
245   // instruction, pick the defs that contribute to the covering (i.e. is  in getAllReachingDefs()
246   // not covered by previously added defs). Check the defs individually,  in getAllReachingDefs()
261   auto DefInSet = [&Defs](NodeAddr<RefNode *> TA) -> bool {  in getAllReachingDefs()
262     return TA.Addr->getKind() == NodeAttrs::Def && Defs.count(TA.Id);  in getAllReachingDefs()
273       // Add phi defs even if they are covered by subsequent defs. This is  in getAllReachingDefs()
274       // for cases where the reached use is not covered by any of the defs  in getAllReachingDefs()
287       // defs to actually define a register.  in getAllReachingDefs()
305                                 NodeSet &Visited, const NodeSet &Defs) {  in getAllReachingDefsRec()  argument
306   return getAllReachingDefsRecImpl(RefRR, RefA, Visited, Defs, 0, MaxRecNest);  in getAllReachingDefsRec()
311                                     NodeSet &Visited, const NodeSet &Defs,  in getAllReachingDefsRecImpl()  argument
318   for (NodeId D : Defs) {  in getAllReachingDefsRecImpl()
326     return {Defs, true};  in getAllReachingDefsRecImpl()
329   NodeSet TmpDefs = Defs;  in getAllReachingDefsRecImpl()
333   NodeSet Result = Defs;  in getAllReachingDefsRecImpl()
342     // Go over all phi uses and get the reaching defs for each use.  in getAllReachingDefsRecImpl()
419   // defs, no more uses can be reached.  in getAllReachedUses()
437   // Traverse all reached defs. This time dead defs cannot be ignored.  in getAllReachedUses()
448       // If it is a preserving def, do not update the set of intervening defs.  in getAllReachedUses()
479     // Go over all defs and collect the reached uses that are non-phi uses  in computePhiInfo()
484     // Have a work queue of defs whose reached uses need to be found.  in computePhiInfo()
485     // For each def, add to the queue all reached (non-phi) defs.  in computePhiInfo()
500     // phi defs, or (recursively) via non-phi defs reached by the phi defs.  in computePhiInfo()
502     // are actually reached by the phi defs.  in computePhiInfo()
505       // Visit all reached uses. Phi defs should not really have the "dead"  in computePhiInfo()
518       // Visit all reached defs, and add them to the queue. These defs may  in computePhiInfo()
546     //                        defs and uses from d1 will lead here.  in computePhiInfo()
551       // this phi's defs.  in computePhiInfo()
586     // Collect the phis that are among the reaching defs of these uses.  in computePhiInfo()
587     // While traversing the list of reaching defs for each phi use, accumulate  in computePhiInfo()
622     dbgs() << "Phi-up-to-phi map with intervening defs:\n";  in computePhiInfo()
649   // When propagating uses up the phi chains, get the all reaching defs  in computePhiInfo()
655   // defs, cache the result of subtracting these defs from a given register  in computePhiInfo()
803   // through the reaching defs of the corresponding phi uses.  in computeLiveIns()
822         // reaching defs will eventually lead to this phi.  in computeLiveIns()
823         // Any chain of reaching defs may fork at a phi node, but there  in computeLiveIns()
827         // For each reached "real" use, identify the set of reaching defs  in computeLiveIns()
837             // all reaching defs starting from the phi use, and treating  in computeLiveIns()
946       // implicit defs.  in resetKills()
987   // reaching defs of that register that are live on entry to the associated  in traverse()
1001   // LiveUses -= Defs(B);  in traverse()
1030   // Add reaching defs of phi uses that are live on exit from this block.  in traverse()
1041   // The LiveIn map at this point has all defs that are live-on-exit from B,  in traverse()
1043   // defs that are present in this block. Then we will add reaching defs of  in traverse()
1046   // To filter out the defs, first make a copy of LiveIn, and then re-populate  in traverse()
1047   // LiveIn with the defs that should remain.  in traverse()
1061         // Defs from a different block need to be preserved. Defs from this  in traverse()
1062         // block will need to be processed further, except for phi defs, the  in traverse()
1068       // Defs from this block need to stop the liveness from being  in traverse()
1069       // propagated upwards. This only applies to non-preserving defs,  in traverse()
1070       // and to the parts of the register actually covered by those defs.  in traverse()
1071       // (Note that phi defs should always be preserving.)  in traverse()
1086       // the last in a chain of aliased defs before the exit from this block.  in traverse()
1087       // There could be other defs in this block that are a part of that  in traverse()
1088       // chain. Check that now: accumulate the registers from these defs,  in traverse()
1094         // Reaching defs are ordered in the upward direction.  in traverse()
1099           // Subtract all accumulated defs (RRs) from LRef.  in traverse()
1120     dbgs() << "after defs in block\n";  in traverse()
1147   // are not dominated by their corresponding reaching defs.  in traverse()