/** See llvm::createLoopUnrollPass function. */
void LLVMAddLoopUnrollPass(LLVMPassManagerRef PM);
-/** See llvm::createLoopUnrollAndJamPass function. */
-void LLVMAddLoopUnrollAndJamPass(LLVMPassManagerRef PM);
-
/** See llvm::createLoopUnswitchPass function. */
void LLVMAddLoopUnswitchPass(LLVMPassManagerRef PM);
bool AllowPeeling;
/// Allow unrolling of all the iterations of the runtime loop remainder.
bool UnrollRemainder;
- /// Allow unroll and jam. Used to enable unroll and jam for the target.
- bool UnrollAndJam;
- /// Threshold for unroll and jam, for inner loop size. The 'Threshold'
- /// value above is used during unroll and jam for the outer loop size.
- /// This value is used in the same manner to limit the size of the inner
- /// loop.
- unsigned UnrollAndJamInnerLoopThreshold;
};
/// Get target-customized preferences for the generic loop unrolling
void initializeLoopSimplifyPass(PassRegistry&);
void initializeLoopStrengthReducePass(PassRegistry&);
void initializeLoopUnrollPass(PassRegistry&);
-void initializeLoopUnrollAndJamPass(PassRegistry&);
void initializeLoopUnswitchPass(PassRegistry&);
void initializeLoopVectorizePass(PassRegistry&);
void initializeLoopVersioningLICMPass(PassRegistry&);
(void) llvm::createLoopStrengthReducePass();
(void) llvm::createLoopRerollPass();
(void) llvm::createLoopUnrollPass();
- (void) llvm::createLoopUnrollAndJamPass();
(void) llvm::createLoopUnswitchPass();
(void) llvm::createLoopVersioningLICMPass();
(void) llvm::createLoopIdiomPass();
//===----------------------------------------------------------------------===//
//
-// LoopUnrollAndJam - This pass is a simple loop unroll and jam pass.
-//
-Pass *createLoopUnrollAndJamPass(int OptLevel = 2);
-
-//===----------------------------------------------------------------------===//
-//
// LoopReroll - This pass is a simple loop rerolling pass.
//
Pass *createLoopRerollPass();
+++ /dev/null
-//===- LoopUnrollAndJamPass.h -----------------------------------*- C++ -*-===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_TRANSFORMS_SCALAR_LOOPUNROLLANDJAMPASS_H
-#define LLVM_TRANSFORMS_SCALAR_LOOPUNROLLANDJAMPASS_H
-
-#include "llvm/Analysis/LoopAnalysisManager.h"
-#include "llvm/Analysis/LoopInfo.h"
-#include "llvm/IR/PassManager.h"
-
-namespace llvm {
-
-class Loop;
-struct LoopStandardAnalysisResults;
-class LPMUpdater;
-
-/// A simple loop rotation transformation.
-class LoopUnrollAndJamPass : public PassInfoMixin<LoopUnrollAndJamPass> {
- const int OptLevel;
-
-public:
- explicit LoopUnrollAndJamPass(int OptLevel = 2) : OptLevel(OptLevel) {}
- PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,
- LoopStandardAnalysisResults &AR, LPMUpdater &U);
-};
-
-} // end namespace llvm
-
-#endif // LLVM_TRANSFORMS_SCALAR_LOOPUNROLLANDJAMPASS_H
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Analysis/TargetTransformInfo.h"
-#include "llvm/Transforms/Utils/ValueMapper.h"
namespace llvm {
class AssumptionCache;
class BasicBlock;
-class DependenceInfo;
class DominatorTree;
class Loop;
class LoopInfo;
bool peelLoop(Loop *L, unsigned PeelCount, LoopInfo *LI, ScalarEvolution *SE,
DominatorTree *DT, AssumptionCache *AC, bool PreserveLCSSA);
-LoopUnrollResult UnrollAndJamLoop(Loop *L, unsigned Count, unsigned TripCount,
- unsigned TripMultiple, bool UnrollRemainder,
- LoopInfo *LI, ScalarEvolution *SE,
- DominatorTree *DT, AssumptionCache *AC,
- OptimizationRemarkEmitter *ORE);
-
-bool isSafeToUnrollAndJam(Loop *L, ScalarEvolution &SE, DominatorTree &DT,
- DependenceInfo &DI);
-
-bool computeUnrollCount(Loop *L, const TargetTransformInfo &TTI,
- DominatorTree &DT, LoopInfo *LI, ScalarEvolution &SE,
- const SmallPtrSetImpl<const Value *> &EphValues,
- OptimizationRemarkEmitter *ORE, unsigned &TripCount,
- unsigned MaxTripCount, unsigned &TripMultiple,
- unsigned LoopSize,
- TargetTransformInfo::UnrollingPreferences &UP,
- bool &UseUpperBound);
-
-BasicBlock *foldBlockIntoPredecessor(BasicBlock *BB, LoopInfo *LI,
- ScalarEvolution *SE, DominatorTree *DT);
-
-void remapInstruction(Instruction *I, ValueToValueMapTy &VMap);
-
-void simplifyLoopAfterUnroll(Loop *L, bool SimplifyIVs, LoopInfo *LI,
- ScalarEvolution *SE, DominatorTree *DT,
- AssumptionCache *AC);
-
MDNode *GetUnrollMetadata(MDNode *LoopID, StringRef Name);
-TargetTransformInfo::UnrollingPreferences gatherUnrollingPreferences(
- Loop *L, ScalarEvolution &SE, const TargetTransformInfo &TTI, int OptLevel,
- Optional<unsigned> UserThreshold, Optional<unsigned> UserCount,
- Optional<bool> UserAllowPartial, Optional<bool> UserRuntime,
- Optional<bool> UserUpperBound, Optional<bool> UserAllowPeeling);
-
-unsigned ApproximateLoopSize(const Loop *L, unsigned &NumCalls,
- bool &NotDuplicatable, bool &Convergent,
- const TargetTransformInfo &TTI,
- const SmallPtrSetImpl<const Value *> &EphValues,
- unsigned BEInsns);
-
} // end namespace llvm
#endif // LLVM_TRANSFORMS_UTILS_UNROLLLOOP_H
#include "llvm/Transforms/Scalar/LoopSimplifyCFG.h"
#include "llvm/Transforms/Scalar/LoopSink.h"
#include "llvm/Transforms/Scalar/LoopStrengthReduce.h"
-#include "llvm/Transforms/Scalar/LoopUnrollAndJamPass.h"
#include "llvm/Transforms/Scalar/LoopUnrollPass.h"
#include "llvm/Transforms/Scalar/LowerAtomic.h"
#include "llvm/Transforms/Scalar/LowerExpectIntrinsic.h"
"enable-npm-gvn-sink", cl::init(false), cl::Hidden,
cl::desc("Enable the GVN hoisting pass for the new PM (default = off)"));
-static cl::opt<bool> EnableUnrollAndJam(
- "enable-npm-unroll-and-jam", cl::init(false), cl::Hidden,
- cl::desc("Enable the Unroll and Jam pass for the new PM (default = off)"));
-
static cl::opt<bool> EnableSyntheticCounts(
"enable-npm-synthetic-counts", cl::init(false), cl::Hidden, cl::ZeroOrMore,
cl::desc("Run synthetic function entry count generation "
// FIXME: It would be really good to use a loop-integrated instruction
// combiner for cleanup here so that the unrolling and LICM can be pipelined
// across the loop nests.
- // We do UnrollAndJam in a separate LPM to ensure it happens before unroll
- if (EnableUnrollAndJam) {
- OptimizePM.addPass(
- createFunctionToLoopPassAdaptor(LoopUnrollAndJamPass(Level)));
- }
OptimizePM.addPass(LoopUnrollPass(Level));
OptimizePM.addPass(InstCombinePass());
OptimizePM.addPass(RequireAnalysisPass<OptimizationRemarkEmitterAnalysis, Function>());
LOOP_PASS("strength-reduce", LoopStrengthReducePass())
LOOP_PASS("indvars", IndVarSimplifyPass())
LOOP_PASS("irce", IRCEPass())
-LOOP_PASS("unroll-and-jam", LoopUnrollAndJamPass())
LOOP_PASS("unroll-full", LoopFullUnrollPass())
LOOP_PASS("unswitch", SimpleLoopUnswitchPass())
LOOP_PASS("print-access-info", LoopAccessInfoPrinterPass(dbgs()))
UP.Runtime = true;
UP.UnrollRemainder = true;
UP.DefaultUnrollRuntimeCount = 4;
- UP.UnrollAndJam = true;
- UP.UnrollAndJamInnerLoopThreshold = 60;
// Force unrolling small loops can be very useful because of the branch
// taken cost of the backedge.
"enable-loopinterchange", cl::init(false), cl::Hidden,
cl::desc("Enable the new, experimental LoopInterchange Pass"));
-static cl::opt<bool> EnableUnrollAndJam("enable-unroll-and-jam",
- cl::init(false), cl::Hidden,
- cl::desc("Enable Unroll And Jam Pass"));
-
static cl::opt<bool>
EnablePrepareForThinLTO("prepare-for-thinlto", cl::init(false), cl::Hidden,
cl::desc("Enable preparation for ThinLTO."));
addInstructionCombiningPass(MPM);
if (!DisableUnrollLoops) {
- if (EnableUnrollAndJam) {
- // Unroll and Jam. We do this before unroll but need to be in a separate
- // loop pass manager in order for the outer loop to be processed by
- // unroll and jam before the inner loop is unrolled.
- MPM.add(createLoopUnrollAndJamPass(OptLevel));
- }
-
MPM.add(createLoopUnrollPass(OptLevel)); // Unroll small loops
// LoopUnroll may generate some redundency to cleanup.
LoopSimplifyCFG.cpp
LoopStrengthReduce.cpp
LoopUnrollPass.cpp
- LoopUnrollAndJamPass.cpp
LoopUnswitch.cpp
LoopVersioningLICM.cpp
LowerAtomic.cpp
+++ /dev/null
-//===- LoopUnrollAndJam.cpp - Loop unroll and jam pass --------------------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This pass implements an unroll and jam pass. Most of the work is done by
-// Utils/UnrollLoopAndJam.cpp.
-//===----------------------------------------------------------------------===//
-
-#include "llvm/Transforms/Scalar/LoopUnrollAndJamPass.h"
-#include "llvm/ADT/None.h"
-#include "llvm/ADT/STLExtras.h"
-#include "llvm/ADT/SmallPtrSet.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/Analysis/AssumptionCache.h"
-#include "llvm/Analysis/CodeMetrics.h"
-#include "llvm/Analysis/DependenceAnalysis.h"
-#include "llvm/Analysis/LoopAnalysisManager.h"
-#include "llvm/Analysis/LoopInfo.h"
-#include "llvm/Analysis/LoopPass.h"
-#include "llvm/Analysis/OptimizationRemarkEmitter.h"
-#include "llvm/Analysis/ScalarEvolution.h"
-#include "llvm/Analysis/TargetTransformInfo.h"
-#include "llvm/IR/BasicBlock.h"
-#include "llvm/IR/CFG.h"
-#include "llvm/IR/Constant.h"
-#include "llvm/IR/Constants.h"
-#include "llvm/IR/Dominators.h"
-#include "llvm/IR/Function.h"
-#include "llvm/IR/Instruction.h"
-#include "llvm/IR/Instructions.h"
-#include "llvm/IR/IntrinsicInst.h"
-#include "llvm/IR/Metadata.h"
-#include "llvm/IR/PassManager.h"
-#include "llvm/Pass.h"
-#include "llvm/Support/Casting.h"
-#include "llvm/Support/CommandLine.h"
-#include "llvm/Support/Debug.h"
-#include "llvm/Support/ErrorHandling.h"
-#include "llvm/Support/raw_ostream.h"
-#include "llvm/Transforms/Scalar.h"
-#include "llvm/Transforms/Scalar/LoopPassManager.h"
-#include "llvm/Transforms/Utils.h"
-#include "llvm/Transforms/Utils/LoopUtils.h"
-#include "llvm/Transforms/Utils/UnrollLoop.h"
-#include <algorithm>
-#include <cassert>
-#include <cstdint>
-#include <string>
-
-using namespace llvm;
-
-#define DEBUG_TYPE "loop-unroll-and-jam"
-
-static cl::opt<unsigned> UnrollAndJamCount(
- "unroll-and-jam-count", cl::Hidden,
- cl::desc("Use this unroll count for all loops including those with "
- "unroll_and_jam_count pragma values, for testing purposes"));
-
-static cl::opt<unsigned> UnrollAndJamThreshold(
- "unroll-and-jam-threshold", cl::init(60), cl::Hidden,
- cl::desc("Threshold to use for inner loop when doing unroll and jam."));
-
-static cl::opt<unsigned> PragmaUnrollAndJamThreshold(
- "pragma-unroll-and-jam-threshold", cl::init(1024), cl::Hidden,
- cl::desc("Unrolled size limit for loops with an unroll_and_jam(full) or "
- "unroll_count pragma."));
-
-// Returns the loop hint metadata node with the given name (for example,
-// "llvm.loop.unroll.count"). If no such metadata node exists, then nullptr is
-// returned.
-static MDNode *GetUnrollMetadataForLoop(const Loop *L, StringRef Name) {
- if (MDNode *LoopID = L->getLoopID())
- return GetUnrollMetadata(LoopID, Name);
- return nullptr;
-}
-
-// Returns true if the loop has any metadata starting with Prefix. For example a
-// Prefix of "llvm.loop.unroll." returns true if we have any unroll metadata.
-static bool HasAnyUnrollPragma(const Loop *L, StringRef Prefix) {
- if (MDNode *LoopID = L->getLoopID()) {
- // First operand should refer to the loop id itself.
- assert(LoopID->getNumOperands() > 0 && "requires at least one operand");
- assert(LoopID->getOperand(0) == LoopID && "invalid loop id");
-
- for (unsigned i = 1, e = LoopID->getNumOperands(); i < e; ++i) {
- MDNode *MD = dyn_cast<MDNode>(LoopID->getOperand(i));
- if (!MD)
- continue;
-
- MDString *S = dyn_cast<MDString>(MD->getOperand(0));
- if (!S)
- continue;
-
- if (S->getString().startswith(Prefix))
- return true;
- }
- }
- return false;
-}
-
-// Returns true if the loop has an unroll_and_jam(enable) pragma.
-static bool HasUnrollAndJamEnablePragma(const Loop *L) {
- return GetUnrollMetadataForLoop(L, "llvm.loop.unroll_and_jam.enable");
-}
-
-// Returns true if the loop has an unroll_and_jam(disable) pragma.
-static bool HasUnrollAndJamDisablePragma(const Loop *L) {
- return GetUnrollMetadataForLoop(L, "llvm.loop.unroll_and_jam.disable");
-}
-
-// If loop has an unroll_and_jam_count pragma return the (necessarily
-// positive) value from the pragma. Otherwise return 0.
-static unsigned UnrollAndJamCountPragmaValue(const Loop *L) {
- MDNode *MD = GetUnrollMetadataForLoop(L, "llvm.loop.unroll_and_jam.count");
- if (MD) {
- assert(MD->getNumOperands() == 2 &&
- "Unroll count hint metadata should have two operands.");
- unsigned Count =
- mdconst::extract<ConstantInt>(MD->getOperand(1))->getZExtValue();
- assert(Count >= 1 && "Unroll count must be positive.");
- return Count;
- }
- return 0;
-}
-
-// Returns loop size estimation for unrolled loop.
-static uint64_t
-getUnrollAndJammedLoopSize(unsigned LoopSize,
- TargetTransformInfo::UnrollingPreferences &UP) {
- assert(LoopSize >= UP.BEInsns && "LoopSize should not be less than BEInsns!");
- return static_cast<uint64_t>(LoopSize - UP.BEInsns) * UP.Count + UP.BEInsns;
-}
-
-// Calculates unroll and jam count and writes it to UP.Count. Returns true if
-// unroll count was set explicitly.
-static bool computeUnrollAndJamCount(
- Loop *L, Loop *SubLoop, const TargetTransformInfo &TTI, DominatorTree &DT,
- LoopInfo *LI, ScalarEvolution &SE,
- const SmallPtrSetImpl<const Value *> &EphValues,
- OptimizationRemarkEmitter *ORE, unsigned OuterTripCount,
- unsigned OuterTripMultiple, unsigned OuterLoopSize, unsigned InnerTripCount,
- unsigned InnerLoopSize, TargetTransformInfo::UnrollingPreferences &UP) {
- // Check for explicit Count from the "unroll-and-jam-count" option.
- bool UserUnrollCount = UnrollAndJamCount.getNumOccurrences() > 0;
- if (UserUnrollCount) {
- UP.Count = UnrollAndJamCount;
- UP.Force = true;
- if (UP.AllowRemainder &&
- getUnrollAndJammedLoopSize(OuterLoopSize, UP) < UP.Threshold &&
- getUnrollAndJammedLoopSize(InnerLoopSize, UP) <
- UP.UnrollAndJamInnerLoopThreshold)
- return true;
- }
-
- // Check for unroll_and_jam pragmas
- unsigned PragmaCount = UnrollAndJamCountPragmaValue(L);
- if (PragmaCount > 0) {
- UP.Count = PragmaCount;
- UP.Runtime = true;
- UP.Force = true;
- if ((UP.AllowRemainder || (OuterTripMultiple % PragmaCount == 0)) &&
- getUnrollAndJammedLoopSize(OuterLoopSize, UP) < UP.Threshold &&
- getUnrollAndJammedLoopSize(InnerLoopSize, UP) <
- UP.UnrollAndJamInnerLoopThreshold)
- return true;
- }
-
- // Use computeUnrollCount from the loop unroller to get a sensible count
- // for the unrolling the outer loop. This uses UP.Threshold /
- // UP.PartialThreshold / UP.MaxCount to come up with sensible loop values.
- // We have already checked that the loop has no unroll.* pragmas.
- unsigned MaxTripCount = 0;
- bool UseUpperBound = false;
- bool ExplicitUnroll = computeUnrollCount(
- L, TTI, DT, LI, SE, EphValues, ORE, OuterTripCount, MaxTripCount,
- OuterTripMultiple, OuterLoopSize, UP, UseUpperBound);
- if (ExplicitUnroll || UseUpperBound) {
- // If the user explicitly set the loop as unrolled, dont UnJ it. Leave it
- // for the unroller instead.
- UP.Count = 0;
- return false;
- }
-
- bool PragmaEnableUnroll = HasUnrollAndJamEnablePragma(L);
- ExplicitUnroll = PragmaCount > 0 || PragmaEnableUnroll || UserUnrollCount;
-
- // If the loop has an unrolling pragma, we want to be more aggressive with
- // unrolling limits.
- if (ExplicitUnroll && OuterTripCount != 0)
- UP.UnrollAndJamInnerLoopThreshold = PragmaUnrollAndJamThreshold;
-
- if (!UP.AllowRemainder && getUnrollAndJammedLoopSize(InnerLoopSize, UP) >=
- UP.UnrollAndJamInnerLoopThreshold) {
- UP.Count = 0;
- return false;
- }
-
- // If the inner loop count is known and small, leave the entire loop nest to
- // be the unroller
- if (!ExplicitUnroll && InnerTripCount &&
- InnerLoopSize * InnerTripCount < UP.Threshold) {
- UP.Count = 0;
- return false;
- }
-
- // We have a sensible limit for the outer loop, now adjust it for the inner
- // loop and UP.UnrollAndJamInnerLoopThreshold.
- while (UP.Count != 0 && UP.AllowRemainder &&
- getUnrollAndJammedLoopSize(InnerLoopSize, UP) >=
- UP.UnrollAndJamInnerLoopThreshold)
- UP.Count--;
-
- if (!ExplicitUnroll) {
- // Check for situations where UnJ is likely to be unprofitable. Including
- // subloops with more than 1 block.
- if (SubLoop->getBlocks().size() != 1) {
- UP.Count = 0;
- return false;
- }
-
- // Limit to loops where there is something to gain from unrolling and
- // jamming the loop. In this case, look for loads that are invariant in the
- // outer loop and can become shared.
- unsigned NumInvariant = 0;
- for (BasicBlock *BB : SubLoop->getBlocks()) {
- for (Instruction &I : *BB) {
- if (auto *Ld = dyn_cast<LoadInst>(&I)) {
- Value *V = Ld->getPointerOperand();
- const SCEV *LSCEV = SE.getSCEVAtScope(V, L);
- if (SE.isLoopInvariant(LSCEV, L))
- NumInvariant++;
- }
- }
- }
- if (NumInvariant == 0) {
- UP.Count = 0;
- return false;
- }
- }
-
- return ExplicitUnroll;
-}
-
-static LoopUnrollResult
-tryToUnrollAndJamLoop(Loop *L, DominatorTree &DT, LoopInfo *LI,
- ScalarEvolution &SE, const TargetTransformInfo &TTI,
- AssumptionCache &AC, DependenceInfo &DI,
- OptimizationRemarkEmitter &ORE, int OptLevel) {
- // Quick checks of the correct loop form
- if (!L->isLoopSimplifyForm() || L->getSubLoops().size() != 1)
- return LoopUnrollResult::Unmodified;
- Loop *SubLoop = L->getSubLoops()[0];
- if (!SubLoop->isLoopSimplifyForm())
- return LoopUnrollResult::Unmodified;
-
- BasicBlock *Latch = L->getLoopLatch();
- BasicBlock *Exit = L->getExitingBlock();
- BasicBlock *SubLoopLatch = SubLoop->getLoopLatch();
- BasicBlock *SubLoopExit = SubLoop->getExitingBlock();
-
- if (Latch != Exit || SubLoopLatch != SubLoopExit)
- return LoopUnrollResult::Unmodified;
-
- TargetTransformInfo::UnrollingPreferences UP = gatherUnrollingPreferences(
- L, SE, TTI, OptLevel, None, None, None, None, None, None);
- if (UnrollAndJamThreshold.getNumOccurrences() > 0)
- UP.UnrollAndJamInnerLoopThreshold = UnrollAndJamThreshold;
- // Exit early if unrolling is disabled.
- if (!UP.UnrollAndJam || UP.UnrollAndJamInnerLoopThreshold == 0)
- return LoopUnrollResult::Unmodified;
-
- LLVM_DEBUG(dbgs() << "Loop Unroll and Jam: F["
- << L->getHeader()->getParent()->getName() << "] Loop %"
- << L->getHeader()->getName() << "\n");
-
- // A loop with any unroll pragma (enabling/disabling/count/etc) is left for
- // the unroller, so long as it does not explicitly have unroll_and_jam
- // metadata. This means #pragma nounroll will disable unroll and jam as well
- // as unrolling
- if (HasUnrollAndJamDisablePragma(L) ||
- (HasAnyUnrollPragma(L, "llvm.loop.unroll.") &&
- !HasAnyUnrollPragma(L, "llvm.loop.unroll_and_jam."))) {
- LLVM_DEBUG(dbgs() << " Disabled due to pragma.\n");
- return LoopUnrollResult::Unmodified;
- }
-
- if (!isSafeToUnrollAndJam(L, SE, DT, DI)) {
- LLVM_DEBUG(dbgs() << " Disabled due to not being safe.\n");
- return LoopUnrollResult::Unmodified;
- }
-
- // Approximate the loop size and collect useful info
- unsigned NumInlineCandidates;
- bool NotDuplicatable;
- bool Convergent;
- SmallPtrSet<const Value *, 32> EphValues;
- CodeMetrics::collectEphemeralValues(L, &AC, EphValues);
- unsigned InnerLoopSize =
- ApproximateLoopSize(SubLoop, NumInlineCandidates, NotDuplicatable,
- Convergent, TTI, EphValues, UP.BEInsns);
- unsigned OuterLoopSize =
- ApproximateLoopSize(L, NumInlineCandidates, NotDuplicatable, Convergent,
- TTI, EphValues, UP.BEInsns);
- LLVM_DEBUG(dbgs() << " Outer Loop Size: " << OuterLoopSize << "\n");
- LLVM_DEBUG(dbgs() << " Inner Loop Size: " << InnerLoopSize << "\n");
- if (NotDuplicatable) {
- LLVM_DEBUG(dbgs() << " Not unrolling loop which contains non-duplicatable "
- "instructions.\n");
- return LoopUnrollResult::Unmodified;
- }
- if (NumInlineCandidates != 0) {
- LLVM_DEBUG(dbgs() << " Not unrolling loop with inlinable calls.\n");
- return LoopUnrollResult::Unmodified;
- }
- if (Convergent) {
- LLVM_DEBUG(
- dbgs() << " Not unrolling loop with convergent instructions.\n");
- return LoopUnrollResult::Unmodified;
- }
-
- // Find trip count and trip multiple
- unsigned OuterTripCount = SE.getSmallConstantTripCount(L, Latch);
- unsigned OuterTripMultiple = SE.getSmallConstantTripMultiple(L, Latch);
- unsigned InnerTripCount = SE.getSmallConstantTripCount(SubLoop, SubLoopLatch);
-
- // Decide if, and by how much, to unroll
- bool IsCountSetExplicitly = computeUnrollAndJamCount(
- L, SubLoop, TTI, DT, LI, SE, EphValues, &ORE, OuterTripCount,
- OuterTripMultiple, OuterLoopSize, InnerTripCount, InnerLoopSize, UP);
- if (UP.Count <= 1)
- return LoopUnrollResult::Unmodified;
- // Unroll factor (Count) must be less or equal to TripCount.
- if (OuterTripCount && UP.Count > OuterTripCount)
- UP.Count = OuterTripCount;
-
- LoopUnrollResult UnrollResult =
- UnrollAndJamLoop(L, UP.Count, OuterTripCount, OuterTripMultiple,
- UP.UnrollRemainder, LI, &SE, &DT, &AC, &ORE);
-
- // If loop has an unroll count pragma or unrolled by explicitly set count
- // mark loop as unrolled to prevent unrolling beyond that requested.
- if (UnrollResult != LoopUnrollResult::FullyUnrolled && IsCountSetExplicitly)
- L->setLoopAlreadyUnrolled();
-
- return UnrollResult;
-}
-
-namespace {
-
-class LoopUnrollAndJam : public LoopPass {
-public:
- static char ID; // Pass ID, replacement for typeid
- unsigned OptLevel;
-
- LoopUnrollAndJam(int OptLevel = 2) : LoopPass(ID), OptLevel(OptLevel) {
- initializeLoopUnrollAndJamPass(*PassRegistry::getPassRegistry());
- }
-
- bool runOnLoop(Loop *L, LPPassManager &LPM) override {
- if (skipLoop(L))
- return false;
-
- Function &F = *L->getHeader()->getParent();
-
- auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
- LoopInfo *LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
- ScalarEvolution &SE = getAnalysis<ScalarEvolutionWrapperPass>().getSE();
- const TargetTransformInfo &TTI =
- getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F);
- auto &AC = getAnalysis<AssumptionCacheTracker>().getAssumptionCache(F);
- auto &DI = getAnalysis<DependenceAnalysisWrapperPass>().getDI();
- // For the old PM, we can't use OptimizationRemarkEmitter as an analysis
- // pass. Function analyses need to be preserved across loop transformations
- // but ORE cannot be preserved (see comment before the pass definition).
- OptimizationRemarkEmitter ORE(&F);
-
- LoopUnrollResult Result =
- tryToUnrollAndJamLoop(L, DT, LI, SE, TTI, AC, DI, ORE, OptLevel);
-
- if (Result == LoopUnrollResult::FullyUnrolled)
- LPM.markLoopAsDeleted(*L);
-
- return Result != LoopUnrollResult::Unmodified;
- }
-
- /// This transformation requires natural loop information & requires that
- /// loop preheaders be inserted into the CFG...
- void getAnalysisUsage(AnalysisUsage &AU) const override {
- AU.addRequired<AssumptionCacheTracker>();
- AU.addRequired<TargetTransformInfoWrapperPass>();
- AU.addRequired<DependenceAnalysisWrapperPass>();
- getLoopAnalysisUsage(AU);
- }
-};
-
-} // end anonymous namespace
-
-char LoopUnrollAndJam::ID = 0;
-
-INITIALIZE_PASS_BEGIN(LoopUnrollAndJam, "loop-unroll-and-jam",
- "Unroll and Jam loops", false, false)
-INITIALIZE_PASS_DEPENDENCY(AssumptionCacheTracker)
-INITIALIZE_PASS_DEPENDENCY(LoopPass)
-INITIALIZE_PASS_DEPENDENCY(TargetTransformInfoWrapperPass)
-INITIALIZE_PASS_DEPENDENCY(DependenceAnalysisWrapperPass)
-INITIALIZE_PASS_END(LoopUnrollAndJam, "loop-unroll-and-jam",
- "Unroll and Jam loops", false, false)
-
-Pass *llvm::createLoopUnrollAndJamPass(int OptLevel) {
- return new LoopUnrollAndJam(OptLevel);
-}
-
-PreservedAnalyses LoopUnrollAndJamPass::run(Loop &L, LoopAnalysisManager &AM,
- LoopStandardAnalysisResults &AR,
- LPMUpdater &) {
- const auto &FAM =
- AM.getResult<FunctionAnalysisManagerLoopProxy>(L, AR).getManager();
- Function *F = L.getHeader()->getParent();
-
- auto *ORE = FAM.getCachedResult<OptimizationRemarkEmitterAnalysis>(*F);
- // FIXME: This should probably be optional rather than required.
- if (!ORE)
- report_fatal_error(
- "LoopUnrollAndJamPass: OptimizationRemarkEmitterAnalysis not cached at "
- "a higher level");
-
- DependenceInfo DI(F, &AR.AA, &AR.SE, &AR.LI);
-
- LoopUnrollResult Result = tryToUnrollAndJamLoop(
- &L, AR.DT, &AR.LI, AR.SE, AR.TTI, AR.AC, DI, *ORE, OptLevel);
-
- if (Result == LoopUnrollResult::Unmodified)
- return PreservedAnalyses::all();
-
- return getLoopPassPreservedAnalyses();
-}
/// Gather the various unrolling parameters based on the defaults, compiler
/// flags, TTI overrides and user specified parameters.
-TargetTransformInfo::UnrollingPreferences llvm::gatherUnrollingPreferences(
+static TargetTransformInfo::UnrollingPreferences gatherUnrollingPreferences(
Loop *L, ScalarEvolution &SE, const TargetTransformInfo &TTI, int OptLevel,
Optional<unsigned> UserThreshold, Optional<unsigned> UserCount,
Optional<bool> UserAllowPartial, Optional<bool> UserRuntime,
UP.Force = false;
UP.UpperBound = false;
UP.AllowPeeling = true;
- UP.UnrollAndJam = false;
- UP.UnrollAndJamInnerLoopThreshold = 60;
// Override with any target specific settings
TTI.getUnrollingPreferences(L, SE, UP);
}
/// ApproximateLoopSize - Approximate the size of the loop.
-unsigned llvm::ApproximateLoopSize(
- const Loop *L, unsigned &NumCalls, bool &NotDuplicatable, bool &Convergent,
- const TargetTransformInfo &TTI,
- const SmallPtrSetImpl<const Value *> &EphValues, unsigned BEInsns) {
+static unsigned
+ApproximateLoopSize(const Loop *L, unsigned &NumCalls, bool &NotDuplicatable,
+ bool &Convergent, const TargetTransformInfo &TTI,
+ const SmallPtrSetImpl<const Value *> &EphValues,
+ unsigned BEInsns) {
CodeMetrics Metrics;
for (BasicBlock *BB : L->blocks())
Metrics.analyzeBasicBlock(BB, TTI, EphValues);
// Returns true if unroll count was set explicitly.
// Calculates unroll count and writes it to UP.Count.
-bool llvm::computeUnrollCount(
+static bool computeUnrollCount(
Loop *L, const TargetTransformInfo &TTI, DominatorTree &DT, LoopInfo *LI,
ScalarEvolution &SE, const SmallPtrSetImpl<const Value *> &EphValues,
OptimizationRemarkEmitter *ORE, unsigned &TripCount, unsigned MaxTripCount,
if (ExplicitUnroll && TripCount != 0) {
// If the loop has an unrolling pragma, we want to be more aggressive with
- // unrolling limits. Set thresholds to at least the PragmaUnrollThreshold
- // value which is larger than the default limits.
+ // unrolling limits. Set thresholds to at least the PragmaThreshold value
+ // which is larger than the default limits.
UP.Threshold = std::max<unsigned>(UP.Threshold, PragmaUnrollThreshold);
UP.PartialThreshold =
std::max<unsigned>(UP.PartialThreshold, PragmaUnrollThreshold);
initializeLoopStrengthReducePass(Registry);
initializeLoopRerollPass(Registry);
initializeLoopUnrollPass(Registry);
- initializeLoopUnrollAndJamPass(Registry);
initializeLoopUnswitchPass(Registry);
initializeLoopVersioningLICMPass(Registry);
initializeLoopIdiomRecognizeLegacyPassPass(Registry);
unwrap(PM)->add(createLoopUnrollPass());
}
-void LLVMAddLoopUnrollAndJamPass(LLVMPassManagerRef PM) {
- unwrap(PM)->add(createLoopUnrollAndJamPass());
-}
-
void LLVMAddLoopUnswitchPass(LLVMPassManagerRef PM) {
unwrap(PM)->add(createLoopUnswitchPass());
}
LoopRotationUtils.cpp
LoopSimplify.cpp
LoopUnroll.cpp
- LoopUnrollAndJam.cpp
LoopUnrollPeel.cpp
LoopUnrollRuntime.cpp
LoopUtils.cpp
/// Convert the instruction operands from referencing the current values into
/// those specified by VMap.
-void llvm::remapInstruction(Instruction *I, ValueToValueMapTy &VMap) {
+static inline void remapInstruction(Instruction *I,
+ ValueToValueMapTy &VMap) {
for (unsigned op = 0, E = I->getNumOperands(); op != E; ++op) {
Value *Op = I->getOperand(op);
/// Folds a basic block into its predecessor if it only has one predecessor, and
/// that predecessor only has one successor.
/// The LoopInfo Analysis that is passed will be kept consistent.
-BasicBlock *llvm::foldBlockIntoPredecessor(BasicBlock *BB, LoopInfo *LI,
- ScalarEvolution *SE,
- DominatorTree *DT) {
+static BasicBlock *
+foldBlockIntoPredecessor(BasicBlock *BB, LoopInfo *LI, ScalarEvolution *SE,
+ DominatorTree *DT) {
// Merge basic blocks into their predecessor if there is only one distinct
// pred, and if there is only one distinct successor of the predecessor, and
// if there are no PHI nodes.
if (OnlyPred->getTerminator()->getNumSuccessors() != 1)
return nullptr;
- LLVM_DEBUG(dbgs() << "Merging: " << BB->getName() << " into "
- << OnlyPred->getName() << "\n");
+ LLVM_DEBUG(dbgs() << "Merging: " << *BB << "into: " << *OnlyPred);
// Resolve any PHI nodes at the start of the block. They are all
// guaranteed to have exactly one entry if they exist, unless there are
/// Perform some cleanup and simplifications on loops after unrolling. It is
/// useful to simplify the IV's in the new loop, as well as do a quick
/// simplify/dce pass of the instructions.
-void llvm::simplifyLoopAfterUnroll(Loop *L, bool SimplifyIVs, LoopInfo *LI,
- ScalarEvolution *SE, DominatorTree *DT,
- AssumptionCache *AC) {
+static void simplifyLoopAfterUnroll(Loop *L, bool SimplifyIVs, LoopInfo *LI,
+ ScalarEvolution *SE, DominatorTree *DT,
+ AssumptionCache *AC) {
// Simplify any new induction variables in the partially unrolled loop.
if (SE && SimplifyIVs) {
SmallVector<WeakTrackingVH, 16> DeadInsts;
if (Force)
RuntimeTripCount = false;
else {
- LLVM_DEBUG(dbgs() << "Won't unroll; remainder loop could not be "
- "generated when assuming runtime trip count\n");
+ LLVM_DEBUG(dbgs() << "Wont unroll; remainder loop could not be generated"
+ "when assuming runtime trip count\n");
return LoopUnrollResult::Unmodified;
}
}
+++ /dev/null
-//===-- LoopUnrollAndJam.cpp - Loop unrolling utilities -------------------===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-//
-// This file implements loop unroll and jam as a routine, much like
-// LoopUnroll.cpp implements loop unroll.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/ADT/SmallPtrSet.h"
-#include "llvm/ADT/Statistic.h"
-#include "llvm/Analysis/AssumptionCache.h"
-#include "llvm/Analysis/DependenceAnalysis.h"
-#include "llvm/Analysis/InstructionSimplify.h"
-#include "llvm/Analysis/LoopAnalysisManager.h"
-#include "llvm/Analysis/LoopIterator.h"
-#include "llvm/Analysis/LoopPass.h"
-#include "llvm/Analysis/OptimizationRemarkEmitter.h"
-#include "llvm/Analysis/ScalarEvolution.h"
-#include "llvm/Analysis/ScalarEvolutionExpander.h"
-#include "llvm/Analysis/Utils/Local.h"
-#include "llvm/IR/BasicBlock.h"
-#include "llvm/IR/DataLayout.h"
-#include "llvm/IR/DebugInfoMetadata.h"
-#include "llvm/IR/Dominators.h"
-#include "llvm/IR/IntrinsicInst.h"
-#include "llvm/IR/LLVMContext.h"
-#include "llvm/Support/Debug.h"
-#include "llvm/Support/raw_ostream.h"
-#include "llvm/Transforms/Utils/BasicBlockUtils.h"
-#include "llvm/Transforms/Utils/Cloning.h"
-#include "llvm/Transforms/Utils/LoopSimplify.h"
-#include "llvm/Transforms/Utils/LoopUtils.h"
-#include "llvm/Transforms/Utils/SimplifyIndVar.h"
-#include "llvm/Transforms/Utils/UnrollLoop.h"
-using namespace llvm;
-
-#define DEBUG_TYPE "loop-unroll-and-jam"
-
-STATISTIC(NumUnrolledAndJammed, "Number of loops unroll and jammed");
-STATISTIC(NumCompletelyUnrolledAndJammed, "Number of loops unroll and jammed");
-
-static bool containsBB(std::vector<BasicBlock *> &V, BasicBlock *BB) {
- return std::find(V.begin(), V.end(), BB) != V.end();
-}
-
-// Partition blocks in an outer/inner loop pair into blocks before and after
-// the loop
-static bool partitionOuterLoopBlocks(Loop *L, Loop *SubLoop,
- std::vector<BasicBlock *> &ForeBlocks,
- std::vector<BasicBlock *> &SubLoopBlocks,
- std::vector<BasicBlock *> &AftBlocks,
- DominatorTree *DT) {
- BasicBlock *SubLoopLatch = SubLoop->getLoopLatch();
- SubLoopBlocks = SubLoop->getBlocks();
-
- for (BasicBlock *BB : L->blocks()) {
- if (!SubLoop->contains(BB)) {
- if (DT->dominates(SubLoopLatch, BB))
- AftBlocks.push_back(BB);
- else
- ForeBlocks.push_back(BB);
- }
- }
-
- // Check that all blocks in ForeBlocks together dominate the subloop
- // TODO: This might ideally be done better with a dominator/postdominators.
- BasicBlock *SubLoopPreHeader = SubLoop->getLoopPreheader();
- for (BasicBlock *BB : ForeBlocks) {
- if (BB == SubLoopPreHeader)
- continue;
- TerminatorInst *TI = BB->getTerminator();
- for (unsigned i = 0, e = TI->getNumSuccessors(); i != e; ++i)
- if (!containsBB(ForeBlocks, TI->getSuccessor(i)))
- return false;
- }
-
- return true;
-}
-
-// Move the phi operands of Header from Latch out of AftBlocks to InsertLoc.
-static void
-moveHeaderPhiOperandsToForeBlocks(BasicBlock *Header, BasicBlock *Latch,
- Instruction *InsertLoc,
- std::vector<BasicBlock *> &AftBlocks) {
- // We need to ensure we move the instructions in the correct order,
- // starting with the earliest required instruction and moving forward.
- std::vector<Instruction *> Worklist;
- std::vector<Instruction *> Visited;
- for (auto &Phi : Header->phis()) {
- Value *V = Phi.getIncomingValueForBlock(Latch);
- if (Instruction *I = dyn_cast<Instruction>(V))
- Worklist.push_back(I);
- }
-
- while (!Worklist.empty()) {
- Instruction *I = Worklist.back();
- Worklist.pop_back();
- if (!containsBB(AftBlocks, I->getParent()))
- continue;
-
- Visited.push_back(I);
- for (auto &U : I->operands())
- if (Instruction *II = dyn_cast<Instruction>(U))
- Worklist.push_back(II);
- }
-
- // Move all instructions in program order to before the InsertLoc
- BasicBlock *InsertLocBB = InsertLoc->getParent();
- for (Instruction *I : reverse(Visited)) {
- if (I->getParent() != InsertLocBB)
- I->moveBefore(InsertLoc);
- }
-}
-
-/*
- This method performs Unroll and Jam. For a simple loop like:
- for (i = ..)
- Fore(i)
- for (j = ..)
- SubLoop(i, j)
- Aft(i)
-
- Instead of doing normal inner or outer unrolling, we do:
- for (i = .., i+=2)
- Fore(i)
- Fore(i+1)
- for (j = ..)
- SubLoop(i, j)
- SubLoop(i+1, j)
- Aft(i)
- Aft(i+1)
-
- So the outer loop is essetially unrolled and then the inner loops are fused
- ("jammed") together into a single loop. This can increase speed when there
- are loads in SubLoop that are invariant to i, as they become shared between
- the now jammed inner loops.
-
- We do this by spliting the blocks in the loop into Fore, Subloop and Aft.
- Fore blocks are those before the inner loop, Aft are those after. Normal
- Unroll code is used to copy each of these sets of blocks and the results are
- combined together into the final form above.
-
- isSafeToUnrollAndJam should be used prior to calling this to make sure the
- unrolling will be valid. Checking profitablility is also advisable.
-*/
-LoopUnrollResult
-llvm::UnrollAndJamLoop(Loop *L, unsigned Count, unsigned TripCount,
- unsigned TripMultiple, bool UnrollRemainder,
- LoopInfo *LI, ScalarEvolution *SE, DominatorTree *DT,
- AssumptionCache *AC, OptimizationRemarkEmitter *ORE) {
-
- // When we enter here we should have already checked that it is safe
- BasicBlock *Header = L->getHeader();
- assert(L->getSubLoops().size() == 1);
- Loop *SubLoop = *L->begin();
-
- // Don't enter the unroll code if there is nothing to do.
- if (TripCount == 0 && Count < 2) {
- LLVM_DEBUG(dbgs() << "Won't unroll; almost nothing to do\n");
- return LoopUnrollResult::Unmodified;
- }
-
- assert(Count > 0);
- assert(TripMultiple > 0);
- assert(TripCount == 0 || TripCount % TripMultiple == 0);
-
- // Are we eliminating the loop control altogether?
- bool CompletelyUnroll = (Count == TripCount);
-
- // We use the runtime remainder in cases where we don't know trip multiple
- if (TripMultiple == 1 || TripMultiple % Count != 0) {
- if (!UnrollRuntimeLoopRemainder(L, Count, false /*AllowExpensiveTripCount*/,
- /*UseEpilogRemainder*/ true,
- UnrollRemainder, LI, SE, DT, AC, true)) {
- LLVM_DEBUG(dbgs() << "Won't unroll-and-jam; remainder loop could not be "
- "generated when assuming runtime trip count\n");
- return LoopUnrollResult::Unmodified;
- }
- }
-
- // Notify ScalarEvolution that the loop will be substantially changed,
- // if not outright eliminated.
- if (SE) {
- SE->forgetLoop(L);
- SE->forgetLoop(SubLoop);
- }
-
- using namespace ore;
- // Report the unrolling decision.
- if (CompletelyUnroll) {
- LLVM_DEBUG(dbgs() << "COMPLETELY UNROLL AND JAMMING loop %"
- << Header->getName() << " with trip count " << TripCount
- << "!\n");
- ORE->emit(OptimizationRemark(DEBUG_TYPE, "FullyUnrolled", L->getStartLoc(),
- L->getHeader())
- << "completely unroll and jammed loop with "
- << NV("UnrollCount", TripCount) << " iterations");
- } else {
- auto DiagBuilder = [&]() {
- OptimizationRemark Diag(DEBUG_TYPE, "PartialUnrolled", L->getStartLoc(),
- L->getHeader());
- return Diag << "unroll and jammed loop by a factor of "
- << NV("UnrollCount", Count);
- };
-
- LLVM_DEBUG(dbgs() << "UNROLL AND JAMMING loop %" << Header->getName()
- << " by " << Count);
- if (TripMultiple != 1) {
- LLVM_DEBUG(dbgs() << " with " << TripMultiple << " trips per branch");
- ORE->emit([&]() {
- return DiagBuilder() << " with " << NV("TripMultiple", TripMultiple)
- << " trips per branch";
- });
- } else {
- LLVM_DEBUG(dbgs() << " with run-time trip count");
- ORE->emit([&]() { return DiagBuilder() << " with run-time trip count"; });
- }
- LLVM_DEBUG(dbgs() << "!\n");
- }
-
- BasicBlock *Preheader = L->getLoopPreheader();
- BasicBlock *LatchBlock = L->getLoopLatch();
- BranchInst *BI = dyn_cast<BranchInst>(LatchBlock->getTerminator());
- assert(Preheader && LatchBlock && Header);
- assert(BI && !BI->isUnconditional());
- bool ContinueOnTrue = L->contains(BI->getSuccessor(0));
- BasicBlock *LoopExit = BI->getSuccessor(ContinueOnTrue);
- bool SubLoopContinueOnTrue = SubLoop->contains(
- SubLoop->getLoopLatch()->getTerminator()->getSuccessor(0));
-
- // Partition blocks in an outer/inner loop pair into blocks before and after
- // the loop
- std::vector<BasicBlock *> SubLoopBlocks;
- std::vector<BasicBlock *> ForeBlocks;
- std::vector<BasicBlock *> AftBlocks;
- partitionOuterLoopBlocks(L, SubLoop, ForeBlocks, SubLoopBlocks, AftBlocks,
- DT);
-
- // We keep track of the entering/first and exiting/last block of each
- // of Fore/SubLoop/Aft in each iteration. This helps make the stapling up of
- // blocks easier.
- std::vector<BasicBlock *> ForeBlocksFirst;
- std::vector<BasicBlock *> ForeBlocksLast;
- std::vector<BasicBlock *> SubLoopBlocksFirst;
- std::vector<BasicBlock *> SubLoopBlocksLast;
- std::vector<BasicBlock *> AftBlocksFirst;
- std::vector<BasicBlock *> AftBlocksLast;
- ForeBlocksFirst.push_back(Header);
- ForeBlocksLast.push_back(SubLoop->getLoopPreheader());
- SubLoopBlocksFirst.push_back(SubLoop->getHeader());
- SubLoopBlocksLast.push_back(SubLoop->getExitingBlock());
- AftBlocksFirst.push_back(SubLoop->getExitBlock());
- AftBlocksLast.push_back(L->getExitingBlock());
- // Maps Blocks[0] -> Blocks[It]
- ValueToValueMapTy LastValueMap;
-
- // Move any instructions from fore phi operands from AftBlocks into Fore.
- moveHeaderPhiOperandsToForeBlocks(
- Header, LatchBlock, SubLoop->getLoopPreheader()->getTerminator(),
- AftBlocks);
-
- // The current on-the-fly SSA update requires blocks to be processed in
- // reverse postorder so that LastValueMap contains the correct value at each
- // exit.
- LoopBlocksDFS DFS(L);
- DFS.perform(LI);
- // Stash the DFS iterators before adding blocks to the loop.
- LoopBlocksDFS::RPOIterator BlockBegin = DFS.beginRPO();
- LoopBlocksDFS::RPOIterator BlockEnd = DFS.endRPO();
-
- if (Header->getParent()->isDebugInfoForProfiling())
- for (BasicBlock *BB : L->getBlocks())
- for (Instruction &I : *BB)
- if (!isa<DbgInfoIntrinsic>(&I))
- if (const DILocation *DIL = I.getDebugLoc())
- I.setDebugLoc(DIL->cloneWithDuplicationFactor(Count));
-
- // Copy all blocks
- for (unsigned It = 1; It != Count; ++It) {
- std::vector<BasicBlock *> NewBlocks;
- // Maps Blocks[It] -> Blocks[It-1]
- DenseMap<Value *, Value *> PrevItValueMap;
-
- for (LoopBlocksDFS::RPOIterator BB = BlockBegin; BB != BlockEnd; ++BB) {
- ValueToValueMapTy VMap;
- BasicBlock *New = CloneBasicBlock(*BB, VMap, "." + Twine(It));
- Header->getParent()->getBasicBlockList().push_back(New);
-
- if (containsBB(ForeBlocks, *BB)) {
- L->addBasicBlockToLoop(New, *LI);
-
- if (*BB == ForeBlocksFirst[0])
- ForeBlocksFirst.push_back(New);
- if (*BB == ForeBlocksLast[0])
- ForeBlocksLast.push_back(New);
- } else if (containsBB(SubLoopBlocks, *BB)) {
- SubLoop->addBasicBlockToLoop(New, *LI);
-
- if (*BB == SubLoopBlocksFirst[0])
- SubLoopBlocksFirst.push_back(New);
- if (*BB == SubLoopBlocksLast[0])
- SubLoopBlocksLast.push_back(New);
- } else if (containsBB(AftBlocks, *BB)) {
- L->addBasicBlockToLoop(New, *LI);
-
- if (*BB == AftBlocksFirst[0])
- AftBlocksFirst.push_back(New);
- if (*BB == AftBlocksLast[0])
- AftBlocksLast.push_back(New);
- } else {
- llvm_unreachable("BB being cloned should be in Fore/Sub/Aft");
- }
-
- // Update our running maps of newest clones
- PrevItValueMap[New] = (It == 1 ? *BB : LastValueMap[*BB]);
- LastValueMap[*BB] = New;
- for (ValueToValueMapTy::iterator VI = VMap.begin(), VE = VMap.end();
- VI != VE; ++VI) {
- PrevItValueMap[VI->second] =
- const_cast<Value *>(It == 1 ? VI->first : LastValueMap[VI->first]);
- LastValueMap[VI->first] = VI->second;
- }
-
- NewBlocks.push_back(New);
-
- // Update DomTree:
- if (*BB == ForeBlocksFirst[0])
- DT->addNewBlock(New, ForeBlocksLast[It - 1]);
- else if (*BB == SubLoopBlocksFirst[0])
- DT->addNewBlock(New, SubLoopBlocksLast[It - 1]);
- else if (*BB == AftBlocksFirst[0])
- DT->addNewBlock(New, AftBlocksLast[It - 1]);
- else {
- // Each set of blocks (Fore/Sub/Aft) will have the same
- // internal domtree structure.
- auto BBDomNode = DT->getNode(*BB);
- auto BBIDom = BBDomNode->getIDom();
- BasicBlock *OriginalBBIDom = BBIDom->getBlock();
- assert(OriginalBBIDom);
- assert(LastValueMap[cast<Value>(OriginalBBIDom)]);
- DT->addNewBlock(
- New, cast<BasicBlock>(LastValueMap[cast<Value>(OriginalBBIDom)]));
- }
- }
-
- // Remap all instructions in the most recent iteration
- for (BasicBlock *NewBlock : NewBlocks) {
- for (Instruction &I : *NewBlock) {
- ::remapInstruction(&I, LastValueMap);
- if (auto *II = dyn_cast<IntrinsicInst>(&I))
- if (II->getIntrinsicID() == Intrinsic::assume)
- AC->registerAssumption(II);
- }
- }
-
- // Alter the ForeBlocks phi's, pointing them at the latest version of the
- // value from the previous iteration's phis
- for (PHINode &Phi : ForeBlocksFirst[It]->phis()) {
- Value *OldValue = Phi.getIncomingValueForBlock(AftBlocksLast[It]);
- assert(OldValue && "should have incoming edge from Aft[It]");
- Value *NewValue = OldValue;
- if (Value *PrevValue = PrevItValueMap[OldValue])
- NewValue = PrevValue;
-
- assert(Phi.getNumOperands() == 2);
- Phi.setIncomingBlock(0, ForeBlocksLast[It - 1]);
- Phi.setIncomingValue(0, NewValue);
- Phi.removeIncomingValue(1);
- }
- }
-
- // Now that all the basic blocks for the unrolled iterations are in place,
- // finish up connecting the blocks and phi nodes. At this point LastValueMap
- // is the last unrolled iterations values.
-
- // Update Phis in BB from OldBB to point to NewBB
- auto updatePHIBlocks = [](BasicBlock *BB, BasicBlock *OldBB,
- BasicBlock *NewBB) {
- for (PHINode &Phi : BB->phis()) {
- int I = Phi.getBasicBlockIndex(OldBB);
- Phi.setIncomingBlock(I, NewBB);
- }
- };
- // Update Phis in BB from OldBB to point to NewBB and use the latest value
- // from LastValueMap
- auto updatePHIBlocksAndValues = [](BasicBlock *BB, BasicBlock *OldBB,
- BasicBlock *NewBB,
- ValueToValueMapTy &LastValueMap) {
- for (PHINode &Phi : BB->phis()) {
- for (unsigned b = 0; b < Phi.getNumIncomingValues(); ++b) {
- if (Phi.getIncomingBlock(b) == OldBB) {
- Value *OldValue = Phi.getIncomingValue(b);
- if (Value *LastValue = LastValueMap[OldValue])
- Phi.setIncomingValue(b, LastValue);
- Phi.setIncomingBlock(b, NewBB);
- break;
- }
- }
- }
- };
- // Move all the phis from Src into Dest
- auto movePHIs = [](BasicBlock *Src, BasicBlock *Dest) {
- Instruction *insertPoint = Dest->getFirstNonPHI();
- while (PHINode *Phi = dyn_cast<PHINode>(Src->begin()))
- Phi->moveBefore(insertPoint);
- };
-
- // Update the PHI values outside the loop to point to the last block
- updatePHIBlocksAndValues(LoopExit, AftBlocksLast[0], AftBlocksLast.back(),
- LastValueMap);
-
- // Update ForeBlocks successors and phi nodes
- BranchInst *ForeTerm =
- cast<BranchInst>(ForeBlocksLast.back()->getTerminator());
- BasicBlock *Dest = SubLoopBlocksFirst[0];
- ForeTerm->setSuccessor(0, Dest);
-
- if (CompletelyUnroll) {
- while (PHINode *Phi = dyn_cast<PHINode>(ForeBlocksFirst[0]->begin())) {
- Phi->replaceAllUsesWith(Phi->getIncomingValueForBlock(Preheader));
- Phi->getParent()->getInstList().erase(Phi);
- }
- } else {
- // Update the PHI values to point to the last aft block
- updatePHIBlocksAndValues(ForeBlocksFirst[0], AftBlocksLast[0],
- AftBlocksLast.back(), LastValueMap);
- }
-
- for (unsigned It = 1; It != Count; It++) {
- // Remap ForeBlock successors from previous iteration to this
- BranchInst *ForeTerm =
- cast<BranchInst>(ForeBlocksLast[It - 1]->getTerminator());
- BasicBlock *Dest = ForeBlocksFirst[It];
- ForeTerm->setSuccessor(0, Dest);
- }
-
- // Subloop successors and phis
- BranchInst *SubTerm =
- cast<BranchInst>(SubLoopBlocksLast.back()->getTerminator());
- SubTerm->setSuccessor(!SubLoopContinueOnTrue, SubLoopBlocksFirst[0]);
- SubTerm->setSuccessor(SubLoopContinueOnTrue, AftBlocksFirst[0]);
- updatePHIBlocks(SubLoopBlocksFirst[0], ForeBlocksLast[0],
- ForeBlocksLast.back());
- updatePHIBlocks(SubLoopBlocksFirst[0], SubLoopBlocksLast[0],
- SubLoopBlocksLast.back());
-
- for (unsigned It = 1; It != Count; It++) {
- // Replace the conditional branch of the previous iteration subloop
- // with an unconditional one to this one
- BranchInst *SubTerm =
- cast<BranchInst>(SubLoopBlocksLast[It - 1]->getTerminator());
- BranchInst::Create(SubLoopBlocksFirst[It], SubTerm);
- SubTerm->eraseFromParent();
-
- updatePHIBlocks(SubLoopBlocksFirst[It], ForeBlocksLast[It],
- ForeBlocksLast.back());
- updatePHIBlocks(SubLoopBlocksFirst[It], SubLoopBlocksLast[It],
- SubLoopBlocksLast.back());
- movePHIs(SubLoopBlocksFirst[It], SubLoopBlocksFirst[0]);
- }
-
- // Aft blocks successors and phis
- BranchInst *Term = cast<BranchInst>(AftBlocksLast.back()->getTerminator());
- if (CompletelyUnroll) {
- BranchInst::Create(LoopExit, Term);
- Term->eraseFromParent();
- } else {
- Term->setSuccessor(!ContinueOnTrue, ForeBlocksFirst[0]);
- }
- updatePHIBlocks(AftBlocksFirst[0], SubLoopBlocksLast[0],
- SubLoopBlocksLast.back());
-
- for (unsigned It = 1; It != Count; It++) {
- // Replace the conditional branch of the previous iteration subloop
- // with an unconditional one to this one
- BranchInst *AftTerm =
- cast<BranchInst>(AftBlocksLast[It - 1]->getTerminator());
- BranchInst::Create(AftBlocksFirst[It], AftTerm);
- AftTerm->eraseFromParent();
-
- updatePHIBlocks(AftBlocksFirst[It], SubLoopBlocksLast[It],
- SubLoopBlocksLast.back());
- movePHIs(AftBlocksFirst[It], AftBlocksFirst[0]);
- }
-
- // Dominator Tree. Remove the old links between Fore, Sub and Aft, adding the
- // new ones required.
- if (Count != 1) {
- SmallVector<DominatorTree::UpdateType, 4> DTUpdates;
- DTUpdates.emplace_back(DominatorTree::UpdateKind::Delete, ForeBlocksLast[0],
- SubLoopBlocksFirst[0]);
- DTUpdates.emplace_back(DominatorTree::UpdateKind::Delete,
- SubLoopBlocksLast[0], AftBlocksFirst[0]);
-
- DTUpdates.emplace_back(DominatorTree::UpdateKind::Insert,
- ForeBlocksLast.back(), SubLoopBlocksFirst[0]);
- DTUpdates.emplace_back(DominatorTree::UpdateKind::Insert,
- SubLoopBlocksLast.back(), AftBlocksFirst[0]);
- DT->applyUpdates(DTUpdates);
- }
-
- // Merge adjacent basic blocks, if possible.
- SmallPtrSet<BasicBlock *, 16> MergeBlocks;
- MergeBlocks.insert(ForeBlocksLast.begin(), ForeBlocksLast.end());
- MergeBlocks.insert(SubLoopBlocksLast.begin(), SubLoopBlocksLast.end());
- MergeBlocks.insert(AftBlocksLast.begin(), AftBlocksLast.end());
- while (!MergeBlocks.empty()) {
- BasicBlock *BB = *MergeBlocks.begin();
- BranchInst *Term = dyn_cast<BranchInst>(BB->getTerminator());
- if (Term && Term->isUnconditional() && L->contains(Term->getSuccessor(0))) {
- BasicBlock *Dest = Term->getSuccessor(0);
- if (BasicBlock *Fold = foldBlockIntoPredecessor(Dest, LI, SE, DT)) {
- // Don't remove BB and add Fold as they are the same BB
- assert(Fold == BB);
- (void)Fold;
- MergeBlocks.erase(Dest);
- } else
- MergeBlocks.erase(BB);
- } else
- MergeBlocks.erase(BB);
- }
-
- // At this point, the code is well formed. We now do a quick sweep over the
- // inserted code, doing constant propagation and dead code elimination as we
- // go.
- simplifyLoopAfterUnroll(SubLoop, true, LI, SE, DT, AC);
- simplifyLoopAfterUnroll(L, !CompletelyUnroll && Count > 1, LI, SE, DT, AC);
-
- NumCompletelyUnrolledAndJammed += CompletelyUnroll;
- ++NumUnrolledAndJammed;
-
-#ifndef NDEBUG
- Loop *OuterL = L->getParentLoop();
-#endif
-
- // Update LoopInfo if the loop is completely removed.
- if (CompletelyUnroll)
- LI->erase(L);
-
-#ifndef NDEBUG
- // We shouldn't have done anything to break loop simplify form or LCSSA.
- Loop *OutestLoop = OuterL ? OuterL : (!CompletelyUnroll ? L : SubLoop);
- assert(OutestLoop->isRecursivelyLCSSAForm(*DT, *LI));
- if (!CompletelyUnroll)
- assert(L->isLoopSimplifyForm());
- assert(SubLoop->isLoopSimplifyForm());
- assert(DT->verify());
-#endif
-
- return CompletelyUnroll ? LoopUnrollResult::FullyUnrolled
- : LoopUnrollResult::PartiallyUnrolled;
-}
-
-static bool getLoadsAndStores(std::vector<BasicBlock *> &Blocks,
- SmallVector<Value *, 4> &MemInstr) {
- // Scan the BBs and collect legal loads and stores.
- // Returns false if non-simple loads/stores are found.
- for (BasicBlock *BB : Blocks) {
- for (Instruction &I : *BB) {
- if (auto *Ld = dyn_cast<LoadInst>(&I)) {
- if (!Ld->isSimple())
- return false;
- MemInstr.push_back(&I);
- } else if (auto *St = dyn_cast<StoreInst>(&I)) {
- if (!St->isSimple())
- return false;
- MemInstr.push_back(&I);
- } else if (I.mayReadOrWriteMemory()) {
- return false;
- }
- }
- }
- return true;
-}
-
-static bool checkDependencies(SmallVector<Value *, 4> &Earlier,
- SmallVector<Value *, 4> &Later,
- unsigned LoopDepth, bool InnerLoop,
- DependenceInfo &DI) {
- // Use DA to check for dependencies between loads and
- // stores that make unroll and jam invalid
- for (Value *I : Earlier) {
- for (Value *J : Later) {
- Instruction *Src = cast<Instruction>(I);
- Instruction *Dst = cast<Instruction>(J);
- if (Src == Dst)
- continue;
- // Ignore Input dependencies.
- if (isa<LoadInst>(Src) && isa<LoadInst>(Dst))
- continue;
-
- // Track dependencies, and if we find them take a conservative approach
- // by allowing only = or > (not <), altough some < would be safe
- // (depending upon unroll width).
- // FIXME: Allow < so long as distance is less than unroll width
- if (auto D = DI.depends(Src, Dst, true)) {
- assert(D->isOrdered() && "Expected an output, flow or anti dep.");
-
- if (D->isConfused())
- return false;
- if (!InnerLoop) {
- if (D->getDirection(LoopDepth) & Dependence::DVEntry::GT)
- return false;
- } else {
- assert(LoopDepth + 1 <= D->getLevels());
- if (D->getDirection(LoopDepth) & Dependence::DVEntry::GT &&
- D->getDirection(LoopDepth + 1) & Dependence::DVEntry::LT)
- return false;
- }
- }
- }
- }
- return true;
-}
-
-static bool checkDependencies(Loop *L, std::vector<BasicBlock *> &ForeBlocks,
- std::vector<BasicBlock *> &SubLoopBlocks,
- std::vector<BasicBlock *> &AftBlocks,
- DependenceInfo &DI) {
- // Get all loads/store pairs for each blocks
- SmallVector<Value *, 4> ForeMemInstr;
- SmallVector<Value *, 4> SubLoopMemInstr;
- SmallVector<Value *, 4> AftMemInstr;
- if (!getLoadsAndStores(ForeBlocks, ForeMemInstr) ||
- !getLoadsAndStores(SubLoopBlocks, SubLoopMemInstr) ||
- !getLoadsAndStores(AftBlocks, AftMemInstr))
- return false;
-
- // Check for dependencies between any blocks that may change order
- unsigned LoopDepth = L->getLoopDepth();
- return checkDependencies(ForeMemInstr, SubLoopMemInstr, LoopDepth, false,
- DI) &&
- checkDependencies(ForeMemInstr, AftMemInstr, LoopDepth, false, DI) &&
- checkDependencies(SubLoopMemInstr, AftMemInstr, LoopDepth, false,
- DI) &&
- checkDependencies(SubLoopMemInstr, SubLoopMemInstr, LoopDepth, true,
- DI);
-}
-
-bool llvm::isSafeToUnrollAndJam(Loop *L, ScalarEvolution &SE, DominatorTree &DT,
- DependenceInfo &DI) {
- /* We currently handle outer loops like this:
- |
- ForeFirst <----\ }
- Blocks | } ForeBlocks
- ForeLast | }
- | |
- SubLoopFirst <\ | }
- Blocks | | } SubLoopBlocks
- SubLoopLast -/ | }
- | |
- AftFirst | }
- Blocks | } AftBlocks
- AftLast ------/ }
- |
-
- There are (theoretically) any number of blocks in ForeBlocks, SubLoopBlocks
- and AftBlocks, providing that there is one edge from Fores to SubLoops,
- one edge from SubLoops to Afts and a single outer loop exit (from Afts).
- In practice we currently limit Aft blocks to a single block, and limit
- things further in the profitablility checks of the unroll and jam pass.
-
- Because of the way we rearrange basic blocks, we also require that
- the Fore blocks on all unrolled iterations are safe to move before the
- SubLoop blocks of all iterations. So we require that the phi node looping
- operands of ForeHeader can be moved to at least the end of ForeEnd, so that
- we can arrange cloned Fore Blocks before the subloop and match up Phi's
- correctly.
-
- i.e. The old order of blocks used to be F1 S1 S1 S1 A1 F2 S2 S2 S2 A2.
- It needs to be safe to tranform this to F1 F2 S1 S2 S1 S2 S1 S2 A1 A2.
-
- There are then a number of checks along the lines of no calls, no
- exceptions, inner loop IV is consistent, etc.
- */
-
- if (!L->isLoopSimplifyForm() || L->getSubLoops().size() != 1)
- return false;
- Loop *SubLoop = L->getSubLoops()[0];
- if (!SubLoop->isLoopSimplifyForm())
- return false;
-
- BasicBlock *PreHeader = L->getLoopPreheader();
- BasicBlock *Header = L->getHeader();
- BasicBlock *Latch = L->getLoopLatch();
- BasicBlock *Exit = L->getExitingBlock();
- BasicBlock *SubLoopHeader = SubLoop->getHeader();
- BasicBlock *SubLoopLatch = SubLoop->getLoopLatch();
- BasicBlock *SubLoopExit = SubLoop->getExitingBlock();
-
- if (Latch != Exit)
- return false;
- if (SubLoopLatch != SubLoopExit)
- return false;
-
- if (Header->hasAddressTaken() || SubLoopHeader->hasAddressTaken())
- return false;
-
- // Split blocks into Fore/SubLoop/Aft based on dominators
- std::vector<BasicBlock *> SubLoopBlocks;
- std::vector<BasicBlock *> ForeBlocks;
- std::vector<BasicBlock *> AftBlocks;
- if (!partitionOuterLoopBlocks(L, SubLoop, ForeBlocks, SubLoopBlocks,
- AftBlocks, &DT))
- return false;
-
- // Aft blocks may need to move instructions to fore blocks, which
- // becomes more difficult if there are multiple (potentially conditionally
- // executed) blocks. For now we just exclude loops with multiple aft blocks.
- if (AftBlocks.size() != 1)
- return false;
-
- // Check outer loop IV is easily calcable
- const SCEV *BECountSC = SE.getExitCount(L, Latch);
- if (isa<SCEVCouldNotCompute>(BECountSC) ||
- !BECountSC->getType()->isIntegerTy())
- return false;
- // Add 1 since the backedge count doesn't include the first loop iteration.
- const SCEV *TripCountSC =
- SE.getAddExpr(BECountSC, SE.getConstant(BECountSC->getType(), 1));
- if (isa<SCEVCouldNotCompute>(TripCountSC))
- return false;
- BranchInst *PreHeaderBR = cast<BranchInst>(PreHeader->getTerminator());
- const DataLayout &DL = Header->getModule()->getDataLayout();
- SCEVExpander Expander(SE, DL, "loop-unroll");
- if (Expander.isHighCostExpansion(TripCountSC, L, PreHeaderBR))
- return false;
-
- // Check inner loop IV is consistent between all iterations
- const SCEV *SubLoopBECountSC = SE.getExitCount(SubLoop, SubLoopLatch);
- if (isa<SCEVCouldNotCompute>(SubLoopBECountSC) ||
- !SubLoopBECountSC->getType()->isIntegerTy())
- return false;
- ScalarEvolution::LoopDisposition LD =
- SE.getLoopDisposition(SubLoopBECountSC, L);
- if (LD != ScalarEvolution::LoopInvariant)
- return false;
-
- // Check the loop safety info for exceptions.
- LoopSafetyInfo LSI;
- computeLoopSafetyInfo(&LSI, L);
- if (LSI.MayThrow)
- return false;
-
- // We've ruled out the easy stuff, and need to check that there
- // are no interdependencies which may prevent us from moving
- // the:
- // ForeBlocks before Subloop and AftBlocks.
- // Subloop before AftBlocks.
- // ForeBlock phi operands before the subloop
-
- // Make sure we can move all instructions we need to before the subloop
- SmallVector<Instruction *, 8> Worklist;
- SmallPtrSet<Instruction *, 8> Visited;
- for (auto &Phi : Header->phis()) {
- Value *V = Phi.getIncomingValueForBlock(Latch);
- if (Instruction *I = dyn_cast<Instruction>(V))
- Worklist.push_back(I);
- }
- while (!Worklist.empty()) {
- Instruction *I = Worklist.back();
- Worklist.pop_back();
- if (Visited.insert(I).second) {
- if (SubLoop->contains(I->getParent()))
- return false;
- if (containsBB(AftBlocks, I->getParent())) {
- // If we hit a phi node in afts we know we are done (probably LCSSA)
- if (isa<PHINode>(I))
- return false;
- if (I->mayHaveSideEffects() || I->mayReadOrWriteMemory())
- return false;
- for (auto &U : I->operands())
- if (Instruction *II = dyn_cast<Instruction>(U))
- Worklist.push_back(II);
- }
- }
- }
-
- // Check for memory dependencies which prohibit the unrolling
- // we are doing. Because of the way we are unrolling Fore/Sub/Aft
- // blocks, we need to check there are no dependencies between
- // Fore-Sub, Fore-Aft, Sub-Aft and Sub-Sub.
- if (!checkDependencies(L, ForeBlocks, SubLoopBlocks, AftBlocks, DI))
- return false;
-
- return true;
-}
+++ /dev/null
-; RUN: opt -basicaa -loop-unroll-and-jam -unroll-and-jam-count=4 < %s -S | FileCheck %s
-
-target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
-target triple = "thumbv8m.main-arm-none-eabi"
-
-; CHECK-LABEL: fore_aft_less
-; CHECK: %j = phi
-; CHECK: %j.1 = phi
-; CHECK: %j.2 = phi
-; CHECK: %j.3 = phi
-define void @fore_aft_less(i32* noalias nocapture %A, i32 %N, i32* noalias nocapture readonly %B) {
-entry:
- %cmp = icmp sgt i32 %N, 0
- br i1 %cmp, label %for.outer, label %cleanup
-
-for.outer:
- %i = phi i32 [ %add7.us, %for.latch ], [ 0, %entry ]
- %arrayidx.us = getelementptr inbounds i32, i32* %A, i32 %i
- store i32 1, i32* %arrayidx.us, align 4
- br label %for.inner
-
-for.inner:
- %j = phi i32 [ %add6.us, %for.inner ], [ 0, %for.outer ]
- %sum = phi i32 [ %add.us, %for.inner ], [ 0, %for.outer ]
- %arrayidx5.us = getelementptr inbounds i32, i32* %B, i32 %j
- %0 = load i32, i32* %arrayidx5.us, align 4
- %mul.us = mul nsw i32 %0, %i
- %add.us = add nsw i32 %mul.us, %sum
- %add6.us = add nuw nsw i32 %j, 1
- %exitcond.us = icmp eq i32 %add6.us, %N
- br i1 %exitcond.us, label %for.latch, label %for.inner
-
-for.latch:
- %add7.us = add nuw nsw i32 %i, 1
- %add7.us2 = add nuw nsw i32 %i, -1
- %arrayidx8.us = getelementptr inbounds i32, i32* %A, i32 %add7.us2
- store i32 %add.us, i32* %arrayidx8.us, align 4
- %exitcond29.us = icmp eq i32 %add7.us, %N
- br i1 %exitcond29.us, label %cleanup, label %for.outer
-
-cleanup:
- ret void
-}
-
-; CHECK-LABEL: fore_aft_eq
-; CHECK: %j = phi
-; CHECK: %j.1 = phi
-; CHECK: %j.2 = phi
-; CHECK: %j.3 = phi
-define void @fore_aft_eq(i32* noalias nocapture %A, i32 %N, i32* noalias nocapture readonly %B) {
-entry:
- %cmp = icmp sgt i32 %N, 0
- br i1 %cmp, label %for.outer, label %cleanup
-
-for.outer:
- %i = phi i32 [ %add7.us, %for.latch ], [ 0, %entry ]
- %arrayidx.us = getelementptr inbounds i32, i32* %A, i32 %i
- store i32 1, i32* %arrayidx.us, align 4
- br label %for.inner
-
-for.inner:
- %j = phi i32 [ %add6.us, %for.inner ], [ 0, %for.outer ]
- %sum = phi i32 [ %add.us, %for.inner ], [ 0, %for.outer ]
- %arrayidx5.us = getelementptr inbounds i32, i32* %B, i32 %j
- %0 = load i32, i32* %arrayidx5.us, align 4
- %mul.us = mul nsw i32 %0, %i
- %add.us = add nsw i32 %mul.us, %sum
- %add6.us = add nuw nsw i32 %j, 1
- %exitcond.us = icmp eq i32 %add6.us, %N
- br i1 %exitcond.us, label %for.latch, label %for.inner
-
-for.latch:
- %add7.us = add nuw nsw i32 %i, 1
- %add7.us2 = add nuw nsw i32 %i, 0
- %arrayidx8.us = getelementptr inbounds i32, i32* %A, i32 %i
- store i32 %add.us, i32* %arrayidx8.us, align 4
- %exitcond29.us = icmp eq i32 %add7.us, %N
- br i1 %exitcond29.us, label %cleanup, label %for.outer
-
-cleanup:
- ret void
-}
-
-
-; CHECK-LABEL: fore_aft_more
-; CHECK: %j = phi
-; CHECK-NOT: %j.1 = phi
-define void @fore_aft_more(i32* noalias nocapture %A, i32 %N, i32* noalias nocapture readonly %B) {
-entry:
- %cmp = icmp sgt i32 %N, 0
- br i1 %cmp, label %for.outer, label %cleanup
-
-for.outer:
- %i = phi i32 [ %add7.us, %for.latch ], [ 0, %entry ]
- %arrayidx.us = getelementptr inbounds i32, i32* %A, i32 %i
- store i32 1, i32* %arrayidx.us, align 4
- br label %for.inner
-
-for.inner:
- %j = phi i32 [ %add6.us, %for.inner ], [ 0, %for.outer ]
- %sum = phi i32 [ %add.us, %for.inner ], [ 0, %for.outer ]
- %arrayidx5.us = getelementptr inbounds i32, i32* %B, i32 %j
- %0 = load i32, i32* %arrayidx5.us, align 4
- %mul.us = mul nsw i32 %0, %i
- %add.us = add nsw i32 %mul.us, %sum
- %add6.us = add nuw nsw i32 %j, 1
- %exitcond.us = icmp eq i32 %add6.us, %N
- br i1 %exitcond.us, label %for.latch, label %for.inner
-
-for.latch:
- %add7.us = add nuw nsw i32 %i, 1
- %add7.us2 = add nuw nsw i32 %i, 1
- %arrayidx8.us = getelementptr inbounds i32, i32* %A, i32 %add7.us2
- store i32 %add.us, i32* %arrayidx8.us, align 4
- %exitcond29.us = icmp eq i32 %add7.us, %N
- br i1 %exitcond29.us, label %cleanup, label %for.outer
-
-cleanup:
- ret void
-}
-
-
-; CHECK-LABEL: fore_sub_less
-; CHECK: %j = phi
-; CHECK: %j.1 = phi
-; CHECK: %j.2 = phi
-; CHECK: %j.3 = phi
-define void @fore_sub_less(i32* noalias nocapture %A, i32 %N, i32* noalias nocapture readonly %B) {
-entry:
- %cmp = icmp sgt i32 %N, 0
- br i1 %cmp, label %for.outer, label %cleanup
-
-for.outer:
- %i = phi i32 [ %add7.us, %for.latch ], [ 0, %entry ]
- %arrayidx.us = getelementptr inbounds i32, i32* %A, i32 %i
- store i32 1, i32* %arrayidx.us, align 4
- br label %for.inner
-
-for.inner:
- %j = phi i32 [ %add6.us, %for.inner ], [ 0, %for.outer ]
- %sum = phi i32 [ %add.us, %for.inner ], [ 0, %for.outer ]
- %arrayidx5.us = getelementptr inbounds i32, i32* %B, i32 %j
- %0 = load i32, i32* %arrayidx5.us, align 4
- %mul.us = mul nsw i32 %0, %i
- %add.us = add nsw i32 %mul.us, %sum
- %add7.us2 = add nuw nsw i32 %i, -1
- %arrayidx8.us = getelementptr inbounds i32, i32* %A, i32 %add7.us2
- store i32 %add.us, i32* %arrayidx8.us, align 4
- %add6.us = add nuw nsw i32 %j, 1
- %exitcond.us = icmp eq i32 %add6.us, %N
- br i1 %exitcond.us, label %for.latch, label %for.inner
-
-for.latch:
- %add7.us = add nuw nsw i32 %i, 1
- %exitcond29.us = icmp eq i32 %add7.us, %N
- br i1 %exitcond29.us, label %cleanup, label %for.outer
-
-cleanup:
- ret void
-}
-
-; CHECK-LABEL: fore_eq_less
-; CHECK: %j = phi
-; CHECK: %j.1 = phi
-; CHECK: %j.2 = phi
-; CHECK: %j.3 = phi
-define void @fore_eq_less(i32* noalias nocapture %A, i32 %N, i32* noalias nocapture readonly %B) {
-entry:
- %cmp = icmp sgt i32 %N, 0
- br i1 %cmp, label %for.outer, label %cleanup
-
-for.outer:
- %i = phi i32 [ %add7.us, %for.latch ], [ 0, %entry ]
- %arrayidx.us = getelementptr inbounds i32, i32* %A, i32 %i
- store i32 1, i32* %arrayidx.us, align 4
- br label %for.inner
-
-for.inner:
- %j = phi i32 [ %add6.us, %for.inner ], [ 0, %for.outer ]
- %sum = phi i32 [ %add.us, %for.inner ], [ 0, %for.outer ]
- %arrayidx5.us = getelementptr inbounds i32, i32* %B, i32 %j
- %0 = load i32, i32* %arrayidx5.us, align 4
- %mul.us = mul nsw i32 %0, %i
- %add.us = add nsw i32 %mul.us, %sum
- %add7.us2 = add nuw nsw i32 %i, 0
- %arrayidx8.us = getelementptr inbounds i32, i32* %A, i32 %add7.us2
- store i32 %add.us, i32* %arrayidx8.us, align 4
- %add6.us = add nuw nsw i32 %j, 1
- %exitcond.us = icmp eq i32 %add6.us, %N
- br i1 %exitcond.us, label %for.latch, label %for.inner
-
-for.latch:
- %add7.us = add nuw nsw i32 %i, 1
- %exitcond29.us = icmp eq i32 %add7.us, %N
- br i1 %exitcond29.us, label %cleanup, label %for.outer
-
-cleanup:
- ret void
-}
-
-; CHECK-LABEL: fore_sub_more
-; CHECK: %j = phi
-; CHECK-NOT: %j.1 = phi
-define void @fore_sub_more(i32* noalias nocapture %A, i32 %N, i32* noalias nocapture readonly %B) {
-entry:
- %cmp = icmp sgt i32 %N, 0
- br i1 %cmp, label %for.outer, label %cleanup
-
-for.outer:
- %i = phi i32 [ %add7.us, %for.latch ], [ 0, %entry ]
- %arrayidx.us = getelementptr inbounds i32, i32* %A, i32 %i
- store i32 1, i32* %arrayidx.us, align 4
- br label %for.inner
-
-for.inner:
- %j = phi i32 [ %add6.us, %for.inner ], [ 0, %for.outer ]
- %sum = phi i32 [ %add.us, %for.inner ], [ 0, %for.outer ]
- %arrayidx5.us = getelementptr inbounds i32, i32* %B, i32 %j
- %0 = load i32, i32* %arrayidx5.us, align 4
- %mul.us = mul nsw i32 %0, %i
- %add.us = add nsw i32 %mul.us, %sum
- %add7.us2 = add nuw nsw i32 %i, 1
- %arrayidx8.us = getelementptr inbounds i32, i32* %A, i32 %add7.us2
- store i32 %add.us, i32* %arrayidx8.us, align 4
- %add6.us = add nuw nsw i32 %j, 1
- %exitcond.us = icmp eq i32 %add6.us, %N
- br i1 %exitcond.us, label %for.latch, label %for.inner
-
-for.latch:
- %add7.us = add nuw nsw i32 %i, 1
- %exitcond29.us = icmp eq i32 %add7.us, %N
- br i1 %exitcond29.us, label %cleanup, label %for.outer
-
-cleanup:
- ret void
-}
-
-; CHECK-LABEL: sub_aft_less
-; CHECK: %j = phi
-; CHECK: %j.1 = phi
-; CHECK: %j.2 = phi
-; CHECK: %j.3 = phi
-define void @sub_aft_less(i32* noalias nocapture %A, i32 %N, i32* noalias nocapture readonly %B) {
-entry:
- %cmp = icmp sgt i32 %N, 0
- br i1 %cmp, label %for.outer, label %cleanup
-
-for.outer:
- %i = phi i32 [ %add7.us, %for.latch ], [ 0, %entry ]
- br label %for.inner
-
-for.inner:
- %j = phi i32 [ %add6.us, %for.inner ], [ 0, %for.outer ]
- %sum = phi i32 [ %add.us, %for.inner ], [ 0, %for.outer ]
- %arrayidx5.us = getelementptr inbounds i32, i32* %B, i32 %j
- %0 = load i32, i32* %arrayidx5.us, align 4
- %mul.us = mul nsw i32 %0, %i
- %add.us = add nsw i32 %mul.us, %sum
- %add6.us = add nuw nsw i32 %j, 1
- %arrayidx.us = getelementptr inbounds i32, i32* %A, i32 %i
- store i32 1, i32* %arrayidx.us, align 4
- %exitcond.us = icmp eq i32 %add6.us, %N
- br i1 %exitcond.us, label %for.latch, label %for.inner
-
-for.latch:
- %add7.us = add nuw nsw i32 %i, 1
- %add7.us2 = add nuw nsw i32 %i, -1
- %arrayidx8.us = getelementptr inbounds i32, i32* %A, i32 %add7.us2
- store i32 %add.us, i32* %arrayidx8.us, align 4
- %exitcond29.us = icmp eq i32 %add7.us, %N
- br i1 %exitcond29.us, label %cleanup, label %for.outer
-
-cleanup:
- ret void
-}
-
-; CHECK-LABEL: sub_aft_eq
-; CHECK: %j = phi
-; CHECK: %j.1 = phi
-; CHECK: %j.2 = phi
-; CHECK: %j.3 = phi
-define void @sub_aft_eq(i32* noalias nocapture %A, i32 %N, i32* noalias nocapture readonly %B) {
-entry:
- %cmp = icmp sgt i32 %N, 0
- br i1 %cmp, label %for.outer, label %cleanup
-
-for.outer:
- %i = phi i32 [ %add7.us, %for.latch ], [ 0, %entry ]
- br label %for.inner
-
-for.inner:
- %j = phi i32 [ %add6.us, %for.inner ], [ 0, %for.outer ]
- %sum = phi i32 [ %add.us, %for.inner ], [ 0, %for.outer ]
- %arrayidx5.us = getelementptr inbounds i32, i32* %B, i32 %j
- %0 = load i32, i32* %arrayidx5.us, align 4
- %mul.us = mul nsw i32 %0, %i
- %add.us = add nsw i32 %mul.us, %sum
- %add6.us = add nuw nsw i32 %j, 1
- %arrayidx.us = getelementptr inbounds i32, i32* %A, i32 %i
- store i32 1, i32* %arrayidx.us, align 4
- %exitcond.us = icmp eq i32 %add6.us, %N
- br i1 %exitcond.us, label %for.latch, label %for.inner
-
-for.latch:
- %add7.us = add nuw nsw i32 %i, 1
- %add7.us2 = add nuw nsw i32 %i, 0
- %arrayidx8.us = getelementptr inbounds i32, i32* %A, i32 %i
- store i32 %add.us, i32* %arrayidx8.us, align 4
- %exitcond29.us = icmp eq i32 %add7.us, %N
- br i1 %exitcond29.us, label %cleanup, label %for.outer
-
-cleanup:
- ret void
-}
-
-
-; CHECK-LABEL: sub_aft_more
-; CHECK: %j = phi
-; CHECK-NOT: %j.1 = phi
-define void @sub_aft_more(i32* noalias nocapture %A, i32 %N, i32* noalias nocapture readonly %B) {
-entry:
- %cmp = icmp sgt i32 %N, 0
- br i1 %cmp, label %for.outer, label %cleanup
-
-for.outer:
- %i = phi i32 [ %add7.us, %for.latch ], [ 0, %entry ]
- br label %for.inner
-
-for.inner:
- %j = phi i32 [ %add6.us, %for.inner ], [ 0, %for.outer ]
- %sum = phi i32 [ %add.us, %for.inner ], [ 0, %for.outer ]
- %arrayidx5.us = getelementptr inbounds i32, i32* %B, i32 %j
- %0 = load i32, i32* %arrayidx5.us, align 4
- %mul.us = mul nsw i32 %0, %i
- %add.us = add nsw i32 %mul.us, %sum
- %add6.us = add nuw nsw i32 %j, 1
- %arrayidx.us = getelementptr inbounds i32, i32* %A, i32 %i
- store i32 1, i32* %arrayidx.us, align 4
- %exitcond.us = icmp eq i32 %add6.us, %N
- br i1 %exitcond.us, label %for.latch, label %for.inner
-
-for.latch:
- %add7.us = add nuw nsw i32 %i, 1
- %add7.us2 = add nuw nsw i32 %i, 1
- %arrayidx8.us = getelementptr inbounds i32, i32* %A, i32 %add7.us2
- store i32 %add.us, i32* %arrayidx8.us, align 4
- %exitcond29.us = icmp eq i32 %add7.us, %N
- br i1 %exitcond29.us, label %cleanup, label %for.outer
-
-cleanup:
- ret void
-}
-
-
-; CHECK-LABEL: sub_sub_less
-; CHECK: %j = phi
-; CHECK-NOT: %j.1 = phi
-define void @sub_sub_less(i32* noalias nocapture %A, i32 %N, i32* noalias nocapture readonly %B) {
-entry:
- %cmp = icmp sgt i32 %N, 0
- br i1 %cmp, label %for.outer, label %cleanup
-
-for.outer:
- %i = phi i32 [ %add7.us, %for.latch ], [ 0, %entry ]
- br label %for.inner
-
-for.inner:
- %j = phi i32 [ %add6.us, %for.inner ], [ 0, %for.outer ]
- %sum = phi i32 [ %add.us, %for.inner ], [ 0, %for.outer ]
- %arrayidx5.us = getelementptr inbounds i32, i32* %B, i32 %j
- %0 = load i32, i32* %arrayidx5.us, align 4
- %mul.us = mul nsw i32 %0, %i
- %add.us = add nsw i32 %mul.us, %sum
- %add6.us = add nuw nsw i32 %j, 1
- %arrayidx.us = getelementptr inbounds i32, i32* %A, i32 %i
- store i32 1, i32* %arrayidx.us, align 4
- %add7.us2 = add nuw nsw i32 %i, -1
- %arrayidx8.us = getelementptr inbounds i32, i32* %A, i32 %add7.us2
- store i32 %add.us, i32* %arrayidx8.us, align 4
- %exitcond.us = icmp eq i32 %add6.us, %N
- br i1 %exitcond.us, label %for.latch, label %for.inner
-
-for.latch:
- %add7.us = add nuw nsw i32 %i, 1
- %exitcond29.us = icmp eq i32 %add7.us, %N
- br i1 %exitcond29.us, label %cleanup, label %for.outer
-
-cleanup:
- ret void
-}
-
-
-; CHECK-LABEL: sub_sub_eq
-; CHECK: %j = phi
-; CHECK: %j.1 = phi
-define void @sub_sub_eq(i32* noalias nocapture %A, i32 %N, i32* noalias nocapture readonly %B) {
-entry:
- %cmp = icmp sgt i32 %N, 0
- br i1 %cmp, label %for.outer, label %cleanup
-
-for.outer:
- %i = phi i32 [ %add7.us, %for.latch ], [ 0, %entry ]
- br label %for.inner
-
-for.inner:
- %j = phi i32 [ %add6.us, %for.inner ], [ 0, %for.outer ]
- %sum = phi i32 [ %add.us, %for.inner ], [ 0, %for.outer ]
- %arrayidx5.us = getelementptr inbounds i32, i32* %B, i32 %j
- %0 = load i32, i32* %arrayidx5.us, align 4
- %mul.us = mul nsw i32 %0, %i
- %add.us = add nsw i32 %mul.us, %sum
- %add6.us = add nuw nsw i32 %j, 1
- %arrayidx.us = getelementptr inbounds i32, i32* %A, i32 %i
- store i32 1, i32* %arrayidx.us, align 4
- %add7.us2 = add nuw nsw i32 %i, 0
- %arrayidx8.us = getelementptr inbounds i32, i32* %A, i32 %add7.us2
- store i32 %add.us, i32* %arrayidx8.us, align 4
- %exitcond.us = icmp eq i32 %add6.us, %N
- br i1 %exitcond.us, label %for.latch, label %for.inner
-
-for.latch:
- %add7.us = add nuw nsw i32 %i, 1
- %exitcond29.us = icmp eq i32 %add7.us, %N
- br i1 %exitcond29.us, label %cleanup, label %for.outer
-
-cleanup:
- ret void
-}
-
-
-; CHECK-LABEL: sub_sub_more
-; CHECK: %j = phi
-; CHECK-NOT: %j.1 = phi
-define void @sub_sub_more(i32* noalias nocapture %A, i32 %N, i32* noalias nocapture readonly %B) {
-entry:
- %cmp = icmp sgt i32 %N, 0
- br i1 %cmp, label %for.outer, label %cleanup
-
-for.outer:
- %i = phi i32 [ %add7.us, %for.latch ], [ 0, %entry ]
- br label %for.inner
-
-for.inner:
- %j = phi i32 [ %add6.us, %for.inner ], [ 0, %for.outer ]
- %sum = phi i32 [ %add.us, %for.inner ], [ 0, %for.outer ]
- %arrayidx5.us = getelementptr inbounds i32, i32* %B, i32 %j
- %0 = load i32, i32* %arrayidx5.us, align 4
- %mul.us = mul nsw i32 %0, %i
- %add.us = add nsw i32 %mul.us, %sum
- %add6.us = add nuw nsw i32 %j, 1
- %arrayidx.us = getelementptr inbounds i32, i32* %A, i32 %i
- store i32 1, i32* %arrayidx.us, align 4
- %add7.us2 = add nuw nsw i32 %i, 1
- %arrayidx8.us = getelementptr inbounds i32, i32* %A, i32 %add7.us2
- store i32 %add.us, i32* %arrayidx8.us, align 4
- %exitcond.us = icmp eq i32 %add6.us, %N
- br i1 %exitcond.us, label %for.latch, label %for.inner
-
-for.latch:
- %add7.us = add nuw nsw i32 %i, 1
- %exitcond29.us = icmp eq i32 %add7.us, %N
- br i1 %exitcond29.us, label %cleanup, label %for.outer
-
-cleanup:
- ret void
-}
+++ /dev/null
-; RUN: opt -loop-unroll-and-jam -unroll-and-jam-count=4 -pass-remarks=loop-unroll-and-jam < %s -S 2>&1 | FileCheck %s
-
-target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
-target triple = "thumbv8m.main-arm-none-eabi"
-
-;; Common check for all tests. None should be unroll and jammed
-; CHECK-NOT: remark: {{.*}} unroll and jammed
-
-
-; CHECK-LABEL: disabled1
-; Tests for(i) { sum = A[i]; for(j) sum += B[j]; A[i+1] = sum; }
-; A[i] to A[i+1] dependency should block unrollandjam
-define void @disabled1(i32 %I, i32 %J, i32* noalias nocapture %A, i32* noalias nocapture readonly %B) #0 {
-; CHECK: %i.029 = phi i32 [ %add10, %for.latch ], [ 0, %for.preheader ]
-; CHECK: %j.026 = phi i32 [ 0, %for.outer ], [ %inc, %for.inner ]
-entry:
- %cmp = icmp ne i32 %J, 0
- %cmp127 = icmp ne i32 %I, 0
- %or.cond = and i1 %cmp127, %cmp
- br i1 %or.cond, label %for.preheader, label %return
-
-for.preheader:
- br label %for.outer
-
-for.outer:
- %i.029 = phi i32 [ %add10, %for.latch ], [ 0, %for.preheader ]
- %b.028 = phi i32 [ %inc8, %for.latch ], [ 1, %for.preheader ]
- %arrayidx = getelementptr inbounds i32, i32* %A, i32 %i.029
- %0 = load i32, i32* %arrayidx, align 4, !tbaa !5
- br label %for.inner
-
-for.inner:
- %j.026 = phi i32 [ 0, %for.outer ], [ %inc, %for.inner ]
- %sum1.025 = phi i32 [ %0, %for.outer ], [ %add, %for.inner ]
- %arrayidx6 = getelementptr inbounds i32, i32* %B, i32 %j.026
- %1 = load i32, i32* %arrayidx6, align 4, !tbaa !5
- %add = add i32 %1, %sum1.025
- %inc = add nuw i32 %j.026, 1
- %exitcond = icmp eq i32 %inc, %J
- br i1 %exitcond, label %for.latch, label %for.inner
-
-for.latch:
- %arrayidx7 = getelementptr inbounds i32, i32* %A, i32 %b.028
- store i32 %add, i32* %arrayidx7, align 4, !tbaa !5
- %inc8 = add nuw nsw i32 %b.028, 1
- %add10 = add nuw nsw i32 %i.029, 1
- %exitcond30 = icmp eq i32 %add10, %I
- br i1 %exitcond30, label %return, label %for.outer
-
-return:
- ret void
-}
-
-
-; CHECK-LABEL: disabled2
-; Tests an incompatible block layout (for.outer jumps past for.inner)
-; FIXME: Make this work
-define void @disabled2(i32 %I, i32 %J, i32* noalias nocapture %A, i32* noalias nocapture readonly %B) #0 {
-; CHECK: %i.032 = phi i32 [ %add13, %for.latch ], [ 0, %for.preheader ]
-; CHECK: %j.030 = phi i32 [ %inc, %for.inner ], [ 0, %for.inner.preheader ]
-entry:
- %cmp = icmp ne i32 %J, 0
- %cmp131 = icmp ne i32 %I, 0
- %or.cond = and i1 %cmp131, %cmp
- br i1 %or.cond, label %for.preheader, label %for.end14
-
-for.preheader:
- br label %for.outer
-
-for.outer:
- %i.032 = phi i32 [ %add13, %for.latch ], [ 0, %for.preheader ]
- %arrayidx = getelementptr inbounds i32, i32* %B, i32 %i.032
- %0 = load i32, i32* %arrayidx, align 4, !tbaa !5
- %tobool = icmp eq i32 %0, 0
- br i1 %tobool, label %for.latch, label %for.inner
-
-for.inner:
- %j.030 = phi i32 [ %inc, %for.inner ], [ 0, %for.outer ]
- %sum1.029 = phi i32 [ %sum1.1, %for.inner ], [ 0, %for.outer ]
- %arrayidx6 = getelementptr inbounds i32, i32* %B, i32 %j.030
- %1 = load i32, i32* %arrayidx6, align 4, !tbaa !5
- %tobool7 = icmp eq i32 %1, 0
- %sub = add i32 %sum1.029, 10
- %add = sub i32 %sub, %1
- %sum1.1 = select i1 %tobool7, i32 %sum1.029, i32 %add
- %inc = add nuw i32 %j.030, 1
- %exitcond = icmp eq i32 %inc, %J
- br i1 %exitcond, label %for.latch, label %for.inner
-
-for.latch:
- %sum1.1.lcssa = phi i32 [ 0, %for.outer ], [ %sum1.1, %for.inner ]
- %arrayidx11 = getelementptr inbounds i32, i32* %A, i32 %i.032
- store i32 %sum1.1.lcssa, i32* %arrayidx11, align 4, !tbaa !5
- %add13 = add nuw i32 %i.032, 1
- %exitcond33 = icmp eq i32 %add13, %I
- br i1 %exitcond33, label %for.end14, label %for.outer
-
-for.end14:
- ret void
-}
-
-
-
-; CHECK-LABEL: disabled3
-; Tests loop carry dependencies in an array S
-define void @disabled3(i32 %I, i32 %J, i32* noalias nocapture %A, i32* noalias nocapture readonly %B) #0 {
-; CHECK: %i.029 = phi i32 [ 0, %for.preheader ], [ %add12, %for.latch ]
-; CHECK: %j.027 = phi i32 [ 0, %for.outer ], [ %inc, %for.inner ]
-entry:
- %S = alloca [4 x i32], align 4
- %cmp = icmp eq i32 %J, 0
- br i1 %cmp, label %return, label %if.end
-
-if.end:
- %0 = bitcast [4 x i32]* %S to i8*
- %cmp128 = icmp eq i32 %I, 0
- br i1 %cmp128, label %for.cond.cleanup, label %for.preheader
-
-for.preheader:
- %arrayidx9 = getelementptr inbounds [4 x i32], [4 x i32]* %S, i32 0, i32 0
- br label %for.outer
-
-for.cond.cleanup:
- br label %return
-
-for.outer:
- %i.029 = phi i32 [ 0, %for.preheader ], [ %add12, %for.latch ]
- br label %for.inner
-
-for.inner:
- %j.027 = phi i32 [ 0, %for.outer ], [ %inc, %for.inner ]
- %arrayidx = getelementptr inbounds i32, i32* %B, i32 %j.027
- %l2 = load i32, i32* %arrayidx, align 4, !tbaa !5
- %add = add i32 %j.027, %i.029
- %rem = urem i32 %add, %J
- %arrayidx6 = getelementptr inbounds i32, i32* %B, i32 %rem
- %l3 = load i32, i32* %arrayidx6, align 4, !tbaa !5
- %mul = mul i32 %l3, %l2
- %rem7 = urem i32 %j.027, 3
- %arrayidx8 = getelementptr inbounds [4 x i32], [4 x i32]* %S, i32 0, i32 %rem7
- store i32 %mul, i32* %arrayidx8, align 4, !tbaa !5
- %inc = add nuw i32 %j.027, 1
- %exitcond = icmp eq i32 %inc, %J
- br i1 %exitcond, label %for.latch, label %for.inner
-
-for.latch:
- %l1 = load i32, i32* %arrayidx9, align 4, !tbaa !5
- %arrayidx10 = getelementptr inbounds i32, i32* %A, i32 %i.029
- store i32 %l1, i32* %arrayidx10, align 4, !tbaa !5
- %add12 = add nuw i32 %i.029, 1
- %exitcond31 = icmp eq i32 %add12, %I
- br i1 %exitcond31, label %for.cond.cleanup, label %for.outer
-
-return:
- ret void
-}
-
-
-; CHECK-LABEL: disabled4
-; Inner looop induction variable in not consistent
-; ie for(i = 0..n) for (j = 0..i) sum+=B[j]
-define void @disabled4(i32 %I, i32 %J, i32* noalias nocapture %A, i32* noalias nocapture readonly %B) #0 {
-; CHECK: %indvars.iv = phi i32 [ %indvars.iv.next, %for.latch ], [ 1, %for.preheader ]
-; CHECK: %j.021 = phi i32 [ 0, %for.outer ], [ %inc, %for.inner ]
-entry:
- %cmp = icmp ne i32 %J, 0
- %cmp122 = icmp ugt i32 %I, 1
- %or.cond = and i1 %cmp122, %cmp
- br i1 %or.cond, label %for.preheader, label %for.end9
-
-for.preheader:
- br label %for.outer
-
-for.outer:
- %indvars.iv = phi i32 [ %indvars.iv.next, %for.latch ], [ 1, %for.preheader ]
- br label %for.inner
-
-for.inner:
- %j.021 = phi i32 [ 0, %for.outer ], [ %inc, %for.inner ]
- %sum1.020 = phi i32 [ 0, %for.outer ], [ %add, %for.inner ]
- %arrayidx = getelementptr inbounds i32, i32* %B, i32 %j.021
- %0 = load i32, i32* %arrayidx, align 4, !tbaa !5
- %add = add i32 %0, %sum1.020
- %inc = add nuw i32 %j.021, 1
- %exitcond = icmp eq i32 %inc, %indvars.iv
- br i1 %exitcond, label %for.latch, label %for.inner
-
-for.latch:
- %arrayidx6 = getelementptr inbounds i32, i32* %A, i32 %indvars.iv
- store i32 %add, i32* %arrayidx6, align 4, !tbaa !5
- %indvars.iv.next = add nuw i32 %indvars.iv, 1
- %exitcond24 = icmp eq i32 %indvars.iv.next, %I
- br i1 %exitcond24, label %for.end9, label %for.outer
-
-for.end9:
- ret void
-}
-
-
-; CHECK-LABEL: disabled5
-; Test odd uses of phi nodes where the outer IV cannot be moved into Fore as it hits a PHI
-@f = hidden global i32 0, align 4
-define i32 @disabled5() #0 {
-; CHECK: %0 = phi i32 [ %f.promoted10, %entry ], [ 2, %for.latch ]
-; CHECK: %1 = phi i32 [ %0, %for.outer ], [ 2, %for.inner ]
-entry:
- %f.promoted10 = load i32, i32* @f, align 4, !tbaa !5
- br label %for.outer
-
-for.outer:
- %0 = phi i32 [ %f.promoted10, %entry ], [ 2, %for.latch ]
- %d.018 = phi i16 [ 0, %entry ], [ %odd.lcssa, %for.latch ]
- %inc5.sink9 = phi i32 [ 2, %entry ], [ %inc5, %for.latch ]
- br label %for.inner
-
-for.inner:
- %1 = phi i32 [ %0, %for.outer ], [ 2, %for.inner ]
- %inc.sink8 = phi i32 [ 0, %for.outer ], [ %inc, %for.inner ]
- %inc = add nuw nsw i32 %inc.sink8, 1
- %exitcond = icmp ne i32 %inc, 7
- br i1 %exitcond, label %for.inner, label %for.latch
-
-for.latch:
- %.lcssa = phi i32 [ %1, %for.inner ]
- %odd.lcssa = phi i16 [ 1, %for.inner ]
- %inc5 = add nuw nsw i32 %inc5.sink9, 1
- %exitcond11 = icmp ne i32 %inc5, 7
- br i1 %exitcond11, label %for.outer, label %for.end
-
-for.end:
- %.lcssa.lcssa = phi i32 [ %.lcssa, %for.latch ]
- %inc.lcssa.lcssa = phi i32 [ 7, %for.latch ]
- ret i32 0
-}
-
-
-; CHECK-LABEL: disabled6
-; There is a dependency in here, between @d and %0 (=@f)
-@d6 = hidden global i16 5, align 2
-@f6 = hidden global i16* @d6, align 4
-define i32 @disabled6() #0 {
-; CHECK: %inc8.sink14.i = phi i16 [ 1, %entry ], [ %inc8.i, %for.cond.cleanup.i ]
-; CHECK: %c.013.i = phi i32 [ 0, %for.body.i ], [ %inc.i, %for.body6.i ]
-entry:
- store i16 1, i16* @d6, align 2
- %0 = load i16*, i16** @f6, align 4
- br label %for.body.i
-
-for.body.i:
- %inc8.sink14.i = phi i16 [ 1, %entry ], [ %inc8.i, %for.cond.cleanup.i ]
- %1 = load i16, i16* %0, align 2
- br label %for.body6.i
-
-for.cond.cleanup.i:
- %inc8.i = add nuw nsw i16 %inc8.sink14.i, 1
- store i16 %inc8.i, i16* @d6, align 2
- %cmp.i = icmp ult i16 %inc8.i, 6
- br i1 %cmp.i, label %for.body.i, label %test.exit
-
-for.body6.i:
- %c.013.i = phi i32 [ 0, %for.body.i ], [ %inc.i, %for.body6.i ]
- %inc.i = add nuw nsw i32 %c.013.i, 1
- %exitcond.i = icmp eq i32 %inc.i, 7
- br i1 %exitcond.i, label %for.cond.cleanup.i, label %for.body6.i
-
-test.exit:
- %conv2.i = sext i16 %1 to i32
- ret i32 0
-}
-
-
-
-; CHECK-LABEL: disabled7
-; Has negative output dependency
-define void @disabled7(i32 %I, i32 %J, i32* noalias nocapture %A, i32* noalias nocapture readonly %B) #0 {
-; CHECK: %i.028 = phi i32 [ %add11, %for.cond3.for.cond.cleanup5_crit_edge ], [ 0, %for.body.preheader ]
-; CHECK: %j.026 = phi i32 [ 0, %for.body ], [ %add9, %for.body6 ]
-entry:
- %cmp = icmp ne i32 %J, 0
- %cmp127 = icmp ne i32 %I, 0
- %or.cond = and i1 %cmp127, %cmp
- br i1 %or.cond, label %for.body.preheader, label %for.end12
-
-for.body.preheader:
- br label %for.body
-
-for.body:
- %i.028 = phi i32 [ %add11, %for.cond3.for.cond.cleanup5_crit_edge ], [ 0, %for.body.preheader ]
- %arrayidx = getelementptr inbounds i32, i32* %A, i32 %i.028
- store i32 0, i32* %arrayidx, align 4, !tbaa !5
- %sub = add i32 %i.028, -1
- %arrayidx2 = getelementptr inbounds i32, i32* %A, i32 %sub
- store i32 2, i32* %arrayidx2, align 4, !tbaa !5
- br label %for.body6
-
-for.cond3.for.cond.cleanup5_crit_edge:
- store i32 %add, i32* %arrayidx, align 4, !tbaa !5
- %add11 = add nuw i32 %i.028, 1
- %exitcond29 = icmp eq i32 %add11, %I
- br i1 %exitcond29, label %for.end12, label %for.body
-
-for.body6:
- %0 = phi i32 [ 0, %for.body ], [ %add, %for.body6 ]
- %j.026 = phi i32 [ 0, %for.body ], [ %add9, %for.body6 ]
- %arrayidx7 = getelementptr inbounds i32, i32* %B, i32 %j.026
- %1 = load i32, i32* %arrayidx7, align 4, !tbaa !5
- %add = add i32 %1, %0
- %add9 = add nuw i32 %j.026, 1
- %exitcond = icmp eq i32 %add9, %J
- br i1 %exitcond, label %for.cond3.for.cond.cleanup5_crit_edge, label %for.body6
-
-for.end12:
- ret void
-}
-
-
-; CHECK-LABEL: disabled8
-; Same as above with an extra outer loop nest
-define void @disabled8(i32 %I, i32 %J, i32* noalias nocapture %A, i32* noalias nocapture readonly %B) #0 {
-; CHECK: %i.036 = phi i32 [ %add15, %for.latch ], [ 0, %for.body ]
-; CHECK: %j.034 = phi i32 [ 0, %for.outer ], [ %add13, %for.inner ]
-entry:
- %cmp = icmp eq i32 %J, 0
- %cmp335 = icmp eq i32 %I, 0
- %or.cond = or i1 %cmp, %cmp335
- br i1 %or.cond, label %for.end18, label %for.body.preheader
-
-for.body.preheader:
- br label %for.body
-
-for.body:
- %x.037 = phi i32 [ %inc, %for.cond.cleanup4 ], [ 0, %for.body.preheader ]
- br label %for.outer
-
-for.cond.cleanup4:
- %inc = add nuw nsw i32 %x.037, 1
- %exitcond40 = icmp eq i32 %inc, 5
- br i1 %exitcond40, label %for.end18, label %for.body
-
-for.outer:
- %i.036 = phi i32 [ %add15, %for.latch ], [ 0, %for.body ]
- %arrayidx = getelementptr inbounds i32, i32* %A, i32 %i.036
- store i32 0, i32* %arrayidx, align 4, !tbaa !5
- %sub = add i32 %i.036, -1
- %arrayidx6 = getelementptr inbounds i32, i32* %A, i32 %sub
- store i32 2, i32* %arrayidx6, align 4, !tbaa !5
- br label %for.inner
-
-for.latch:
- store i32 %add, i32* %arrayidx, align 4, !tbaa !5
- %add15 = add nuw i32 %i.036, 1
- %exitcond38 = icmp eq i32 %add15, %I
- br i1 %exitcond38, label %for.cond.cleanup4, label %for.outer
-
-for.inner:
- %0 = phi i32 [ 0, %for.outer ], [ %add, %for.inner ]
- %j.034 = phi i32 [ 0, %for.outer ], [ %add13, %for.inner ]
- %arrayidx11 = getelementptr inbounds i32, i32* %B, i32 %j.034
- %1 = load i32, i32* %arrayidx11, align 4, !tbaa !5
- %add = add i32 %1, %0
- %add13 = add nuw i32 %j.034, 1
- %exitcond = icmp eq i32 %add13, %J
- br i1 %exitcond, label %for.latch, label %for.inner
-
-for.end18:
- ret void
-}
-
-
-; CHECK-LABEL: disabled9
-; Can't prove alias between A and B
-define void @disabled9(i32 %I, i32 %J, i32* nocapture %A, i32* nocapture readonly %B) #0 {
-; CHECK: %i.us = phi i32 [ %add8.us, %for.latch ], [ 0, %for.outer.preheader ]
-; CHECK: %j.us = phi i32 [ 0, %for.outer ], [ %inc.us, %for.inner ]
-entry:
- %cmp = icmp ne i32 %J, 0
- %cmp122 = icmp ne i32 %I, 0
- %or.cond = and i1 %cmp, %cmp122
- br i1 %or.cond, label %for.outer.preheader, label %for.end
-
-for.outer.preheader:
- br label %for.outer
-
-for.outer:
- %i.us = phi i32 [ %add8.us, %for.latch ], [ 0, %for.outer.preheader ]
- br label %for.inner
-
-for.inner:
- %j.us = phi i32 [ 0, %for.outer ], [ %inc.us, %for.inner ]
- %sum1.us = phi i32 [ 0, %for.outer ], [ %add.us, %for.inner ]
- %arrayidx.us = getelementptr inbounds i32, i32* %B, i32 %j.us
- %0 = load i32, i32* %arrayidx.us, align 4, !tbaa !5
- %add.us = add i32 %0, %sum1.us
- %inc.us = add nuw i32 %j.us, 1
- %exitcond = icmp eq i32 %inc.us, %J
- br i1 %exitcond, label %for.latch, label %for.inner
-
-for.latch:
- %add.us.lcssa = phi i32 [ %add.us, %for.inner ]
- %arrayidx6.us = getelementptr inbounds i32, i32* %A, i32 %i.us
- store i32 %add.us.lcssa, i32* %arrayidx6.us, align 4, !tbaa !5
- %add8.us = add nuw i32 %i.us, 1
- %exitcond25 = icmp eq i32 %add8.us, %I
- br i1 %exitcond25, label %for.end.loopexit, label %for.outer
-
-for.end.loopexit:
- br label %for.end
-
-for.end:
- ret void
-}
-
-
-; CHECK-LABEL: disable10
-; Simple call
-declare void @f10(i32, i32) #0
-define void @disable10(i32 %I, i32 %J, i32* noalias nocapture %A, i32* noalias nocapture readonly %B) #0 {
-; CHECK: %i.us = phi i32 [ %add8.us, %for.latch ], [ 0, %for.outer.preheader ]
-; CHECK: %j.us = phi i32 [ 0, %for.outer ], [ %inc.us, %for.inner ]
-entry:
- %cmp = icmp ne i32 %J, 0
- %cmp122 = icmp ne i32 %I, 0
- %or.cond = and i1 %cmp, %cmp122
- br i1 %or.cond, label %for.outer.preheader, label %for.end
-
-for.outer.preheader:
- br label %for.outer
-
-for.outer:
- %i.us = phi i32 [ %add8.us, %for.latch ], [ 0, %for.outer.preheader ]
- br label %for.inner
-
-for.inner:
- %j.us = phi i32 [ 0, %for.outer ], [ %inc.us, %for.inner ]
- %sum1.us = phi i32 [ 0, %for.outer ], [ %add.us, %for.inner ]
- %arrayidx.us = getelementptr inbounds i32, i32* %B, i32 %j.us
- %0 = load i32, i32* %arrayidx.us, align 4, !tbaa !5
- %add.us = add i32 %0, %sum1.us
- %inc.us = add nuw i32 %j.us, 1
- %exitcond = icmp eq i32 %inc.us, %J
- tail call void @f10(i32 %i.us, i32 %j.us) nounwind
- br i1 %exitcond, label %for.latch, label %for.inner
-
-for.latch:
- %add.us.lcssa = phi i32 [ %add.us, %for.inner ]
- %arrayidx6.us = getelementptr inbounds i32, i32* %A, i32 %i.us
- store i32 %add.us.lcssa, i32* %arrayidx6.us, align 4, !tbaa !5
- %add8.us = add nuw i32 %i.us, 1
- %exitcond25 = icmp eq i32 %add8.us, %I
- br i1 %exitcond25, label %for.end.loopexit, label %for.outer
-
-for.end.loopexit:
- br label %for.end
-
-for.end:
- ret void
-}
-
-
-; CHECK-LABEL: disable11
-; volatile
-define void @disable11(i32 %I, i32 %J, i32* noalias nocapture %A, i32* noalias nocapture readonly %B) #0 {
-; CHECK: %i.us = phi i32 [ %add8.us, %for.latch ], [ 0, %for.outer.preheader ]
-; CHECK: %j.us = phi i32 [ 0, %for.outer ], [ %inc.us, %for.inner ]
-entry:
- %cmp = icmp ne i32 %J, 0
- %cmp122 = icmp ne i32 %I, 0
- %or.cond = and i1 %cmp, %cmp122
- br i1 %or.cond, label %for.outer.preheader, label %for.end
-
-for.outer.preheader:
- br label %for.outer
-
-for.outer:
- %i.us = phi i32 [ %add8.us, %for.latch ], [ 0, %for.outer.preheader ]
- br label %for.inner
-
-for.inner:
- %j.us = phi i32 [ 0, %for.outer ], [ %inc.us, %for.inner ]
- %sum1.us = phi i32 [ 0, %for.outer ], [ %add.us, %for.inner ]
- %arrayidx.us = getelementptr inbounds i32, i32* %B, i32 %j.us
- %0 = load volatile i32, i32* %arrayidx.us, align 4, !tbaa !5
- %add.us = add i32 %0, %sum1.us
- %inc.us = add nuw i32 %j.us, 1
- %exitcond = icmp eq i32 %inc.us, %J
- br i1 %exitcond, label %for.latch, label %for.inner
-
-for.latch:
- %add.us.lcssa = phi i32 [ %add.us, %for.inner ]
- %arrayidx6.us = getelementptr inbounds i32, i32* %A, i32 %i.us
- store i32 %add.us.lcssa, i32* %arrayidx6.us, align 4, !tbaa !5
- %add8.us = add nuw i32 %i.us, 1
- %exitcond25 = icmp eq i32 %add8.us, %I
- br i1 %exitcond25, label %for.end.loopexit, label %for.outer
-
-for.end.loopexit:
- br label %for.end
-
-for.end:
- ret void
-}
-
-
-; CHECK-LABEL: disable12
-; Multiple aft blocks
-define void @disable12(i32 %I, i32 %J, i32* noalias nocapture %A, i32* noalias nocapture readonly %B) #0 {
-; CHECK: %i.us = phi i32 [ %add8.us, %for.latch3 ], [ 0, %for.outer.preheader ]
-; CHECK: %j.us = phi i32 [ 0, %for.outer ], [ %inc.us, %for.inner ]
-entry:
- %cmp = icmp ne i32 %J, 0
- %cmp122 = icmp ne i32 %I, 0
- %or.cond = and i1 %cmp, %cmp122
- br i1 %or.cond, label %for.outer.preheader, label %for.end
-
-for.outer.preheader:
- br label %for.outer
-
-for.outer:
- %i.us = phi i32 [ %add8.us, %for.latch3 ], [ 0, %for.outer.preheader ]
- br label %for.inner
-
-for.inner:
- %j.us = phi i32 [ 0, %for.outer ], [ %inc.us, %for.inner ]
- %sum1.us = phi i32 [ 0, %for.outer ], [ %add.us, %for.inner ]
- %arrayidx.us = getelementptr inbounds i32, i32* %B, i32 %j.us
- %0 = load i32, i32* %arrayidx.us, align 4, !tbaa !5
- %add.us = add i32 %0, %sum1.us
- %inc.us = add nuw i32 %j.us, 1
- %exitcond = icmp eq i32 %inc.us, %J
- br i1 %exitcond, label %for.latch, label %for.inner
-
-for.latch:
- %add.us.lcssa = phi i32 [ %add.us, %for.inner ]
- %arrayidx6.us = getelementptr inbounds i32, i32* %A, i32 %i.us
- store i32 %add.us.lcssa, i32* %arrayidx6.us, align 4, !tbaa !5
- %cmpl = icmp eq i32 %add.us.lcssa, 10
- br i1 %cmpl, label %for.latch2, label %for.latch3
-
-for.latch2:
- br label %for.latch3
-
-for.latch3:
- %add8.us = add nuw i32 %i.us, 1
- %exitcond25 = icmp eq i32 %add8.us, %I
- br i1 %exitcond25, label %for.end.loopexit, label %for.outer
-
-for.end.loopexit:
- br label %for.end
-
-for.end:
- ret void
-}
-
-
-; CHECK-LABEL: disable13
-; Two subloops
-define void @disable13(i32 %I, i32 %J, i32* noalias nocapture %A, i32* noalias nocapture readonly %B) #0 {
-; CHECK: %i.us = phi i32 [ %add8.us, %for.latch ], [ 0, %for.outer.preheader ]
-; CHECK: %j.us = phi i32 [ 0, %for.outer ], [ %inc.us, %for.inner ]
-; CHECK: %j.us2 = phi i32 [ %inc.us2, %for.inner2 ], [ 0, %for.inner2.preheader ]
-entry:
- %cmp = icmp ne i32 %J, 0
- %cmp122 = icmp ne i32 %I, 0
- %or.cond = and i1 %cmp, %cmp122
- br i1 %or.cond, label %for.outer.preheader, label %for.end
-
-for.outer.preheader:
- br label %for.outer
-
-for.outer:
- %i.us = phi i32 [ %add8.us, %for.latch ], [ 0, %for.outer.preheader ]
- br label %for.inner
-
-for.inner:
- %j.us = phi i32 [ 0, %for.outer ], [ %inc.us, %for.inner ]
- %sum1.us = phi i32 [ 0, %for.outer ], [ %add.us, %for.inner ]
- %arrayidx.us = getelementptr inbounds i32, i32* %B, i32 %j.us
- %0 = load i32, i32* %arrayidx.us, align 4, !tbaa !5
- %add.us = add i32 %0, %sum1.us
- %inc.us = add nuw i32 %j.us, 1
- %exitcond = icmp eq i32 %inc.us, %J
- br i1 %exitcond, label %for.inner2, label %for.inner
-
-for.inner2:
- %j.us2 = phi i32 [ 0, %for.inner ], [ %inc.us2, %for.inner2 ]
- %sum1.us2 = phi i32 [ 0, %for.inner ], [ %add.us2, %for.inner2 ]
- %arrayidx.us2 = getelementptr inbounds i32, i32* %B, i32 %j.us2
- %l0 = load i32, i32* %arrayidx.us2, align 4, !tbaa !5
- %add.us2 = add i32 %l0, %sum1.us2
- %inc.us2 = add nuw i32 %j.us2, 1
- %exitcond2 = icmp eq i32 %inc.us2, %J
- br i1 %exitcond2, label %for.latch, label %for.inner2
-
-for.latch:
- %add.us.lcssa = phi i32 [ %add.us, %for.inner2 ]
- %arrayidx6.us = getelementptr inbounds i32, i32* %A, i32 %i.us
- store i32 %add.us.lcssa, i32* %arrayidx6.us, align 4, !tbaa !5
- %add8.us = add nuw i32 %i.us, 1
- %exitcond25 = icmp eq i32 %add8.us, %I
- br i1 %exitcond25, label %for.end.loopexit, label %for.outer
-
-for.end.loopexit:
- br label %for.end
-
-for.end:
- ret void
-}
-
-
-; CHECK-LABEL: disable14
-; Multiple exits blocks
-define void @disable14(i32 %I, i32 %J, i32* noalias nocapture %A, i32* noalias nocapture readonly %B) #0 {
-; CHECK: %i.us = phi i32 [ %add8.us, %for.latch ], [ 0, %for.outer.preheader ]
-; CHECK: %j.us = phi i32 [ %inc.us, %for.inner ], [ 0, %for.inner.preheader ]
-entry:
- %cmp = icmp ne i32 %J, 0
- %cmp122 = icmp ne i32 %I, 0
- %or.cond = and i1 %cmp, %cmp122
- br i1 %or.cond, label %for.outer.preheader, label %for.end
-
-for.outer.preheader:
- br label %for.outer
-
-for.outer:
- %i.us = phi i32 [ %add8.us, %for.latch ], [ 0, %for.outer.preheader ]
- %add8.us = add nuw i32 %i.us, 1
- %exitcond23 = icmp eq i32 %add8.us, %I
- br i1 %exitcond23, label %for.end.loopexit, label %for.inner
-
-for.inner:
- %j.us = phi i32 [ 0, %for.outer ], [ %inc.us, %for.inner ]
- %sum1.us = phi i32 [ 0, %for.outer ], [ %add.us, %for.inner ]
- %arrayidx.us = getelementptr inbounds i32, i32* %B, i32 %j.us
- %0 = load i32, i32* %arrayidx.us, align 4, !tbaa !5
- %add.us = add i32 %0, %sum1.us
- %inc.us = add nuw i32 %j.us, 1
- %exitcond = icmp eq i32 %inc.us, %J
- br i1 %exitcond, label %for.latch, label %for.inner
-
-for.latch:
- %add.us.lcssa = phi i32 [ %add.us, %for.inner ]
- %arrayidx6.us = getelementptr inbounds i32, i32* %A, i32 %i.us
- store i32 %add.us.lcssa, i32* %arrayidx6.us, align 4, !tbaa !5
- %exitcond25 = icmp eq i32 %add8.us, %I
- br i1 %exitcond25, label %for.end.loopexit, label %for.outer
-
-for.end.loopexit:
- br label %for.end
-
-for.end:
- ret void
-}
-
-
-; CHECK-LABEL: disable15
-; Latch != exit
-define void @disable15(i32 %I, i32 %J, i32* noalias nocapture %A, i32* noalias nocapture readonly %B) #0 {
-; CHECK: %i.us = phi i32 [ %add8.us, %for.latch ], [ 0, %for.outer.preheader ]
-; CHECK: %j.us = phi i32 [ %inc.us, %for.inner ], [ 0, %for.inner.preheader ]
-entry:
- %cmp = icmp ne i32 %J, 0
- %cmp122 = icmp ne i32 %I, 0
- %or.cond = and i1 %cmp, %cmp122
- br i1 %or.cond, label %for.outer.preheader, label %for.end
-
-for.outer.preheader:
- br label %for.outer
-
-for.outer:
- %i.us = phi i32 [ %add8.us, %for.latch ], [ 0, %for.outer.preheader ]
- %add8.us = add nuw i32 %i.us, 1
- %exitcond25 = icmp eq i32 %add8.us, %I
- br i1 %exitcond25, label %for.end.loopexit, label %for.inner
-
-for.inner:
- %j.us = phi i32 [ 0, %for.outer ], [ %inc.us, %for.inner ]
- %sum1.us = phi i32 [ 0, %for.outer ], [ %add.us, %for.inner ]
- %arrayidx.us = getelementptr inbounds i32, i32* %B, i32 %j.us
- %0 = load i32, i32* %arrayidx.us, align 4, !tbaa !5
- %add.us = add i32 %0, %sum1.us
- %inc.us = add nuw i32 %j.us, 1
- %exitcond = icmp eq i32 %inc.us, %J
- br i1 %exitcond, label %for.latch, label %for.inner
-
-for.latch:
- %add.us.lcssa = phi i32 [ %add.us, %for.inner ]
- %arrayidx6.us = getelementptr inbounds i32, i32* %A, i32 %i.us
- store i32 %add.us.lcssa, i32* %arrayidx6.us, align 4, !tbaa !5
- br label %for.outer
-
-for.end.loopexit:
- br label %for.end
-
-for.end:
- ret void
-}
-
-
-; CHECK-LABEL: disable16
-; Latch != exit
-define void @disable16(i32 %I, i32 %J, i32* noalias nocapture %A, i32* noalias nocapture readonly %B) #0 {
-; CHECK: %i.us = phi i32 [ %add8.us, %for.latch ], [ 0, %for.outer.preheader ]
-; CHECK: %j.us = phi i32 [ 0, %for.outer ], [ %inc.us, %for.inner ]
-entry:
- %cmp = icmp ne i32 %J, 0
- %cmp122 = icmp ne i32 %I, 0
- %or.cond = and i1 %cmp, %cmp122
- br i1 %or.cond, label %for.outer.preheader, label %for.end
-
-for.outer.preheader:
- br label %for.outer
-
-for.outer:
- %i.us = phi i32 [ %add8.us, %for.latch ], [ 0, %for.outer.preheader ]
- %otherphi = phi i32 [ %other, %for.latch ], [ 0, %for.outer.preheader ]
- br label %for.inner
-
-for.inner:
- %j.us = phi i32 [ 0, %for.outer ], [ %inc.us, %for.inner ]
- %sum1.us = phi i32 [ 0, %for.outer ], [ %add.us, %for.inner ]
- %arrayidx.us = getelementptr inbounds i32, i32* %B, i32 %j.us
- %0 = load i32, i32* %arrayidx.us, align 4, !tbaa !5
- %add.us = add i32 %0, %sum1.us
- %inc.us = add nuw i32 %j.us, 1
- %exitcond = icmp eq i32 %inc.us, %J
- br i1 %exitcond, label %for.latch, label %for.inner
-
-for.latch:
- %add.us.lcssa = phi i32 [ %add.us, %for.inner ]
- %arrayidx6.us = getelementptr inbounds i32, i32* %A, i32 %i.us
- store i32 %add.us.lcssa, i32* %arrayidx6.us, align 4, !tbaa !5
- %add8.us = add nuw i32 %i.us, 1
- %exitcond25 = icmp eq i32 %add8.us, %I
- %loadarr = getelementptr inbounds i32, i32* %A, i32 %i.us
- %load = load i32, i32* %arrayidx6.us, align 4, !tbaa !5
- %other = add i32 %otherphi, %load
- br i1 %exitcond25, label %for.end.loopexit, label %for.outer
-
-for.end.loopexit:
- br label %for.end
-
-for.end:
- ret void
-}
-
-
-attributes #0 = { "target-cpu"="cortex-m33" }
-
-!5 = !{!6, !6, i64 0}
-!6 = !{!"omnipotent char", !7, i64 0}
-!7 = !{!"Simple C/C++ TBAA"}
+++ /dev/null
-; RUN: opt -basicaa -tbaa -loop-unroll-and-jam < %s -S | FileCheck %s
-; RUN: opt -basicaa -tbaa -loop-unroll-and-jam -unroll-and-jam-threshold=15 < %s -S | FileCheck %s --check-prefix=CHECK-LOWTHRES
-
-target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
-target triple = "thumbv8m.main-arm-none-eabi"
-
-; CHECK-LABEL: test1
-; Basic check that these loops are by default UnJ'd
-define void @test1(i32 %I, i32 %J, i32* noalias nocapture %A, i32* noalias nocapture readonly %B) {
-; CHECK: %i.us = phi i32 [ %add8.us.3, %for.latch ], [ 0, %for.outer.preheader.new ]
-; CHECK-LOWTHRES: %i.us = phi i32 [ %add8.us, %for.latch ], [ 0, %for.outer.preheader ]
-entry:
- %cmp = icmp ne i32 %J, 0
- %cmp122 = icmp ne i32 %I, 0
- %or.cond = and i1 %cmp, %cmp122
- br i1 %or.cond, label %for.outer.preheader, label %for.end
-
-for.outer.preheader:
- br label %for.outer
-
-for.outer:
- %i.us = phi i32 [ %add8.us, %for.latch ], [ 0, %for.outer.preheader ]
- br label %for.inner
-
-for.inner:
- %j.us = phi i32 [ 0, %for.outer ], [ %inc.us, %for.inner ]
- %sum1.us = phi i32 [ 0, %for.outer ], [ %add.us, %for.inner ]
- %arrayidx.us = getelementptr inbounds i32, i32* %B, i32 %j.us
- %0 = load i32, i32* %arrayidx.us, align 4
- %add.us = add i32 %0, %sum1.us
- %inc.us = add nuw i32 %j.us, 1
- %exitcond = icmp eq i32 %inc.us, %J
- br i1 %exitcond, label %for.latch, label %for.inner
-
-for.latch:
- %add.us.lcssa = phi i32 [ %add.us, %for.inner ]
- %arrayidx6.us = getelementptr inbounds i32, i32* %A, i32 %i.us
- store i32 %add.us.lcssa, i32* %arrayidx6.us, align 4
- %add8.us = add nuw i32 %i.us, 1
- %exitcond25 = icmp eq i32 %add8.us, %I
- br i1 %exitcond25, label %for.end.loopexit, label %for.outer
-
-for.end.loopexit:
- br label %for.end
-
-for.end:
- ret void
-}
-
-; CHECK-LABEL: nounroll_and_jam
-; #pragma nounroll_and_jam
-define void @nounroll_and_jam(i32 %I, i32 %J, i32* noalias nocapture %A, i32* noalias nocapture readonly %B) {
-; CHECK: %i.us = phi i32 [ %add8.us, %for.latch ], [ 0, %for.outer.preheader ]
-entry:
- %cmp = icmp ne i32 %J, 0
- %cmp122 = icmp ne i32 %I, 0
- %or.cond = and i1 %cmp, %cmp122
- br i1 %or.cond, label %for.outer.preheader, label %for.end
-
-for.outer.preheader:
- br label %for.outer
-
-for.outer:
- %i.us = phi i32 [ %add8.us, %for.latch ], [ 0, %for.outer.preheader ]
- br label %for.inner
-
-for.inner:
- %j.us = phi i32 [ 0, %for.outer ], [ %inc.us, %for.inner ]
- %sum1.us = phi i32 [ 0, %for.outer ], [ %add.us, %for.inner ]
- %arrayidx.us = getelementptr inbounds i32, i32* %B, i32 %j.us
- %0 = load i32, i32* %arrayidx.us, align 4
- %add.us = add i32 %0, %sum1.us
- %inc.us = add nuw i32 %j.us, 1
- %exitcond = icmp eq i32 %inc.us, %J
- br i1 %exitcond, label %for.latch, label %for.inner
-
-for.latch:
- %add.us.lcssa = phi i32 [ %add.us, %for.inner ]
- %arrayidx6.us = getelementptr inbounds i32, i32* %A, i32 %i.us
- store i32 %add.us.lcssa, i32* %arrayidx6.us, align 4
- %add8.us = add nuw i32 %i.us, 1
- %exitcond25 = icmp eq i32 %add8.us, %I
- br i1 %exitcond25, label %for.end.loopexit, label %for.outer, !llvm.loop !1
-
-for.end.loopexit:
- br label %for.end
-
-for.end:
- ret void
-}
-
-; CHECK-LABEL: unroll_and_jam_count
-; #pragma unroll_and_jam(8)
-define void @unroll_and_jam_count(i32 %I, i32 %J, i32* noalias nocapture %A, i32* noalias nocapture readonly %B) {
-; CHECK: %i.us = phi i32 [ %add8.us.7, %for.latch ], [ 0, %for.outer.preheader.new ]
-entry:
- %cmp = icmp ne i32 %J, 0
- %cmp122 = icmp ne i32 %I, 0
- %or.cond = and i1 %cmp, %cmp122
- br i1 %or.cond, label %for.outer.preheader, label %for.end
-
-for.outer.preheader:
- br label %for.outer
-
-for.outer:
- %i.us = phi i32 [ %add8.us, %for.latch ], [ 0, %for.outer.preheader ]
- br label %for.inner
-
-for.inner:
- %j.us = phi i32 [ 0, %for.outer ], [ %inc.us, %for.inner ]
- %sum1.us = phi i32 [ 0, %for.outer ], [ %add.us, %for.inner ]
- %arrayidx.us = getelementptr inbounds i32, i32* %B, i32 %j.us
- %0 = load i32, i32* %arrayidx.us, align 4
- %add.us = add i32 %0, %sum1.us
- %inc.us = add nuw i32 %j.us, 1
- %exitcond = icmp eq i32 %inc.us, %J
- br i1 %exitcond, label %for.latch, label %for.inner
-
-for.latch:
- %add.us.lcssa = phi i32 [ %add.us, %for.inner ]
- %arrayidx6.us = getelementptr inbounds i32, i32* %A, i32 %i.us
- store i32 %add.us.lcssa, i32* %arrayidx6.us, align 4
- %add8.us = add nuw i32 %i.us, 1
- %exitcond25 = icmp eq i32 %add8.us, %I
- br i1 %exitcond25, label %for.end.loopexit, label %for.outer, !llvm.loop !3
-
-for.end.loopexit:
- br label %for.end
-
-for.end:
- ret void
-}
-
-; CHECK-LABEL: unroll_and_jam
-; #pragma unroll_and_jam
-define void @unroll_and_jam(i32 %I, i32 %J, i32* noalias nocapture %A, i32* noalias nocapture readonly %B) {
-; CHECK: %i.us = phi i32 [ %add8.us.3, %for.latch ], [ 0, %for.outer.preheader.new ]
-; CHECK-LOWTHRES: %i.us = phi i32 [ %add8.us.3, %for.latch ], [ 0, %for.outer.preheader.new ]
-entry:
- %cmp = icmp ne i32 %J, 0
- %cmp122 = icmp ne i32 %I, 0
- %or.cond = and i1 %cmp, %cmp122
- br i1 %or.cond, label %for.outer.preheader, label %for.end
-
-for.outer.preheader:
- br label %for.outer
-
-for.outer:
- %i.us = phi i32 [ %add8.us, %for.latch ], [ 0, %for.outer.preheader ]
- br label %for.inner
-
-for.inner:
- %j.us = phi i32 [ 0, %for.outer ], [ %inc.us, %for.inner ]
- %sum1.us = phi i32 [ 0, %for.outer ], [ %add.us, %for.inner ]
- %arrayidx.us = getelementptr inbounds i32, i32* %B, i32 %j.us
- %0 = load i32, i32* %arrayidx.us, align 4
- %add.us = add i32 %0, %sum1.us
- %inc.us = add nuw i32 %j.us, 1
- %exitcond = icmp eq i32 %inc.us, %J
- br i1 %exitcond, label %for.latch, label %for.inner
-
-for.latch:
- %add.us.lcssa = phi i32 [ %add.us, %for.inner ]
- %arrayidx6.us = getelementptr inbounds i32, i32* %A, i32 %i.us
- store i32 %add.us.lcssa, i32* %arrayidx6.us, align 4
- %add8.us = add nuw i32 %i.us, 1
- %exitcond25 = icmp eq i32 %add8.us, %I
- br i1 %exitcond25, label %for.end.loopexit, label %for.outer, !llvm.loop !5
-
-for.end.loopexit:
- br label %for.end
-
-for.end:
- ret void
-}
-
-; CHECK-LABEL: nounroll
-; #pragma nounroll (which we take to mean disable unroll and jam too)
-define void @nounroll(i32 %I, i32 %J, i32* noalias nocapture %A, i32* noalias nocapture readonly %B) {
-; CHECK: %i.us = phi i32 [ %add8.us, %for.latch ], [ 0, %for.outer.preheader ]
-entry:
- %cmp = icmp ne i32 %J, 0
- %cmp122 = icmp ne i32 %I, 0
- %or.cond = and i1 %cmp, %cmp122
- br i1 %or.cond, label %for.outer.preheader, label %for.end
-
-for.outer.preheader:
- br label %for.outer
-
-for.outer:
- %i.us = phi i32 [ %add8.us, %for.latch ], [ 0, %for.outer.preheader ]
- br label %for.inner
-
-for.inner:
- %j.us = phi i32 [ 0, %for.outer ], [ %inc.us, %for.inner ]
- %sum1.us = phi i32 [ 0, %for.outer ], [ %add.us, %for.inner ]
- %arrayidx.us = getelementptr inbounds i32, i32* %B, i32 %j.us
- %0 = load i32, i32* %arrayidx.us, align 4
- %add.us = add i32 %0, %sum1.us
- %inc.us = add nuw i32 %j.us, 1
- %exitcond = icmp eq i32 %inc.us, %J
- br i1 %exitcond, label %for.latch, label %for.inner
-
-for.latch:
- %add.us.lcssa = phi i32 [ %add.us, %for.inner ]
- %arrayidx6.us = getelementptr inbounds i32, i32* %A, i32 %i.us
- store i32 %add.us.lcssa, i32* %arrayidx6.us, align 4
- %add8.us = add nuw i32 %i.us, 1
- %exitcond25 = icmp eq i32 %add8.us, %I
- br i1 %exitcond25, label %for.end.loopexit, label %for.outer, !llvm.loop !7
-
-for.end.loopexit:
- br label %for.end
-
-for.end:
- ret void
-}
-
-; CHECK-LABEL: unroll
-; #pragma unroll (which we take to mean disable unroll and jam)
-define void @unroll(i32 %I, i32 %J, i32* noalias nocapture %A, i32* noalias nocapture readonly %B) {
-; CHECK: %i.us = phi i32 [ %add8.us, %for.latch ], [ 0, %for.outer.preheader ]
-entry:
- %cmp = icmp ne i32 %J, 0
- %cmp122 = icmp ne i32 %I, 0
- %or.cond = and i1 %cmp, %cmp122
- br i1 %or.cond, label %for.outer.preheader, label %for.end
-
-for.outer.preheader:
- br label %for.outer
-
-for.outer:
- %i.us = phi i32 [ %add8.us, %for.latch ], [ 0, %for.outer.preheader ]
- br label %for.inner
-
-for.inner:
- %j.us = phi i32 [ 0, %for.outer ], [ %inc.us, %for.inner ]
- %sum1.us = phi i32 [ 0, %for.outer ], [ %add.us, %for.inner ]
- %arrayidx.us = getelementptr inbounds i32, i32* %B, i32 %j.us
- %0 = load i32, i32* %arrayidx.us, align 4
- %add.us = add i32 %0, %sum1.us
- %inc.us = add nuw i32 %j.us, 1
- %exitcond = icmp eq i32 %inc.us, %J
- br i1 %exitcond, label %for.latch, label %for.inner
-
-for.latch:
- %add.us.lcssa = phi i32 [ %add.us, %for.inner ]
- %arrayidx6.us = getelementptr inbounds i32, i32* %A, i32 %i.us
- store i32 %add.us.lcssa, i32* %arrayidx6.us, align 4
- %add8.us = add nuw i32 %i.us, 1
- %exitcond25 = icmp eq i32 %add8.us, %I
- br i1 %exitcond25, label %for.end.loopexit, label %for.outer, !llvm.loop !9
-
-for.end.loopexit:
- br label %for.end
-
-for.end:
- ret void
-}
-
-; CHECK-LABEL: nounroll_plus_unroll_and_jam
-; #pragma clang loop nounroll, unroll_and_jam (which we take to mean, do unroll_and_jam)
-define void @nounroll_plus_unroll_and_jam(i32 %I, i32 %J, i32* noalias nocapture %A, i32* noalias nocapture readonly %B) {
-; CHECK: %i.us = phi i32 [ %add8.us.3, %for.latch ], [ 0, %for.outer.preheader.new ]
-entry:
- %cmp = icmp ne i32 %J, 0
- %cmp122 = icmp ne i32 %I, 0
- %or.cond = and i1 %cmp, %cmp122
- br i1 %or.cond, label %for.outer.preheader, label %for.end
-
-for.outer.preheader:
- br label %for.outer
-
-for.outer:
- %i.us = phi i32 [ %add8.us, %for.latch ], [ 0, %for.outer.preheader ]
- br label %for.inner
-
-for.inner:
- %j.us = phi i32 [ 0, %for.outer ], [ %inc.us, %for.inner ]
- %sum1.us = phi i32 [ 0, %for.outer ], [ %add.us, %for.inner ]
- %arrayidx.us = getelementptr inbounds i32, i32* %B, i32 %j.us
- %0 = load i32, i32* %arrayidx.us, align 4
- %add.us = add i32 %0, %sum1.us
- %inc.us = add nuw i32 %j.us, 1
- %exitcond = icmp eq i32 %inc.us, %J
- br i1 %exitcond, label %for.latch, label %for.inner
-
-for.latch:
- %add.us.lcssa = phi i32 [ %add.us, %for.inner ]
- %arrayidx6.us = getelementptr inbounds i32, i32* %A, i32 %i.us
- store i32 %add.us.lcssa, i32* %arrayidx6.us, align 4
- %add8.us = add nuw i32 %i.us, 1
- %exitcond25 = icmp eq i32 %add8.us, %I
- br i1 %exitcond25, label %for.end.loopexit, label %for.outer, !llvm.loop !11
-
-for.end.loopexit:
- br label %for.end
-
-for.end:
- ret void
-}
-
-!1 = distinct !{!1, !2}
-!2 = distinct !{!"llvm.loop.unroll_and_jam.disable"}
-!3 = distinct !{!3, !4}
-!4 = distinct !{!"llvm.loop.unroll_and_jam.count", i32 8}
-!5 = distinct !{!5, !6}
-!6 = distinct !{!"llvm.loop.unroll_and_jam.enable"}
-!7 = distinct !{!7, !8}
-!8 = distinct !{!"llvm.loop.unroll.disable"}
-!9 = distinct !{!9, !10}
-!10 = distinct !{!"llvm.loop.unroll.enable"}
-!11 = distinct !{!11, !8, !6}
\ No newline at end of file
+++ /dev/null
-; RUN: opt -loop-unroll-and-jam -pass-remarks=loop-unroll < %s -S 2>&1 | FileCheck %s
-
-target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
-target triple = "thumbv8m.main-arm-none-eabi"
-
-;; Common check for all tests. None should be unroll and jammed due to profitability
-; CHECK-NOT: remark: {{.*}} unroll and jammed
-
-
-; CHECK-LABEL: unprof1
-; Multiple inner loop blocks
-define void @unprof1(i32 %I, i32 %J, i32* noalias nocapture %A, i32* noalias nocapture readonly %B) #0 {
-; CHECK: %i.us = phi i32 [ %add8.us, %for.latch ], [ 0, %for.outer.preheader ]
-; CHECK: %j.us = phi i32 [ 0, %for.outer ], [ %inc.us, %for.inner2 ]
-entry:
- %cmp = icmp ne i32 %J, 0
- %cmp122 = icmp ne i32 %I, 0
- %or.cond = and i1 %cmp, %cmp122
- br i1 %or.cond, label %for.outer.preheader, label %for.end
-
-for.outer.preheader:
- br label %for.outer
-
-for.outer:
- %i.us = phi i32 [ %add8.us, %for.latch ], [ 0, %for.outer.preheader ]
- br label %for.inner
-
-for.inner:
- %j.us = phi i32 [ 0, %for.outer ], [ %inc.us, %for.inner2 ]
- %sum1.us = phi i32 [ 0, %for.outer ], [ %add.us, %for.inner2 ]
- %arrayidx.us = getelementptr inbounds i32, i32* %B, i32 %j.us
- %0 = load i32, i32* %arrayidx.us, align 4, !tbaa !5
- %add.us = add i32 %0, %sum1.us
-br label %for.inner2
-
-for.inner2:
- %inc.us = add nuw i32 %j.us, 1
- %exitcond = icmp eq i32 %inc.us, %J
- br i1 %exitcond, label %for.latch, label %for.inner
-
-for.latch:
- %add.us.lcssa = phi i32 [ %add.us, %for.inner2 ]
- %arrayidx6.us = getelementptr inbounds i32, i32* %A, i32 %i.us
- store i32 %add.us.lcssa, i32* %arrayidx6.us, align 4, !tbaa !5
- %add8.us = add nuw i32 %i.us, 1
- %exitcond25 = icmp eq i32 %add8.us, %I
- br i1 %exitcond25, label %for.end.loopexit, label %for.outer
-
-for.end.loopexit:
- br label %for.end
-
-for.end:
- ret void
-}
-
-
-; CHECK-LABEL: unprof2
-; Constant inner loop count
-define void @unprof2(i32 %I, i32 %J, i32* noalias nocapture %A, i32* noalias nocapture readonly %B) #0 {
-; CHECK: %i.us = phi i32 [ %add8.us, %for.latch ], [ 0, %for.outer.preheader ]
-; CHECK: %j.us = phi i32 [ 0, %for.outer ], [ %inc.us, %for.inner ]
-entry:
- %cmp = icmp ne i32 %J, 0
- %cmp122 = icmp ne i32 %I, 0
- %or.cond = and i1 %cmp, %cmp122
- br i1 %or.cond, label %for.outer.preheader, label %for.end
-
-for.outer.preheader:
- br label %for.outer
-
-for.outer:
- %i.us = phi i32 [ %add8.us, %for.latch ], [ 0, %for.outer.preheader ]
- br label %for.inner
-
-for.inner:
- %j.us = phi i32 [ 0, %for.outer ], [ %inc.us, %for.inner ]
- %sum1.us = phi i32 [ 0, %for.outer ], [ %add.us, %for.inner ]
- %arrayidx.us = getelementptr inbounds i32, i32* %B, i32 %j.us
- %0 = load i32, i32* %arrayidx.us, align 4, !tbaa !5
- %add.us = add i32 %0, %sum1.us
- %inc.us = add nuw i32 %j.us, 1
- %exitcond = icmp eq i32 %inc.us, 10
- br i1 %exitcond, label %for.latch, label %for.inner
-
-for.latch:
- %add.us.lcssa = phi i32 [ %add.us, %for.inner ]
- %arrayidx6.us = getelementptr inbounds i32, i32* %A, i32 %i.us
- store i32 %add.us.lcssa, i32* %arrayidx6.us, align 4, !tbaa !5
- %add8.us = add nuw i32 %i.us, 1
- %exitcond25 = icmp eq i32 %add8.us, %I
- br i1 %exitcond25, label %for.end.loopexit, label %for.outer
-
-for.end.loopexit:
- br label %for.end
-
-for.end:
- ret void
-}
-
-
-; CHECK-LABEL: unprof3
-; Complex inner loop
-define void @unprof3(i32 %I, i32 %J, i32* noalias nocapture %A, i32* noalias nocapture readonly %B) #0 {
-; CHECK: %i.us = phi i32 [ %add8.us, %for.latch ], [ 0, %for.outer.preheader ]
-; CHECK: %j.us = phi i32 [ 0, %for.outer ], [ %inc.us, %for.inner ]
-entry:
- %cmp = icmp ne i32 %J, 0
- %cmp122 = icmp ne i32 %I, 0
- %or.cond = and i1 %cmp, %cmp122
- br i1 %or.cond, label %for.outer.preheader, label %for.end
-
-for.outer.preheader:
- br label %for.outer
-
-for.outer:
- %i.us = phi i32 [ %add8.us, %for.latch ], [ 0, %for.outer.preheader ]
- br label %for.inner
-
-for.inner:
- %j.us = phi i32 [ 0, %for.outer ], [ %inc.us, %for.inner ]
- %sum1.us = phi i32 [ 0, %for.outer ], [ %add.us, %for.inner ]
- %arrayidx.us = getelementptr inbounds i32, i32* %B, i32 %j.us
- %0 = load i32, i32* %arrayidx.us, align 4, !tbaa !5
- %add.us = add i32 %0, %sum1.us
- %add.us0 = add i32 %0, %sum1.us
- %add.us1 = add i32 %0, %sum1.us
- %add.us2 = add i32 %0, %sum1.us
- %add.us3 = add i32 %0, %sum1.us
- %add.us4 = add i32 %0, %sum1.us
- %add.us5 = add i32 %0, %sum1.us
- %add.us6 = add i32 %0, %sum1.us
- %add.us7 = add i32 %0, %sum1.us
- %add.us8 = add i32 %0, %sum1.us
- %add.us9 = add i32 %0, %sum1.us
- %add.us10 = add i32 %0, %sum1.us
- %add.us11 = add i32 %0, %sum1.us
- %add.us12 = add i32 %0, %sum1.us
- %add.us13 = add i32 %0, %sum1.us
- %add.us14 = add i32 %0, %sum1.us
- %add.us15 = add i32 %0, %sum1.us
- %add.us16 = add i32 %0, %sum1.us
- %add.us17 = add i32 %0, %sum1.us
- %add.us18 = add i32 %0, %sum1.us
- %add.us19 = add i32 %0, %sum1.us
- %add.us20 = add i32 %0, %sum1.us
- %add.us21 = add i32 %0, %sum1.us
- %add.us22 = add i32 %0, %sum1.us
- %add.us23 = add i32 %0, %sum1.us
- %add.us24 = add i32 %0, %sum1.us
- %add.us25 = add i32 %0, %sum1.us
- %add.us26 = add i32 %0, %sum1.us
- %add.us27 = add i32 %0, %sum1.us
- %add.us28 = add i32 %0, %sum1.us
- %add.us29 = add i32 %0, %sum1.us
- %inc.us = add nuw i32 %j.us, 1
- %exitcond = icmp eq i32 %inc.us, %J
- br i1 %exitcond, label %for.latch, label %for.inner
-
-for.latch:
- %add.us.lcssa = phi i32 [ %add.us, %for.inner ]
- %arrayidx6.us = getelementptr inbounds i32, i32* %A, i32 %i.us
- store i32 %add.us.lcssa, i32* %arrayidx6.us, align 4, !tbaa !5
- %add8.us = add nuw i32 %i.us, 1
- %exitcond25 = icmp eq i32 %add8.us, %I
- br i1 %exitcond25, label %for.end.loopexit, label %for.outer
-
-for.end.loopexit:
- br label %for.end
-
-for.end:
- ret void
-}
-
-
-; CHECK-LABEL: unprof4
-; No loop invariant loads
-define void @unprof4(i32 %I, i32 %J, i32* noalias nocapture %A, i32* noalias nocapture readonly %B) #0 {
-; CHECK: %i.us = phi i32 [ %add8.us, %for.latch ], [ 0, %for.outer.preheader ]
-; CHECK: %j.us = phi i32 [ 0, %for.outer ], [ %inc.us, %for.inner ]
-entry:
- %cmp = icmp ne i32 %J, 0
- %cmp122 = icmp ne i32 %I, 0
- %or.cond = and i1 %cmp, %cmp122
- br i1 %or.cond, label %for.outer.preheader, label %for.end
-
-for.outer.preheader:
- br label %for.outer
-
-for.outer:
- %i.us = phi i32 [ %add8.us, %for.latch ], [ 0, %for.outer.preheader ]
- br label %for.inner
-
-for.inner:
- %j.us = phi i32 [ 0, %for.outer ], [ %inc.us, %for.inner ]
- %sum1.us = phi i32 [ 0, %for.outer ], [ %add.us, %for.inner ]
- %j2 = add i32 %j.us, %i.us
- %arrayidx.us = getelementptr inbounds i32, i32* %B, i32 %j2
- %0 = load i32, i32* %arrayidx.us, align 4, !tbaa !5
- %add.us = add i32 %0, %sum1.us
- %inc.us = add nuw i32 %j.us, 1
- %exitcond = icmp eq i32 %inc.us, %J
- br i1 %exitcond, label %for.latch, label %for.inner
-
-for.latch:
- %add.us.lcssa = phi i32 [ %add.us, %for.inner ]
- %arrayidx6.us = getelementptr inbounds i32, i32* %A, i32 %i.us
- store i32 %add.us.lcssa, i32* %arrayidx6.us, align 4, !tbaa !5
- %add8.us = add nuw i32 %i.us, 1
- %exitcond25 = icmp eq i32 %add8.us, %I
- br i1 %exitcond25, label %for.end.loopexit, label %for.outer
-
-for.end.loopexit:
- br label %for.end
-
-for.end:
- ret void
-}
-
-
-attributes #0 = { "target-cpu"="cortex-m33" }
-
-!5 = !{!6, !6, i64 0}
-!6 = !{!"omnipotent char", !7, i64 0}
-!7 = !{!"Simple C/C++ TBAA"}
+++ /dev/null
-; RUN: opt -basicaa -tbaa -loop-unroll-and-jam -unroll-and-jam-count=4 < %s -S | FileCheck %s
-
-target datalayout = "e-m:e-p:32:32-i64:64-v128:64:128-a:0:32-n32-S64"
-target triple = "thumbv8m.main-arm-none-eabi"
-
-; CHECK-LABEL: test1
-; Tests for(i) { sum = 0; for(j) sum += B[j]; A[i] = sum; }
-; CHECK-NEXT: entry:
-; CHECK-NEXT: [[CMP:%.*]] = icmp ne i32 [[J:%.*]], 0
-; CHECK-NEXT: [[CMP122:%.*]] = icmp ne i32 [[I:%.*]], 0
-; CHECK-NEXT: [[OR_COND:%.*]] = and i1 [[CMP]], [[CMP122]]
-; CHECK-NEXT: br i1 [[OR_COND]], label [[FOR_OUTER_PREHEADER:%.*]], label [[FOR_END:%.*]]
-; CHECK: for.outer.preheader:
-; CHECK-NEXT: [[TMP0:%.*]] = add i32 [[I]], -1
-; CHECK-NEXT: [[XTRAITER:%.*]] = and i32 [[I]], 3
-; CHECK-NEXT: [[TMP1:%.*]] = icmp ult i32 [[TMP0]], 3
-; CHECK-NEXT: br i1 [[TMP1]], label [[FOR_END_LOOPEXIT_UNR_LCSSA:%.*]], label [[FOR_OUTER_PREHEADER_NEW:%.*]]
-; CHECK: for.outer.preheader.new:
-; CHECK-NEXT: [[UNROLL_ITER:%.*]] = sub i32 [[I]], [[XTRAITER]]
-; CHECK-NEXT: br label [[FOR_OUTER:%.*]]
-; CHECK: for.outer:
-; CHECK-NEXT: [[I_US:%.*]] = phi i32 [ [[ADD8_US_3:%.*]], [[FOR_LATCH:%.*]] ], [ 0, [[FOR_OUTER_PREHEADER_NEW]] ]
-; CHECK-NEXT: [[NITER:%.*]] = phi i32 [ [[UNROLL_ITER]], [[FOR_OUTER_PREHEADER_NEW]] ], [ [[NITER_NSUB_3:%.*]], [[FOR_LATCH]] ]
-; CHECK-NEXT: [[ADD8_US:%.*]] = add nuw nsw i32 [[I_US]], 1
-; CHECK-NEXT: [[NITER_NSUB:%.*]] = sub i32 [[NITER]], 1
-; CHECK-NEXT: [[ADD8_US_1:%.*]] = add nuw nsw i32 [[ADD8_US]], 1
-; CHECK-NEXT: [[NITER_NSUB_1:%.*]] = sub i32 [[NITER_NSUB]], 1
-; CHECK-NEXT: [[ADD8_US_2:%.*]] = add nuw nsw i32 [[ADD8_US_1]], 1
-; CHECK-NEXT: [[NITER_NSUB_2:%.*]] = sub i32 [[NITER_NSUB_1]], 1
-; CHECK-NEXT: [[ADD8_US_3]] = add nuw i32 [[ADD8_US_2]], 1
-; CHECK-NEXT: [[NITER_NSUB_3]] = sub i32 [[NITER_NSUB_2]], 1
-; CHECK-NEXT: br label [[FOR_INNER:%.*]]
-; CHECK: for.inner:
-; CHECK-NEXT: [[J_US:%.*]] = phi i32 [ 0, [[FOR_OUTER]] ], [ [[INC_US:%.*]], [[FOR_INNER]] ]
-; CHECK-NEXT: [[SUM1_US:%.*]] = phi i32 [ 0, [[FOR_OUTER]] ], [ [[ADD_US:%.*]], [[FOR_INNER]] ]
-; CHECK-NEXT: [[J_US_1:%.*]] = phi i32 [ 0, [[FOR_OUTER]] ], [ [[INC_US_1:%.*]], [[FOR_INNER]] ]
-; CHECK-NEXT: [[SUM1_US_1:%.*]] = phi i32 [ 0, [[FOR_OUTER]] ], [ [[ADD_US_1:%.*]], [[FOR_INNER]] ]
-; CHECK-NEXT: [[J_US_2:%.*]] = phi i32 [ 0, [[FOR_OUTER]] ], [ [[INC_US_2:%.*]], [[FOR_INNER]] ]
-; CHECK-NEXT: [[SUM1_US_2:%.*]] = phi i32 [ 0, [[FOR_OUTER]] ], [ [[ADD_US_2:%.*]], [[FOR_INNER]] ]
-; CHECK-NEXT: [[J_US_3:%.*]] = phi i32 [ 0, [[FOR_OUTER]] ], [ [[INC_US_3:%.*]], [[FOR_INNER]] ]
-; CHECK-NEXT: [[SUM1_US_3:%.*]] = phi i32 [ 0, [[FOR_OUTER]] ], [ [[ADD_US_3:%.*]], [[FOR_INNER]] ]
-; CHECK-NEXT: [[ARRAYIDX_US:%.*]] = getelementptr inbounds i32, i32* [[B:%.*]], i32 [[J_US]]
-; CHECK-NEXT: [[TMP2:%.*]] = load i32, i32* [[ARRAYIDX_US]], align 4, !tbaa !0
-; CHECK-NEXT: [[ADD_US]] = add i32 [[TMP2]], [[SUM1_US]]
-; CHECK-NEXT: [[INC_US]] = add nuw i32 [[J_US]], 1
-; CHECK-NEXT: [[ARRAYIDX_US_1:%.*]] = getelementptr inbounds i32, i32* [[B]], i32 [[J_US_1]]
-; CHECK-NEXT: [[TMP3:%.*]] = load i32, i32* [[ARRAYIDX_US_1]], align 4, !tbaa !0
-; CHECK-NEXT: [[ADD_US_1]] = add i32 [[TMP3]], [[SUM1_US_1]]
-; CHECK-NEXT: [[INC_US_1]] = add nuw i32 [[J_US_1]], 1
-; CHECK-NEXT: [[ARRAYIDX_US_2:%.*]] = getelementptr inbounds i32, i32* [[B]], i32 [[J_US_2]]
-; CHECK-NEXT: [[TMP4:%.*]] = load i32, i32* [[ARRAYIDX_US_2]], align 4, !tbaa !0
-; CHECK-NEXT: [[ADD_US_2]] = add i32 [[TMP4]], [[SUM1_US_2]]
-; CHECK-NEXT: [[INC_US_2]] = add nuw i32 [[J_US_2]], 1
-; CHECK-NEXT: [[ARRAYIDX_US_3:%.*]] = getelementptr inbounds i32, i32* [[B]], i32 [[J_US_3]]
-; CHECK-NEXT: [[TMP5:%.*]] = load i32, i32* [[ARRAYIDX_US_3]], align 4, !tbaa !0
-; CHECK-NEXT: [[ADD_US_3]] = add i32 [[TMP5]], [[SUM1_US_3]]
-; CHECK-NEXT: [[INC_US_3]] = add nuw i32 [[J_US_3]], 1
-; CHECK-NEXT: [[EXITCOND_3:%.*]] = icmp eq i32 [[INC_US_3]], [[J]]
-; CHECK-NEXT: br i1 [[EXITCOND_3]], label [[FOR_LATCH]], label [[FOR_INNER]]
-; CHECK: for.latch:
-; CHECK-NEXT: [[ADD_US_LCSSA:%.*]] = phi i32 [ [[ADD_US]], [[FOR_INNER]] ]
-; CHECK-NEXT: [[ADD_US_LCSSA_1:%.*]] = phi i32 [ [[ADD_US_1]], [[FOR_INNER]] ]
-; CHECK-NEXT: [[ADD_US_LCSSA_2:%.*]] = phi i32 [ [[ADD_US_2]], [[FOR_INNER]] ]
-; CHECK-NEXT: [[ADD_US_LCSSA_3:%.*]] = phi i32 [ [[ADD_US_3]], [[FOR_INNER]] ]
-; CHECK-NEXT: [[ARRAYIDX6_US:%.*]] = getelementptr inbounds i32, i32* [[A:%.*]], i32 [[I_US]]
-; CHECK-NEXT: store i32 [[ADD_US_LCSSA]], i32* [[ARRAYIDX6_US]], align 4, !tbaa !0
-; CHECK-NEXT: [[ARRAYIDX6_US_1:%.*]] = getelementptr inbounds i32, i32* [[A]], i32 [[ADD8_US]]
-; CHECK-NEXT: store i32 [[ADD_US_LCSSA_1]], i32* [[ARRAYIDX6_US_1]], align 4, !tbaa !0
-; CHECK-NEXT: [[ARRAYIDX6_US_2:%.*]] = getelementptr inbounds i32, i32* [[A]], i32 [[ADD8_US_1]]
-; CHECK-NEXT: store i32 [[ADD_US_LCSSA_2]], i32* [[ARRAYIDX6_US_2]], align 4, !tbaa !0
-; CHECK-NEXT: [[ARRAYIDX6_US_3:%.*]] = getelementptr inbounds i32, i32* [[A]], i32 [[ADD8_US_2]]
-; CHECK-NEXT: store i32 [[ADD_US_LCSSA_3]], i32* [[ARRAYIDX6_US_3]], align 4, !tbaa !0
-; CHECK-NEXT: [[NITER_NCMP_3:%.*]] = icmp eq i32 [[NITER_NSUB_3]], 0
-; CHECK-NEXT: br i1 [[NITER_NCMP_3]], label [[FOR_END_LOOPEXIT_UNR_LCSSA_LOOPEXIT:%.*]], label [[FOR_OUTER]], !llvm.loop !4
-; CHECK: for.end.loopexit.unr-lcssa.loopexit:
-; CHECK-NEXT: [[I_US_UNR_PH:%.*]] = phi i32 [ [[ADD8_US_3]], [[FOR_LATCH]] ]
-; CHECK-NEXT: br label [[FOR_END_LOOPEXIT_UNR_LCSSA]]
-; CHECK: for.end.loopexit.unr-lcssa:
-; CHECK-NEXT: [[I_US_UNR:%.*]] = phi i32 [ 0, [[FOR_OUTER_PREHEADER]] ], [ [[I_US_UNR_PH]], [[FOR_END_LOOPEXIT_UNR_LCSSA_LOOPEXIT]] ]
-; CHECK-NEXT: [[LCMP_MOD:%.*]] = icmp ne i32 [[XTRAITER]], 0
-; CHECK-NEXT: br i1 [[LCMP_MOD]], label [[FOR_OUTER_EPIL_PREHEADER:%.*]], label [[FOR_END_LOOPEXIT:%.*]]
-; CHECK: for.outer.epil.preheader:
-; CHECK-NEXT: br label [[FOR_OUTER_EPIL:%.*]]
-; CHECK: for.outer.epil:
-; CHECK-NEXT: br label [[FOR_INNER_EPIL:%.*]]
-; CHECK: for.inner.epil:
-; CHECK-NEXT: [[J_US_EPIL:%.*]] = phi i32 [ 0, [[FOR_OUTER_EPIL]] ], [ [[INC_US_EPIL:%.*]], [[FOR_INNER_EPIL]] ]
-; CHECK-NEXT: [[SUM1_US_EPIL:%.*]] = phi i32 [ 0, [[FOR_OUTER_EPIL]] ], [ [[ADD_US_EPIL:%.*]], [[FOR_INNER_EPIL]] ]
-; CHECK-NEXT: [[ARRAYIDX_US_EPIL:%.*]] = getelementptr inbounds i32, i32* [[B]], i32 [[J_US_EPIL]]
-; CHECK-NEXT: [[TMP6:%.*]] = load i32, i32* [[ARRAYIDX_US_EPIL]], align 4, !tbaa !0
-; CHECK-NEXT: [[ADD_US_EPIL]] = add i32 [[TMP6]], [[SUM1_US_EPIL]]
-; CHECK-NEXT: [[INC_US_EPIL]] = add nuw i32 [[J_US_EPIL]], 1
-; CHECK-NEXT: [[EXITCOND_EPIL:%.*]] = icmp eq i32 [[INC_US_EPIL]], [[J]]
-; CHECK-NEXT: br i1 [[EXITCOND_EPIL]], label [[FOR_LATCH_EPIL:%.*]], label [[FOR_INNER_EPIL]]
-; CHECK: for.latch.epil:
-; CHECK-NEXT: [[ADD_US_LCSSA_EPIL:%.*]] = phi i32 [ [[ADD_US_EPIL]], [[FOR_INNER_EPIL]] ]
-; CHECK-NEXT: [[ARRAYIDX6_US_EPIL:%.*]] = getelementptr inbounds i32, i32* [[A]], i32 [[I_US_UNR]]
-; CHECK-NEXT: store i32 [[ADD_US_LCSSA_EPIL]], i32* [[ARRAYIDX6_US_EPIL]], align 4, !tbaa !0
-; CHECK-NEXT: [[ADD8_US_EPIL:%.*]] = add nuw i32 [[I_US_UNR]], 1
-; CHECK-NEXT: [[EPIL_ITER_SUB:%.*]] = sub i32 [[XTRAITER]], 1
-; CHECK-NEXT: [[EPIL_ITER_CMP:%.*]] = icmp ne i32 [[EPIL_ITER_SUB]], 0
-; CHECK-NEXT: br i1 [[EPIL_ITER_CMP]], label [[FOR_OUTER_EPIL_1:%.*]], label [[FOR_END_LOOPEXIT_EPILOG_LCSSA:%.*]]
-; CHECK: for.end.loopexit.epilog-lcssa:
-; CHECK-NEXT: br label [[FOR_END_LOOPEXIT]]
-; CHECK: for.end.loopexit:
-; CHECK-NEXT: br label [[FOR_END]]
-; CHECK: for.end:
-; CHECK-NEXT: ret void
-; CHECK: for.outer.epil.1:
-; CHECK-NEXT: br label [[FOR_INNER_EPIL_1:%.*]]
-; CHECK: for.inner.epil.1:
-; CHECK-NEXT: [[J_US_EPIL_1:%.*]] = phi i32 [ 0, [[FOR_OUTER_EPIL_1]] ], [ [[INC_US_EPIL_1:%.*]], [[FOR_INNER_EPIL_1]] ]
-; CHECK-NEXT: [[SUM1_US_EPIL_1:%.*]] = phi i32 [ 0, [[FOR_OUTER_EPIL_1]] ], [ [[ADD_US_EPIL_1:%.*]], [[FOR_INNER_EPIL_1]] ]
-; CHECK-NEXT: [[ARRAYIDX_US_EPIL_1:%.*]] = getelementptr inbounds i32, i32* [[B]], i32 [[J_US_EPIL_1]]
-; CHECK-NEXT: [[TMP7:%.*]] = load i32, i32* [[ARRAYIDX_US_EPIL_1]], align 4, !tbaa !0
-; CHECK-NEXT: [[ADD_US_EPIL_1]] = add i32 [[TMP7]], [[SUM1_US_EPIL_1]]
-; CHECK-NEXT: [[INC_US_EPIL_1]] = add nuw i32 [[J_US_EPIL_1]], 1
-; CHECK-NEXT: [[EXITCOND_EPIL_1:%.*]] = icmp eq i32 [[INC_US_EPIL_1]], [[J]]
-; CHECK-NEXT: br i1 [[EXITCOND_EPIL_1]], label [[FOR_LATCH_EPIL_1:%.*]], label [[FOR_INNER_EPIL_1]]
-; CHECK: for.latch.epil.1:
-; CHECK-NEXT: [[ADD_US_LCSSA_EPIL_1:%.*]] = phi i32 [ [[ADD_US_EPIL_1]], [[FOR_INNER_EPIL_1]] ]
-; CHECK-NEXT: [[ARRAYIDX6_US_EPIL_1:%.*]] = getelementptr inbounds i32, i32* [[A]], i32 [[ADD8_US_EPIL]]
-; CHECK-NEXT: store i32 [[ADD_US_LCSSA_EPIL_1]], i32* [[ARRAYIDX6_US_EPIL_1]], align 4, !tbaa !0
-; CHECK-NEXT: [[ADD8_US_EPIL_1:%.*]] = add nuw i32 [[ADD8_US_EPIL]], 1
-; CHECK-NEXT: [[EPIL_ITER_SUB_1:%.*]] = sub i32 [[EPIL_ITER_SUB]], 1
-; CHECK-NEXT: [[EPIL_ITER_CMP_1:%.*]] = icmp ne i32 [[EPIL_ITER_SUB_1]], 0
-; CHECK-NEXT: br i1 [[EPIL_ITER_CMP_1]], label [[FOR_OUTER_EPIL_2:%.*]], label [[FOR_END_LOOPEXIT_EPILOG_LCSSA]]
-; CHECK: for.outer.epil.2:
-; CHECK-NEXT: br label [[FOR_INNER_EPIL_2:%.*]]
-; CHECK: for.inner.epil.2:
-; CHECK-NEXT: [[J_US_EPIL_2:%.*]] = phi i32 [ 0, [[FOR_OUTER_EPIL_2]] ], [ [[INC_US_EPIL_2:%.*]], [[FOR_INNER_EPIL_2]] ]
-; CHECK-NEXT: [[SUM1_US_EPIL_2:%.*]] = phi i32 [ 0, [[FOR_OUTER_EPIL_2]] ], [ [[ADD_US_EPIL_2:%.*]], [[FOR_INNER_EPIL_2]] ]
-; CHECK-NEXT: [[ARRAYIDX_US_EPIL_2:%.*]] = getelementptr inbounds i32, i32* [[B]], i32 [[J_US_EPIL_2]]
-; CHECK-NEXT: [[TMP8:%.*]] = load i32, i32* [[ARRAYIDX_US_EPIL_2]], align 4, !tbaa !0
-; CHECK-NEXT: [[ADD_US_EPIL_2]] = add i32 [[TMP8]], [[SUM1_US_EPIL_2]]
-; CHECK-NEXT: [[INC_US_EPIL_2]] = add nuw i32 [[J_US_EPIL_2]], 1
-; CHECK-NEXT: [[EXITCOND_EPIL_2:%.*]] = icmp eq i32 [[INC_US_EPIL_2]], [[J]]
-; CHECK-NEXT: br i1 [[EXITCOND_EPIL_2]], label [[FOR_LATCH_EPIL_2:%.*]], label [[FOR_INNER_EPIL_2]]
-; CHECK: for.latch.epil.2:
-; CHECK-NEXT: [[ADD_US_LCSSA_EPIL_2:%.*]] = phi i32 [ [[ADD_US_EPIL_2]], [[FOR_INNER_EPIL_2]] ]
-; CHECK-NEXT: [[ARRAYIDX6_US_EPIL_2:%.*]] = getelementptr inbounds i32, i32* [[A]], i32 [[ADD8_US_EPIL_1]]
-; CHECK-NEXT: store i32 [[ADD_US_LCSSA_EPIL_2]], i32* [[ARRAYIDX6_US_EPIL_2]], align 4, !tbaa !0
-; CHECK-NEXT: [[ADD8_US_EPIL_2:%.*]] = add nuw i32 [[ADD8_US_EPIL_1]], 1
-; CHECK-NEXT: [[EPIL_ITER_SUB_2:%.*]] = sub i32 [[EPIL_ITER_SUB_1]], 1
-; CHECK-NEXT: br label [[FOR_END_LOOPEXIT_EPILOG_LCSSA]]
-define void @test1(i32 %I, i32 %J, i32* noalias nocapture %A, i32* noalias nocapture readonly %B) #0 {
-entry:
- %cmp = icmp ne i32 %J, 0
- %cmp122 = icmp ne i32 %I, 0
- %or.cond = and i1 %cmp, %cmp122
- br i1 %or.cond, label %for.outer.preheader, label %for.end
-
-for.outer.preheader:
- br label %for.outer
-
-for.outer:
- %i.us = phi i32 [ %add8.us, %for.latch ], [ 0, %for.outer.preheader ]
- br label %for.inner
-
-for.inner:
- %j.us = phi i32 [ 0, %for.outer ], [ %inc.us, %for.inner ]
- %sum1.us = phi i32 [ 0, %for.outer ], [ %add.us, %for.inner ]
- %arrayidx.us = getelementptr inbounds i32, i32* %B, i32 %j.us
- %0 = load i32, i32* %arrayidx.us, align 4, !tbaa !5
- %add.us = add i32 %0, %sum1.us
- %inc.us = add nuw i32 %j.us, 1
- %exitcond = icmp eq i32 %inc.us, %J
- br i1 %exitcond, label %for.latch, label %for.inner
-
-for.latch:
- %add.us.lcssa = phi i32 [ %add.us, %for.inner ]
- %arrayidx6.us = getelementptr inbounds i32, i32* %A, i32 %i.us
- store i32 %add.us.lcssa, i32* %arrayidx6.us, align 4, !tbaa !5
- %add8.us = add nuw i32 %i.us, 1
- %exitcond25 = icmp eq i32 %add8.us, %I
- br i1 %exitcond25, label %for.end.loopexit, label %for.outer
-
-for.end.loopexit:
- br label %for.end
-
-for.end:
- ret void
-}
-
-; CHECK-LABEL: test2
-; Tests for(i) { sum = A[i]; for(j) sum += B[j]; A[i] = sum; }
-; A[i] load/store dependency should not block unroll-and-jam
-; CHECK: for.outer:
-; CHECK: %i.us = phi i32 [ %add9.us.3, %for.latch ], [ 0, %for.outer.preheader.new ]
-; CHECK: %niter = phi i32 [ %unroll_iter, %for.outer.preheader.new ], [ %niter.nsub.3, %for.latch ]
-; CHECK: br label %for.inner
-; CHECK: for.inner:
-; CHECK: %j.us = phi i32 [ 0, %for.outer ], [ %inc.us, %for.inner ]
-; CHECK: %sum1.us = phi i32 [ %2, %for.outer ], [ %add.us, %for.inner ]
-; CHECK: %j.us.1 = phi i32 [ 0, %for.outer ], [ %inc.us.1, %for.inner ]
-; CHECK: %sum1.us.1 = phi i32 [ %3, %for.outer ], [ %add.us.1, %for.inner ]
-; CHECK: %j.us.2 = phi i32 [ 0, %for.outer ], [ %inc.us.2, %for.inner ]
-; CHECK: %sum1.us.2 = phi i32 [ %4, %for.outer ], [ %add.us.2, %for.inner ]
-; CHECK: %j.us.3 = phi i32 [ 0, %for.outer ], [ %inc.us.3, %for.inner ]
-; CHECK: %sum1.us.3 = phi i32 [ %5, %for.outer ], [ %add.us.3, %for.inner ]
-; CHECK: br i1 %exitcond.3, label %for.latch, label %for.inner
-; CHECK: for.latch:
-; CHECK: %add.us.lcssa = phi i32 [ %add.us, %for.inner ]
-; CHECK: %add.us.lcssa.1 = phi i32 [ %add.us.1, %for.inner ]
-; CHECK: %add.us.lcssa.2 = phi i32 [ %add.us.2, %for.inner ]
-; CHECK: %add.us.lcssa.3 = phi i32 [ %add.us.3, %for.inner ]
-; CHECK: br i1 %niter.ncmp.3, label %for.end10.loopexit.unr-lcssa.loopexit, label %for.outer
-; CHECK: for.end10.loopexit.unr-lcssa.loopexit:
-define void @test2(i32 %I, i32 %J, i32* noalias nocapture %A, i32* noalias nocapture readonly %B) #0 {
-entry:
- %cmp = icmp ne i32 %J, 0
- %cmp125 = icmp ne i32 %I, 0
- %or.cond = and i1 %cmp, %cmp125
- br i1 %or.cond, label %for.outer.preheader, label %for.end10
-
-for.outer.preheader:
- br label %for.outer
-
-for.outer:
- %i.us = phi i32 [ %add9.us, %for.latch ], [ 0, %for.outer.preheader ]
- %arrayidx.us = getelementptr inbounds i32, i32* %A, i32 %i.us
- %0 = load i32, i32* %arrayidx.us, align 4, !tbaa !5
- br label %for.inner
-
-for.inner:
- %j.us = phi i32 [ 0, %for.outer ], [ %inc.us, %for.inner ]
- %sum1.us = phi i32 [ %0, %for.outer ], [ %add.us, %for.inner ]
- %arrayidx6.us = getelementptr inbounds i32, i32* %B, i32 %j.us
- %1 = load i32, i32* %arrayidx6.us, align 4, !tbaa !5
- %add.us = add i32 %1, %sum1.us
- %inc.us = add nuw i32 %j.us, 1
- %exitcond = icmp eq i32 %inc.us, %J
- br i1 %exitcond, label %for.latch, label %for.inner
-
-for.latch:
- %add.us.lcssa = phi i32 [ %add.us, %for.inner ]
- store i32 %add.us.lcssa, i32* %arrayidx.us, align 4, !tbaa !5
- %add9.us = add nuw i32 %i.us, 1
- %exitcond28 = icmp eq i32 %add9.us, %I
- br i1 %exitcond28, label %for.end10.loopexit, label %for.outer
-
-for.end10.loopexit:
- br label %for.end10
-
-for.end10:
- ret void
-}
-
-
-; CHECK-LABEL: test3
-; Tests Complete unroll-and-jam of the outer loop
-; CHECK: for.outer:
-; CHECK: br label %for.inner
-; CHECK: for.inner:
-; CHECK: %j.021 = phi i32 [ 0, %for.outer ], [ %inc, %for.inner ]
-; CHECK: %sum1.020 = phi i32 [ 0, %for.outer ], [ %add, %for.inner ]
-; CHECK: %j.021.1 = phi i32 [ 0, %for.outer ], [ %inc.1, %for.inner ]
-; CHECK: %sum1.020.1 = phi i32 [ 0, %for.outer ], [ %add.1, %for.inner ]
-; CHECK: %j.021.2 = phi i32 [ 0, %for.outer ], [ %inc.2, %for.inner ]
-; CHECK: %sum1.020.2 = phi i32 [ 0, %for.outer ], [ %add.2, %for.inner ]
-; CHECK: %j.021.3 = phi i32 [ 0, %for.outer ], [ %inc.3, %for.inner ]
-; CHECK: %sum1.020.3 = phi i32 [ 0, %for.outer ], [ %add.3, %for.inner ]
-; CHECK: br i1 %exitcond.3, label %for.latch, label %for.inner
-; CHECK: for.latch:
-; CHECK: %add.lcssa = phi i32 [ %add, %for.inner ]
-; CHECK: %add.lcssa.1 = phi i32 [ %add.1, %for.inner ]
-; CHECK: %add.lcssa.2 = phi i32 [ %add.2, %for.inner ]
-; CHECK: %add.lcssa.3 = phi i32 [ %add.3, %for.inner ]
-; CHECK: br label %for.end
-; CHECK: for.end:
-define void @test3(i32 %I, i32 %J, i32* noalias nocapture %A, i32* noalias nocapture readonly %B) #0 {
-entry:
- %cmp = icmp eq i32 %J, 0
- br i1 %cmp, label %for.end, label %for.preheader
-
-for.preheader:
- br label %for.outer
-
-for.outer:
- %i.022 = phi i32 [ %add8, %for.latch ], [ 0, %for.preheader ]
- br label %for.inner
-
-for.inner:
- %j.021 = phi i32 [ 0, %for.outer ], [ %inc, %for.inner ]
- %sum1.020 = phi i32 [ 0, %for.outer ], [ %add, %for.inner ]
- %arrayidx = getelementptr inbounds i32, i32* %B, i32 %j.021
- %0 = load i32, i32* %arrayidx, align 4, !tbaa !5
- %sub = add i32 %sum1.020, 10
- %add = sub i32 %sub, %0
- %inc = add nuw i32 %j.021, 1
- %exitcond = icmp eq i32 %inc, %J
- br i1 %exitcond, label %for.latch, label %for.inner
-
-for.latch:
- %arrayidx6 = getelementptr inbounds i32, i32* %A, i32 %i.022
- store i32 %add, i32* %arrayidx6, align 4, !tbaa !5
- %add8 = add nuw nsw i32 %i.022, 1
- %exitcond23 = icmp eq i32 %add8, 4
- br i1 %exitcond23, label %for.end, label %for.outer
-
-for.end:
- ret void
-}
-
-; CHECK-LABEL: test4
-; Tests Complete unroll-and-jam with a trip count of 1
-; CHECK: for.outer:
-; CHECK: br label %for.inner
-; CHECK: for.inner:
-; CHECK: %j.021 = phi i32 [ 0, %for.outer ], [ %inc, %for.inner ]
-; CHECK: %sum1.020 = phi i32 [ 0, %for.outer ], [ %add, %for.inner ]
-; CHECK: br i1 %exitcond, label %for.latch, label %for.inner
-; CHECK: for.latch:
-; CHECK: %add.lcssa = phi i32 [ %add, %for.inner ]
-; CHECK: br label %for.end
-; CHECK: for.end:
-define void @test4(i32 %I, i32 %J, i32* noalias nocapture %A, i32* noalias nocapture readonly %B) #0 {
-entry:
- %cmp = icmp eq i32 %J, 0
- br i1 %cmp, label %for.end, label %for.preheader
-
-for.preheader:
- br label %for.outer
-
-for.outer:
- %i.022 = phi i32 [ %add8, %for.latch ], [ 0, %for.preheader ]
- br label %for.inner
-
-for.inner:
- %j.021 = phi i32 [ 0, %for.outer ], [ %inc, %for.inner ]
- %sum1.020 = phi i32 [ 0, %for.outer ], [ %add, %for.inner ]
- %arrayidx = getelementptr inbounds i32, i32* %B, i32 %j.021
- %0 = load i32, i32* %arrayidx, align 4, !tbaa !5
- %sub = add i32 %sum1.020, 10
- %add = sub i32 %sub, %0
- %inc = add nuw i32 %j.021, 1
- %exitcond = icmp eq i32 %inc, %J
- br i1 %exitcond, label %for.latch, label %for.inner
-
-for.latch:
- %arrayidx6 = getelementptr inbounds i32, i32* %A, i32 %i.022
- store i32 %add, i32* %arrayidx6, align 4, !tbaa !5
- %add8 = add nuw nsw i32 %i.022, 1
- %exitcond23 = icmp eq i32 %add8, 1
- br i1 %exitcond23, label %for.end, label %for.outer
-
-for.end:
- ret void
-}
-
-
-
-
-
-; CHECK-LABEL: test5
-; Multiple SubLoopBlocks
-; CHECK: for.outer:
-; CHECK: br label %for.inner
-; CHECK: for.inner:
-; CHECK: %inc8.sink15 = phi i32 [ 0, %for.outer ], [ %inc8, %for.inc.1 ]
-; CHECK: %inc8.sink15.1 = phi i32 [ 0, %for.outer ], [ %inc8.1, %for.inc.1 ]
-; CHECK: br label %for.inner2
-; CHECK: for.inner2:
-; CHECK: br i1 %tobool, label %for.cond4, label %for.inc
-; CHECK: for.cond4:
-; CHECK: br i1 %tobool.1, label %for.cond4a, label %for.inc
-; CHECK: for.cond4a:
-; CHECK: br label %for.inc
-; CHECK: for.inc:
-; CHECK: br i1 %tobool.11, label %for.cond4.1, label %for.inc.1
-; CHECK: for.latch:
-; CHECK: br label %for.end
-; CHECK: for.end:
-; CHECK: ret i32 0
-; CHECK: for.cond4.1:
-; CHECK: br i1 %tobool.1.1, label %for.cond4a.1, label %for.inc.1
-; CHECK: for.cond4a.1:
-; CHECK: br label %for.inc.1
-; CHECK: for.inc.1:
-; CHECK: br i1 %exitcond.1, label %for.latch, label %for.inner
-@a = hidden global [1 x i32] zeroinitializer, align 4
-define i32 @test5() #0 {
-entry:
- br label %for.outer
-
-for.outer:
- %.sink16 = phi i32 [ 0, %entry ], [ %add, %for.latch ]
- br label %for.inner
-
-for.inner:
- %inc8.sink15 = phi i32 [ 0, %for.outer ], [ %inc8, %for.inc ]
- br label %for.inner2
-
-for.inner2:
- %l1 = load i32, i32* getelementptr inbounds ([1 x i32], [1 x i32]* @a, i32 0, i32 0), align 4
- %tobool = icmp eq i32 %l1, 0
- br i1 %tobool, label %for.cond4, label %for.inc
-
-for.cond4:
- %l0 = load i32, i32* getelementptr inbounds ([1 x i32], [1 x i32]* @a, i32 1, i32 0), align 4
- %tobool.1 = icmp eq i32 %l0, 0
- br i1 %tobool.1, label %for.cond4a, label %for.inc
-
-for.cond4a:
- br label %for.inc
-
-for.inc:
- %l2 = phi i32 [ 0, %for.inner2 ], [ 1, %for.cond4 ], [ 2, %for.cond4a ]
- %inc8 = add nuw nsw i32 %inc8.sink15, 1
- %exitcond = icmp eq i32 %inc8, 3
- br i1 %exitcond, label %for.latch, label %for.inner
-
-for.latch:
- %.lcssa = phi i32 [ %l2, %for.inc ]
- %conv11 = and i32 %.sink16, 255
- %add = add nuw nsw i32 %conv11, 4
- %cmp = icmp eq i32 %add, 8
- br i1 %cmp, label %for.end, label %for.outer
-
-for.end:
- %.lcssa.lcssa = phi i32 [ %.lcssa, %for.latch ]
- ret i32 0
-}
-
-
-
-
-; CHECK-LABEL: test6
-; Test odd uses of phi nodes
-; CHECK: for.outer:
-; CHECK: br label %for.inner
-; CHECK: for.inner:
-; CHECK: br i1 %exitcond.3, label %for.inner, label %for.latch
-; CHECK: for.latch:
-; CHECK: br label %for.end
-; CHECK: for.end:
-; CHECK: ret i32 0
-@f = hidden global i32 0, align 4
-define i32 @test6() #0 {
-entry:
- %f.promoted10 = load i32, i32* @f, align 4, !tbaa !5
- br label %for.outer
-
-for.outer:
- %p0 = phi i32 [ %f.promoted10, %entry ], [ 2, %for.latch ]
- %inc5.sink9 = phi i32 [ 2, %entry ], [ %inc5, %for.latch ]
- br label %for.inner
-
-for.inner:
- %p1 = phi i32 [ %p0, %for.outer ], [ 2, %for.inner ]
- %inc.sink8 = phi i32 [ 0, %for.outer ], [ %inc, %for.inner ]
- %inc = add nuw nsw i32 %inc.sink8, 1
- %exitcond = icmp ne i32 %inc, 7
- br i1 %exitcond, label %for.inner, label %for.latch
-
-for.latch:
- %.lcssa = phi i32 [ %p1, %for.inner ]
- %inc5 = add nuw nsw i32 %inc5.sink9, 1
- %exitcond11 = icmp ne i32 %inc5, 7
- br i1 %exitcond11, label %for.outer, label %for.end
-
-for.end:
- %.lcssa.lcssa = phi i32 [ %.lcssa, %for.latch ]
- %inc.lcssa.lcssa = phi i32 [ 7, %for.latch ]
- ret i32 0
-}
-
-
-
-; CHECK-LABEL: test7
-; Has a positive dependency between two stores. Still valid.
-; The negative dependecy is in unroll-and-jam-disabled.ll
-; CHECK: for.outer:
-; CHECK: %i = phi i32 [ %add.3, %for.latch ], [ 0, %for.preheader.new ]
-; CHECK: %niter = phi i32 [ %unroll_iter, %for.preheader.new ], [ %niter.nsub.3, %for.latch ]
-; CHECK: br label %for.inner
-; CHECK: for.latch:
-; CHECK: %add9.lcssa = phi i32 [ %add9, %for.inner ]
-; CHECK: %add9.lcssa.1 = phi i32 [ %add9.1, %for.inner ]
-; CHECK: %add9.lcssa.2 = phi i32 [ %add9.2, %for.inner ]
-; CHECK: %add9.lcssa.3 = phi i32 [ %add9.3, %for.inner ]
-; CHECK: br i1 %niter.ncmp.3, label %for.end.loopexit.unr-lcssa.loopexit, label %for.outer
-; CHECK: for.inner:
-; CHECK: %sum = phi i32 [ 0, %for.outer ], [ %add9, %for.inner ]
-; CHECK: %j = phi i32 [ 0, %for.outer ], [ %add10, %for.inner ]
-; CHECK: %sum.1 = phi i32 [ 0, %for.outer ], [ %add9.1, %for.inner ]
-; CHECK: %j.1 = phi i32 [ 0, %for.outer ], [ %add10.1, %for.inner ]
-; CHECK: %sum.2 = phi i32 [ 0, %for.outer ], [ %add9.2, %for.inner ]
-; CHECK: %j.2 = phi i32 [ 0, %for.outer ], [ %add10.2, %for.inner ]
-; CHECK: %sum.3 = phi i32 [ 0, %for.outer ], [ %add9.3, %for.inner ]
-; CHECK: %j.3 = phi i32 [ 0, %for.outer ], [ %add10.3, %for.inner ]
-; CHECK: br i1 %exitcond.3, label %for.latch, label %for.inner
-; CHECK: for.end.loopexit.unr-lcssa.loopexit:
-define void @test7(i32 %I, i32 %J, i32* noalias nocapture %A, i32* noalias nocapture readonly %B) #0 {
-entry:
- %cmp = icmp ne i32 %J, 0
- %cmp128 = icmp ne i32 %I, 0
- %or.cond = and i1 %cmp128, %cmp
- br i1 %or.cond, label %for.preheader, label %for.end
-
-for.preheader:
- br label %for.outer
-
-for.outer:
- %i = phi i32 [ %add, %for.latch ], [ 0, %for.preheader ]
- %arrayidx = getelementptr inbounds i32, i32* %A, i32 %i
- store i32 0, i32* %arrayidx, align 4, !tbaa !5
- %add = add nuw i32 %i, 1
- %arrayidx2 = getelementptr inbounds i32, i32* %A, i32 %add
- store i32 2, i32* %arrayidx2, align 4, !tbaa !5
- br label %for.inner
-
-for.latch:
- store i32 %add9, i32* %arrayidx, align 4, !tbaa !5
- %exitcond30 = icmp eq i32 %add, %I
- br i1 %exitcond30, label %for.end, label %for.outer
-
-for.inner:
- %sum = phi i32 [ 0, %for.outer ], [ %add9, %for.inner ]
- %j = phi i32 [ 0, %for.outer ], [ %add10, %for.inner ]
- %arrayidx7 = getelementptr inbounds i32, i32* %B, i32 %j
- %l1 = load i32, i32* %arrayidx7, align 4, !tbaa !5
- %add9 = add i32 %l1, %sum
- %add10 = add nuw i32 %j, 1
- %exitcond = icmp eq i32 %add10, %J
- br i1 %exitcond, label %for.latch, label %for.inner
-
-for.end:
- ret void
-}
-
-
-
-; CHECK-LABEL: test8
-; Same as test7 with an extra outer loop nest
-; CHECK: for.outest:
-; CHECK: br label %for.outer
-; CHECK: for.outer:
-; CHECK: %i = phi i32 [ %add.3, %for.latch ], [ 0, %for.outest.new ]
-; CHECK: %niter = phi i32 [ %unroll_iter, %for.outest.new ], [ %niter.nsub.3, %for.latch ]
-; CHECK: br label %for.inner
-; CHECK: for.inner:
-; CHECK: %sum = phi i32 [ 0, %for.outer ], [ %add9, %for.inner ]
-; CHECK: %j = phi i32 [ 0, %for.outer ], [ %add10, %for.inner ]
-; CHECK: %sum.1 = phi i32 [ 0, %for.outer ], [ %add9.1, %for.inner ]
-; CHECK: %j.1 = phi i32 [ 0, %for.outer ], [ %add10.1, %for.inner ]
-; CHECK: %sum.2 = phi i32 [ 0, %for.outer ], [ %add9.2, %for.inner ]
-; CHECK: %j.2 = phi i32 [ 0, %for.outer ], [ %add10.2, %for.inner ]
-; CHECK: %sum.3 = phi i32 [ 0, %for.outer ], [ %add9.3, %for.inner ]
-; CHECK: %j.3 = phi i32 [ 0, %for.outer ], [ %add10.3, %for.inner ]
-; CHECK: br i1 %exitcond.3, label %for.latch, label %for.inner
-; CHECK: for.latch:
-; CHECK: %add9.lcssa = phi i32 [ %add9, %for.inner ]
-; CHECK: %add9.lcssa.1 = phi i32 [ %add9.1, %for.inner ]
-; CHECK: %add9.lcssa.2 = phi i32 [ %add9.2, %for.inner ]
-; CHECK: %add9.lcssa.3 = phi i32 [ %add9.3, %for.inner ]
-; CHECK: br i1 %niter.ncmp.3, label %for.cleanup.unr-lcssa.loopexit, label %for.outer
-; CHECK: for.cleanup.epilog-lcssa:
-; CHECK: br label %for.cleanup
-; CHECK: for.cleanup:
-; CHECK: br i1 %exitcond41, label %for.end.loopexit, label %for.outest
-; CHECK: for.end.loopexit:
-; CHECK: br label %for.end
-define void @test8(i32 %I, i32 %J, i32* noalias nocapture %A, i32* noalias nocapture readonly %B) #0 {
-entry:
- %cmp = icmp eq i32 %J, 0
- %cmp336 = icmp eq i32 %I, 0
- %or.cond = or i1 %cmp, %cmp336
- br i1 %or.cond, label %for.end, label %for.preheader
-
-for.preheader:
- br label %for.outest
-
-for.outest:
- %x.038 = phi i32 [ %inc, %for.cleanup ], [ 0, %for.preheader ]
- br label %for.outer
-
-for.outer:
- %i = phi i32 [ %add, %for.latch ], [ 0, %for.outest ]
- %arrayidx = getelementptr inbounds i32, i32* %A, i32 %i
- store i32 0, i32* %arrayidx, align 4, !tbaa !5
- %add = add nuw i32 %i, 1
- %arrayidx6 = getelementptr inbounds i32, i32* %A, i32 %add
- store i32 2, i32* %arrayidx6, align 4, !tbaa !5
- br label %for.inner
-
-for.inner:
- %sum = phi i32 [ 0, %for.outer ], [ %add9, %for.inner ]
- %j = phi i32 [ 0, %for.outer ], [ %add10, %for.inner ]
- %arrayidx11 = getelementptr inbounds i32, i32* %B, i32 %j
- %l1 = load i32, i32* %arrayidx11, align 4, !tbaa !5
- %add9 = add i32 %l1, %sum
- %add10 = add nuw i32 %j, 1
- %exitcond = icmp eq i32 %add10, %J
- br i1 %exitcond, label %for.latch, label %for.inner
-
-for.latch:
- store i32 %add9, i32* %arrayidx, align 4, !tbaa !5
- %exitcond39 = icmp eq i32 %add, %I
- br i1 %exitcond39, label %for.cleanup, label %for.outer
-
-for.cleanup:
- %inc = add nuw nsw i32 %x.038, 1
- %exitcond41 = icmp eq i32 %inc, 5
- br i1 %exitcond41, label %for.end, label %for.outest
-
-
-for.end:
- ret void
-}
-
-; CHECK-LABEL: test9
-; Same as test1 with tbaa, not noalias
-; CHECK: for.outer:
-; CHECK: %i.us = phi i32 [ %add8.us.3, %for.latch ], [ 0, %for.outer.preheader.new ]
-; CHECK: %niter = phi i32 [ %unroll_iter, %for.outer.preheader.new ], [ %niter.nsub.3, %for.latch ]
-; CHECK: br label %for.inner
-; CHECK: for.inner:
-; CHECK: %j.us = phi i32 [ 0, %for.outer ], [ %inc.us, %for.inner ]
-; CHECK: %sum1.us = phi i32 [ 0, %for.outer ], [ %add.us, %for.inner ]
-; CHECK: %j.us.1 = phi i32 [ 0, %for.outer ], [ %inc.us.1, %for.inner ]
-; CHECK: %sum1.us.1 = phi i32 [ 0, %for.outer ], [ %add.us.1, %for.inner ]
-; CHECK: %j.us.2 = phi i32 [ 0, %for.outer ], [ %inc.us.2, %for.inner ]
-; CHECK: %sum1.us.2 = phi i32 [ 0, %for.outer ], [ %add.us.2, %for.inner ]
-; CHECK: %j.us.3 = phi i32 [ 0, %for.outer ], [ %inc.us.3, %for.inner ]
-; CHECK: %sum1.us.3 = phi i32 [ 0, %for.outer ], [ %add.us.3, %for.inner ]
-; CHECK: br i1 %exitcond.3, label %for.latch, label %for.inner
-; CHECK: for.latch:
-; CHECK: %add.us.lcssa = phi i32 [ %add.us, %for.inner ]
-; CHECK: %add.us.lcssa.1 = phi i32 [ %add.us.1, %for.inner ]
-; CHECK: %add.us.lcssa.2 = phi i32 [ %add.us.2, %for.inner ]
-; CHECK: %add.us.lcssa.3 = phi i32 [ %add.us.3, %for.inner ]
-; CHECK: br i1 %niter.ncmp.3, label %for.end.loopexit.unr-lcssa.loopexit, label %for.outer
-; CHECK: for.end.loopexit.unr-lcssa.loopexit:
-define void @test9(i32 %I, i32 %J, i32* nocapture %A, i16* nocapture readonly %B) #0 {
-entry:
- %cmp = icmp ne i32 %J, 0
- %cmp122 = icmp ne i32 %I, 0
- %or.cond = and i1 %cmp, %cmp122
- br i1 %or.cond, label %for.outer.preheader, label %for.end
-
-for.outer.preheader:
- br label %for.outer
-
-for.outer:
- %i.us = phi i32 [ %add8.us, %for.latch ], [ 0, %for.outer.preheader ]
- br label %for.inner
-
-for.inner:
- %j.us = phi i32 [ 0, %for.outer ], [ %inc.us, %for.inner ]
- %sum1.us = phi i32 [ 0, %for.outer ], [ %add.us, %for.inner ]
- %arrayidx.us = getelementptr inbounds i16, i16* %B, i32 %j.us
- %0 = load i16, i16* %arrayidx.us, align 4, !tbaa !9
- %sext = sext i16 %0 to i32
- %add.us = add i32 %sext, %sum1.us
- %inc.us = add nuw i32 %j.us, 1
- %exitcond = icmp eq i32 %inc.us, %J
- br i1 %exitcond, label %for.latch, label %for.inner
-
-for.latch:
- %add.us.lcssa = phi i32 [ %add.us, %for.inner ]
- %arrayidx6.us = getelementptr inbounds i32, i32* %A, i32 %i.us
- store i32 %add.us.lcssa, i32* %arrayidx6.us, align 4, !tbaa !5
- %add8.us = add nuw i32 %i.us, 1
- %exitcond25 = icmp eq i32 %add8.us, %I
- br i1 %exitcond25, label %for.end.loopexit, label %for.outer
-
-for.end.loopexit:
- br label %for.end
-
-for.end:
- ret void
-}
-
-
-
-; CHECK-LABEL: test10
-; Be careful not to incorrectly update the exit phi nodes
-; CHECK: %dec19.lcssa.lcssa.lcssa.ph.ph = phi i64 [ 0, %for.inc24 ]
-%struct.a = type { i64 }
-@g = common global %struct.a zeroinitializer, align 8
-@c = common global [1 x i8] zeroinitializer, align 1
-; Function Attrs: noinline norecurse nounwind uwtable
-define signext i16 @test10(i32 %k) #0 {
-entry:
- %0 = load i8, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @c, i64 0, i64 0), align 1
- %tobool9 = icmp eq i8 %0, 0
- %tobool13 = icmp ne i32 %k, 0
- br label %for.body
-
-for.body: ; preds = %entry, %for.inc24
- %storemerge82 = phi i64 [ 0, %entry ], [ %inc25, %for.inc24 ]
- br label %for.body2
-
-for.body2: ; preds = %for.body, %for.inc21
- %storemerge2881 = phi i64 [ 4, %for.body ], [ %dec22, %for.inc21 ]
- br i1 %tobool9, label %for.body2.split, label %for.body2.split.us
-
-for.body2.split.us: ; preds = %for.body2
- br i1 %tobool13, label %for.inc21, label %for.inc21.loopexit83
-
-for.body2.split: ; preds = %for.body2
- br i1 %tobool13, label %for.inc21, label %for.inc21.loopexit85
-
-for.inc21.loopexit83: ; preds = %for.body2.split.us
- %storemerge31.us37.lcssa.lcssa = phi i64 [ 0, %for.body2.split.us ]
- br label %for.inc21
-
-for.inc21.loopexit85: ; preds = %for.body2.split
- %storemerge31.lcssa.lcssa87 = phi i64 [ 0, %for.body2.split ]
- %storemerge30.lcssa.lcssa86 = phi i32 [ 0, %for.body2.split ]
- br label %for.inc21
-
-for.inc21: ; preds = %for.body2.split, %for.body2.split.us, %for.inc21.loopexit85, %for.inc21.loopexit83
- %storemerge31.lcssa.lcssa = phi i64 [ %storemerge31.us37.lcssa.lcssa, %for.inc21.loopexit83 ], [ %storemerge31.lcssa.lcssa87, %for.inc21.loopexit85 ], [ 4, %for.body2.split.us ], [ 4, %for.body2.split ]
- %storemerge30.lcssa.lcssa = phi i32 [ 0, %for.inc21.loopexit83 ], [ %storemerge30.lcssa.lcssa86, %for.inc21.loopexit85 ], [ 0, %for.body2.split.us ], [ 0, %for.body2.split ]
- %dec22 = add nsw i64 %storemerge2881, -1
- %tobool = icmp eq i64 %dec22, 0
- br i1 %tobool, label %for.inc24, label %for.body2
-
-for.inc24: ; preds = %for.inc21
- %storemerge31.lcssa.lcssa.lcssa = phi i64 [ %storemerge31.lcssa.lcssa, %for.inc21 ]
- %storemerge30.lcssa.lcssa.lcssa = phi i32 [ %storemerge30.lcssa.lcssa, %for.inc21 ]
- %inc25 = add nuw nsw i64 %storemerge82, 1
- %exitcond = icmp ne i64 %inc25, 5
- br i1 %exitcond, label %for.body, label %for.end26
-
-for.end26: ; preds = %for.inc24
- %dec19.lcssa.lcssa.lcssa = phi i64 [ 0, %for.inc24 ]
- %storemerge31.lcssa.lcssa.lcssa.lcssa = phi i64 [ %storemerge31.lcssa.lcssa.lcssa, %for.inc24 ]
- %storemerge30.lcssa.lcssa.lcssa.lcssa = phi i32 [ %storemerge30.lcssa.lcssa.lcssa, %for.inc24 ]
- store i64 %dec19.lcssa.lcssa.lcssa, i64* getelementptr inbounds (%struct.a, %struct.a* @g, i64 0, i32 0), align 8
- ret i16 0
-}
-
-
-attributes #0 = { "target-cpu"="cortex-m33" }
-
-!5 = !{!6, !6, i64 0}
-!6 = !{!"int", !7, i64 0}
-!7 = !{!"omnipotent char", !8, i64 0}
-!8 = !{!"Simple C/C++ TBAA"}
-!9 = !{!10, !10, i64 0}
-!10 = !{!"short", !7, i64 0}
OSDN Git Service
