Lines Matching full:outgoing

1894 // After creating a control flow hub, the operands of PHINodes in an outgoing
1939 // out successors that are not in the set of outgoing blocks.
1942 // - Succ1 is non-null iff the sole/taken target is an outgoing block.
1944 //         target is an outgoing block.
1947               const BBSetVector &Outgoing) {
1955   Succ0 = Outgoing.count(Succ0) ? Succ0 : nullptr;
1962     Succ1 = Outgoing.count(Succ1) ? Succ1 : nullptr;
1980 // control to the corresponding outgoing block or the next guard
1981 // block. The last guard block has two outgoing blocks as successors
1982 // since the condition for the final outgoing block is trivially
1984 // than the number of outgoing blocks.
1986                                 const BBSetVector &Outgoing,
1989   // outgoing block to the list of guard blocks.
1990   GuardBlocks.push_back(Outgoing.back());
1993     auto Out = Outgoing[i];
2006     const BBSetVector &Incoming, const BBSetVector &Outgoing,
2019         redirectToHub(In, FirstGuardBlock, Outgoing);
2023       auto Succ0Iter = find(Outgoing, Succ0);
2024       auto Succ1Iter = find(Outgoing, Succ1);
2026                                     std::distance(Outgoing.begin(), Succ0Iter));
2028                                     std::distance(Outgoing.begin(), Succ1Iter));
2033       auto SuccIter = Succ0 ? find(Outgoing, Succ0) : find(Outgoing, Succ1);
2035                                     std::distance(Outgoing.begin(), SuccIter));
2040   for (int i = 0, e = Outgoing.size() - 1; i != e; ++i) {
2041     auto Out = Outgoing[i];
2049 /// We record the predicate of each outgoing block using a phi of boolean.
2051     const BBSetVector &Incoming, const BBSetVector &Outgoing,
2059   // The predicate for the last outgoing is trivially true, and so we
2061   for (int i = 0, e = Outgoing.size() - 1; i != e; ++i) {
2062     auto Out = Outgoing[i];
2076         redirectToHub(In, FirstGuardBlock, Outgoing);
2079     // Succ0 and Succ1 in the set of outgoing blocks. The predicates
2086     for (int i = 0, e = Outgoing.size() - 1; i != e; ++i) {
2087       auto Out = Outgoing[i];
2092         // Optimization: When only one successor is an outgoing block,
2112 // \p Outgoing blocks.
2114 // There is one guard predicate for each outgoing block OutBB. The
2117 // them in the same order as the Outgoing set-vector, and control
2118 // branches to the first outgoing block whose predicate evaluates to true.
2123                          const BBSetVector &Outgoing, const StringRef Prefix,
2128   for (int i = 0, e = Outgoing.size() - 1; i != e; ++i)
2136   // number of outgoing block.
2137   if (!MaxControlFlowBooleans || Outgoing.size() <= *MaxControlFlowBooleans)
2138     calcPredicateUsingBooleans(Incoming, Outgoing, GuardBlocks, GuardPredicates,
2141     calcPredicateUsingInteger(Incoming, Outgoing, GuardBlocks, GuardPredicates);
2143   setupBranchForGuard(GuardBlocks, Outgoing, GuardPredicates);
2148     const BBSetVector &Incoming, const BBSetVector &Outgoing,
2150   if (Outgoing.size() < 2)
2151     return Outgoing.front();
2157         if (Outgoing.count(Succ))
2163   convertToGuardPredicates(GuardBlocks, DeletionCandidates, Incoming, Outgoing,
2167   // Update the PHINodes in each outgoing block to match the new control flow.
2169     reconnectPhis(Outgoing[i], GuardBlocks[i], Incoming, FirstGuardBlock);
2171   reconnectPhis(Outgoing.back(), GuardBlocks.back(), Incoming, FirstGuardBlock);
2175     assert((int)Outgoing.size() == NumGuards + 1);
2181       Updates.push_back({DominatorTree::Insert, GuardBlocks[i], Outgoing[i]});
2186                        Outgoing[NumGuards - 1]});
2188                        Outgoing[NumGuards]});