Target/Hexagon/HexagonLoopIdiomRecognition.cpp

79   cl::desc("Disable generation of memcpy in loop idiom recognition"));
83   cl::desc("Disable generation of memmove in loop idiom recognition"));
92     "runtime loop count (mem transfer size) is known at compile-time."));
127       return "Recognize Hexagon-specific loop idioms";
258 INITIALIZE_PASS_BEGIN(HexagonLoopIdiomRecognize, "hexagon-loop-idiom",
259     "Recognize Hexagon-specific loop idioms", false, false)
267 INITIALIZE_PASS_END(HexagonLoopIdiomRecognize, "hexagon-loop-idiom",
268     "Recognize Hexagon-specific loop idioms", false, false)
560     explicit PolynomialMultiplyRecognize(Loop *loop, const DataLayout &dl,
563       : CurLoop(loop), DL(dl), DT(dt), TLI(tli), SE(se) {}
882   //     R' = (R >> 1) ^ Q      ; R is cycled through the loop, so it must
912     // If X is loop invariant, it must be the input polynomial, and the
918       // X is not loop invariant. If X == R, this is the inverse pmpy.
1058   // coming from the loop block will be promoted to another type, and so the
1076   // Check all instructions in the loop.
1131     // The cycle p1->p2->p1 would span two loop iterations.
1332     // If the instruction does not commute with shifts, the loop cannot
1338       // Skip users from outside of the loop. They will be handled later.
1445   // Update the users outside of the loop to account for having left
1446   // shifts. They would normally be shifted right in the loop, so shift
1447   // them right after the loop exit.
1448   // Take advantage of the loop-closed SSA form, which has all the post-
1449   // loop values in phi nodes.
1764   LLVM_DEBUG(dbgs() << "Starting PolynomialMultiplyRecognize on loop\n"
1767   // - The loop must consist of a single block.
1769   // - The loop must have an induction variable starting from 0, and
1770   //   incremented in each iteration of the loop.
1801   // loop can only contain a single transformable operation, so stop the
1803   // XXX: Currently this approach can modify the loop before being 100% sure
1842     // to a left-shifting loop, the working data type must be at least as
1869   // Scan the loop again, find the generating select instruction.
1929   // loop, which indicates a strided store.  If we have something else, it's a
1936   // know that every byte is touched in the loop.
1950   // loop, which indicates a strided load.  If we have something else, it's a
1965 /// mayLoopAccessLocation - Return true if the specified loop might access the
1966 /// specified pointer location, which is a loop-strided access.  The 'Access'
1973   // Get the location that may be stored across the loop.  Since the access
1978   // If the loop iterates a fixed number of times, we can refine the access
2023   // loop, which indicates a strided load.  If we have something else, it's a
2028   // The trip count of the loop and the base pointer of the addrec SCEV is
2029   // guaranteed to be loop invariant, which means that it should dominate the
2034   SCEVExpander Expander(*SE, *DL, "hexagon-loop-idiom");
2039   // this into a memcpy/memmove in the loop preheader now if we want.  However,
2040   // this would be unsafe to do if there is anything else in the loop that may
2097     // of the loop, so we need to make sure that there is nothing else in
2098     // the loop than the load, store and instructions that these two depend
2114   // mutated by the loop.
2301 // cover the loop in the sense that the loop could be safely eliminated once
2311   // Collect all instructions from the loop that the instructions in Insts
2314   // will be limited only to instructions contained in the loop.
2328   // Scan all instructions in the loop, if any of them have a user outside
2329   // of the loop, or outside of the expressions collected above, then either
2330   // the loop has a side-effect visible outside of it, or there are
2352 /// runOnLoopBlock - Process the specified block, which lives in a counted loop
2354 /// loop and not in any subloops.
2358   // executed in the loop.  For a block to be unconditionally executed, it has
2359   // to dominate all the exit blocks of the loop.  Verify this now.
2388          "runOnCountableLoop() called on a loop without a predictable"
2396   // Scan all the blocks in the loop that are not in subloops.
2415   // If the loop could not be converted to canonical form, it must have an
2420   // Disable loop idiom recognition if the function's name is a common idiom.