This is an archive of the discontinued LLVM Phabricator instance.

In D108314#2952915, @lebedev.ri wrote:

What is the point of creating a review if you are going to commit it immediately?
Can you not just push the change directly?
This only creates noise.

Hi Roman. I have heard and read unclear and conflicting guidance on usage of phabricator, llvm-commits, git, and arc for LLVM and how all these relate to patches intended for pre- or post-commit review. To me, having everything on phab makes sense. Additionally, use of arc requires creating a diff first, I believe and helps with the fetch+rebase+push flow, which often needs to be repeated if something else was pushed in the meantime. In cases where pre-merge builds would be useful, but review would not, creating a phab diff has the additional advantage of triggering those. Finally, following a consistent workflow helps avoid errors in constructing git commands. For these reasons, I decided that the simplest thing to do was to make my workflow the same in all cases: arc diff + arc land. I apologize if that has created additional noise for you and I am open to further suggestions, assuming there is something approaching a community consensus on how these things should be done. IMO the LLVM review and development process could use quite a bit of simplification and modernization...

Revision Contents

Path

Size

llvm/

lib/

Transforms/

Scalar/

LoopUnrollPass.cpp

310 lines

Diff 367283

llvm/lib/Transforms/Scalar/LoopUnrollPass.cpp

Show First 20 Lines • Show All 59 Lines • ▼ Show 20 Lines
#include "llvm/Transforms/Utils/LoopSimplify.h"		#include "llvm/Transforms/Utils/LoopSimplify.h"
#include "llvm/Transforms/Utils/LoopUtils.h"		#include "llvm/Transforms/Utils/LoopUtils.h"
#include "llvm/Transforms/Utils/SizeOpts.h"		#include "llvm/Transforms/Utils/SizeOpts.h"
#include "llvm/Transforms/Utils/UnrollLoop.h"		#include "llvm/Transforms/Utils/UnrollLoop.h"
#include <algorithm>		#include <algorithm>
#include <cassert>		#include <cassert>
#include <cstdint>		#include <cstdint>
#include <limits>		#include <limits>
#include <optional>
#include <string>		#include <string>
#include <tuple>		#include <tuple>
#include <utility>		#include <utility>

using namespace llvm;		using namespace llvm;

#define DEBUG_TYPE "loop-unroll"		#define DEBUG_TYPE "loop-unroll"

▲ Show 20 Lines • Show All 238 Lines • ▼ Show 20 Lines	struct EstimatedUnrollCost {
/// The estimated cost after unrolling.		/// The estimated cost after unrolling.
unsigned UnrolledCost;		unsigned UnrolledCost;

/// The estimated dynamic cost of executing the instructions in the		/// The estimated dynamic cost of executing the instructions in the
/// rolled form.		/// rolled form.
unsigned RolledDynamicCost;		unsigned RolledDynamicCost;
};		};

struct PragmaInfo {
PragmaInfo(bool UUC, bool PFU, unsigned PC, bool PEU)
: UserUnrollCount(UUC), PragmaFullUnroll(PFU), PragmaCount(PC),
PragmaEnableUnroll(PEU) {}
const bool UserUnrollCount;
const bool PragmaFullUnroll;
const unsigned PragmaCount;
const bool PragmaEnableUnroll;
};

} // end anonymous namespace		} // end anonymous namespace

/// Figure out if the loop is worth full unrolling.		/// Figure out if the loop is worth full unrolling.
///		///
/// Complete loop unrolling can make some loads constant, and we need to know		/// Complete loop unrolling can make some loads constant, and we need to know
/// if that would expose any further optimization opportunities. This routine		/// if that would expose any further optimization opportunities. This routine
/// estimates this optimization. It computes cost of unrolled loop		/// estimates this optimization. It computes cost of unrolled loop
/// (UnrolledCost) and dynamic cost of the original loop (RolledDynamicCost). By		/// (UnrolledCost) and dynamic cost of the original loop (RolledDynamicCost). By
▲ Show 20 Lines • Show All 412 Lines • ▼ Show 20 Lines
class UnrollCostEstimator {		class UnrollCostEstimator {
const unsigned LoopSize;		const unsigned LoopSize;

public:		public:
UnrollCostEstimator(Loop &L, unsigned LoopSize) : LoopSize(LoopSize) {}		UnrollCostEstimator(Loop &L, unsigned LoopSize) : LoopSize(LoopSize) {}

// Returns loop size estimation for unrolled loop, given the unrolling		// Returns loop size estimation for unrolled loop, given the unrolling
// configuration specified by UP.		// configuration specified by UP.
uint64_t		uint64_t getUnrolledLoopSize(TargetTransformInfo::UnrollingPreferences &UP) {
getUnrolledLoopSize(const TargetTransformInfo::UnrollingPreferences &UP,
const unsigned CountOverwrite = 0) const {
assert(LoopSize >= UP.BEInsns &&		assert(LoopSize >= UP.BEInsns &&
"LoopSize should not be less than BEInsns!");		"LoopSize should not be less than BEInsns!");
if (CountOverwrite)		return (uint64_t)(LoopSize - UP.BEInsns) * UP.Count + UP.BEInsns;
return static_cast<uint64_t>(LoopSize - UP.BEInsns) * CountOverwrite +
UP.BEInsns;
else
return static_cast<uint64_t>(LoopSize - UP.BEInsns) * UP.Count +
UP.BEInsns;
}		}
};		};

static Optional<unsigned>
shouldPragmaUnroll(Loop *L, const PragmaInfo &PInfo,
const unsigned TripMultiple, const unsigned TripCount,
const UnrollCostEstimator UCE,
const TargetTransformInfo::UnrollingPreferences &UP) {

// Using unroll pragma
// 1st priority is unroll count set by "unroll-count" option.

if (PInfo.UserUnrollCount) {
if (UP.AllowRemainder &&
UCE.getUnrolledLoopSize(UP, (unsigned)UnrollCount) < UP.Threshold)
return (unsigned)UnrollCount;
}

// 2nd priority is unroll count set by pragma.
if (PInfo.PragmaCount > 0) {
if ((UP.AllowRemainder \|\| (TripMultiple % PInfo.PragmaCount == 0)) &&
UCE.getUnrolledLoopSize(UP, PInfo.PragmaCount) < PragmaUnrollThreshold)
return PInfo.PragmaCount;
}

if (PInfo.PragmaFullUnroll && TripCount != 0) {
if (UCE.getUnrolledLoopSize(UP, TripCount) < PragmaUnrollThreshold)
return TripCount;
}
// if didn't return until here, should continue to other priorties
return None;
}

static Optional<unsigned> shouldFullUnroll(
Loop *L, const TargetTransformInfo &TTI, DominatorTree &DT,
ScalarEvolution &SE, const SmallPtrSetImpl<const Value *> &EphValues,
const unsigned FullUnrollTripCount, const UnrollCostEstimator UCE,
const TargetTransformInfo::UnrollingPreferences &UP) {

if (FullUnrollTripCount && FullUnrollTripCount <= UP.FullUnrollMaxCount) {
// When computing the unrolled size, note that BEInsns are not replicated
// like the rest of the loop body.
if (UCE.getUnrolledLoopSize(UP) < UP.Threshold) {
return FullUnrollTripCount;

} else {
// The loop isn't that small, but we still can fully unroll it if that
// helps to remove a significant number of instructions.
// To check that, run additional analysis on the loop.
if (Optional<EstimatedUnrollCost> Cost = analyzeLoopUnrollCost(
L, FullUnrollTripCount, DT, SE, EphValues, TTI,
UP.Threshold * UP.MaxPercentThresholdBoost / 100,
UP.MaxIterationsCountToAnalyze)) {
unsigned Boost =
getFullUnrollBoostingFactor(*Cost, UP.MaxPercentThresholdBoost);
if (Cost->UnrolledCost < UP.Threshold * Boost / 100) {
return FullUnrollTripCount;
}
}
}
}
return None;
}

static Optional<unsigned>
shouldPartialUnroll(const unsigned LoopSize, const unsigned TripCount,
const UnrollCostEstimator UCE,
const TargetTransformInfo::UnrollingPreferences &UP) {

unsigned count = UP.Count;
if (TripCount) {
if (!UP.Partial) {
LLVM_DEBUG(dbgs() << " will not try to unroll partially because "
<< "-unroll-allow-partial not given\n");
count = 0;
return count;
}
if (count == 0)
count = TripCount;
if (UP.PartialThreshold != NoThreshold) {
// Reduce unroll count to be modulo of TripCount for partial unrolling.
if (UCE.getUnrolledLoopSize(UP, count) > UP.PartialThreshold)
count = (std::max(UP.PartialThreshold, UP.BEInsns + 1) - UP.BEInsns) /
(LoopSize - UP.BEInsns);
if (count > UP.MaxCount)
count = UP.MaxCount;
while (count != 0 && TripCount % count != 0)
count--;
if (UP.AllowRemainder && count <= 1) {
// If there is no Count that is modulo of TripCount, set Count to
// largest power-of-two factor that satisfies the threshold limit.
// As we'll create fixup loop, do the type of unrolling only if
// remainder loop is allowed.
count = UP.DefaultUnrollRuntimeCount;
while (count != 0 &&
UCE.getUnrolledLoopSize(UP, count) > UP.PartialThreshold)
count >>= 1;
}
if (count < 2) {
count = 0;
}
} else {
count = TripCount;
}
if (count > UP.MaxCount)
count = UP.MaxCount;

LLVM_DEBUG(dbgs() << " partially unrolling with count: " << count << "\n");

return count;
}

// if didn't return until here, should continue to other priorties
return None;
}
// Returns true if unroll count was set explicitly.		// Returns true if unroll count was set explicitly.
// Calculates unroll count and writes it to UP.Count.		// Calculates unroll count and writes it to UP.Count.
// Unless IgnoreUser is true, will also use metadata and command-line options		// Unless IgnoreUser is true, will also use metadata and command-line options
// that are specific to to the LoopUnroll pass (which, for instance, are		// that are specific to to the LoopUnroll pass (which, for instance, are
// irrelevant for the LoopUnrollAndJam pass).		// irrelevant for the LoopUnrollAndJam pass).
// FIXME: This function is used by LoopUnroll and LoopUnrollAndJam, but consumes		// FIXME: This function is used by LoopUnroll and LoopUnrollAndJam, but consumes
// many LoopUnroll-specific options. The shared functionality should be		// many LoopUnroll-specific options. The shared functionality should be
// refactored into it own function.		// refactored into it own function.
bool llvm::computeUnrollCount(		bool llvm::computeUnrollCount(
Loop L, const TargetTransformInfo &TTI, DominatorTree &DT, LoopInfo LI,		Loop L, const TargetTransformInfo &TTI, DominatorTree &DT, LoopInfo LI,
ScalarEvolution &SE, const SmallPtrSetImpl<const Value *> &EphValues,		ScalarEvolution &SE, const SmallPtrSetImpl<const Value *> &EphValues,
OptimizationRemarkEmitter *ORE, unsigned TripCount, unsigned MaxTripCount,		OptimizationRemarkEmitter *ORE, unsigned TripCount, unsigned MaxTripCount,
bool MaxOrZero, unsigned TripMultiple, unsigned LoopSize,		bool MaxOrZero, unsigned TripMultiple, unsigned LoopSize,
TargetTransformInfo::UnrollingPreferences &UP,		TargetTransformInfo::UnrollingPreferences &UP,
TargetTransformInfo::PeelingPreferences &PP, bool &UseUpperBound) {		TargetTransformInfo::PeelingPreferences &PP, bool &UseUpperBound) {

UnrollCostEstimator UCE(*L, LoopSize);		UnrollCostEstimator UCE(*L, LoopSize);
Optional<unsigned> UnrollFactor;

const bool UserUnrollCount = UnrollCount.getNumOccurrences() > 0;
const bool PragmaFullUnroll = hasUnrollFullPragma(L);
const unsigned PragmaCount = unrollCountPragmaValue(L);
const bool PragmaEnableUnroll = hasUnrollEnablePragma(L);

const bool ExplicitUnroll = PragmaCount > 0 \|\| PragmaFullUnroll \|\|
PragmaEnableUnroll \|\| UserUnrollCount;

PragmaInfo PInfo(UserUnrollCount, PragmaFullUnroll, PragmaCount,
PragmaEnableUnroll);
// Use an explicit peel count that has been specified for testing. In this		// Use an explicit peel count that has been specified for testing. In this
// case it's not permitted to also specify an explicit unroll count.		// case it's not permitted to also specify an explicit unroll count.
if (PP.PeelCount) {		if (PP.PeelCount) {
if (UnrollCount.getNumOccurrences() > 0) {		if (UnrollCount.getNumOccurrences() > 0) {
report_fatal_error("Cannot specify both explicit peel count and "		report_fatal_error("Cannot specify both explicit peel count and "
"explicit unroll count");		"explicit unroll count");
}		}
UP.Count = 1;		UP.Count = 1;
UP.Runtime = false;		UP.Runtime = false;
return true;		return true;
}		}

// Check for explicit Count.		// Check for explicit Count.
// 1st priority is unroll count set by "unroll-count" option.		// 1st priority is unroll count set by "unroll-count" option.
// 2nd priority is unroll count set by pragma.		bool UserUnrollCount = UnrollCount.getNumOccurrences() > 0;
UnrollFactor = shouldPragmaUnroll(L, PInfo, TripMultiple, TripCount, UCE, UP);		if (UserUnrollCount) {
		UP.Count = UnrollCount;
if (UnrollFactor) {		UP.AllowExpensiveTripCount = true;
UP.Count = *UnrollFactor;		UP.Force = true;
		if (UP.AllowRemainder && UCE.getUnrolledLoopSize(UP) < UP.Threshold)
		return true;
		}

if (UserUnrollCount \|\| (PragmaCount > 0)) {		// 2nd priority is unroll count set by pragma.
		unsigned PragmaCount = unrollCountPragmaValue(L);
		if (PragmaCount > 0) {
		UP.Count = PragmaCount;
		UP.Runtime = true;
UP.AllowExpensiveTripCount = true;		UP.AllowExpensiveTripCount = true;
UP.Force = true;		UP.Force = true;
		if ((UP.AllowRemainder \|\| (TripMultiple % PragmaCount == 0)) &&
		UCE.getUnrolledLoopSize(UP) < PragmaUnrollThreshold)
		return true;
}		}
UP.Runtime \|= (PragmaCount > 0);		bool PragmaFullUnroll = hasUnrollFullPragma(L);
return ExplicitUnroll;		if (PragmaFullUnroll && TripCount != 0) {
} else {		UP.Count = TripCount;
		if (UCE.getUnrolledLoopSize(UP) < PragmaUnrollThreshold)
		return false;
		}

		bool PragmaEnableUnroll = hasUnrollEnablePragma(L);
		bool ExplicitUnroll = PragmaCount > 0 \|\| PragmaFullUnroll \|\|
		PragmaEnableUnroll \|\| UserUnrollCount;

if (ExplicitUnroll && TripCount != 0) {		if (ExplicitUnroll && TripCount != 0) {
// If the loop has an unrolling pragma, we want to be more aggressive with		// If the loop has an unrolling pragma, we want to be more aggressive with
// unrolling limits. Set thresholds to at least the PragmaUnrollThreshold		// unrolling limits. Set thresholds to at least the PragmaUnrollThreshold
// value which is larger than the default limits.		// value which is larger than the default limits.
UP.Threshold = std::max<unsigned>(UP.Threshold, PragmaUnrollThreshold);		UP.Threshold = std::max<unsigned>(UP.Threshold, PragmaUnrollThreshold);
UP.PartialThreshold =		UP.PartialThreshold =
std::max<unsigned>(UP.PartialThreshold, PragmaUnrollThreshold);		std::max<unsigned>(UP.PartialThreshold, PragmaUnrollThreshold);
}		}
}

// 3rd priority is full unroll count.		// 3rd priority is full unroll count.
// Full unroll makes sense only when TripCount or its upper bound could be		// Full unroll makes sense only when TripCount or its upper bound could be
// statically calculated.		// statically calculated.
// Also we need to check if we exceed FullUnrollMaxCount.		// Also we need to check if we exceed FullUnrollMaxCount.

// We can unroll by the upper bound amount if it's generally allowed or if		// We can unroll by the upper bound amount if it's generally allowed or if
// we know that the loop is executed either the upper bound or zero times.		// we know that the loop is executed either the upper bound or zero times.
Show All 12 Lines	bool llvm::computeUnrollCount(
// compute the former when the latter is zero.		// compute the former when the latter is zero.
unsigned ExactTripCount = TripCount;		unsigned ExactTripCount = TripCount;
assert((ExactTripCount == 0 \|\| FullUnrollMaxTripCount == 0) &&		assert((ExactTripCount == 0 \|\| FullUnrollMaxTripCount == 0) &&
"ExtractTripCount and UnrollByMaxCount cannot both be non zero.");		"ExtractTripCount and UnrollByMaxCount cannot both be non zero.");

unsigned FullUnrollTripCount =		unsigned FullUnrollTripCount =
ExactTripCount ? ExactTripCount : FullUnrollMaxTripCount;		ExactTripCount ? ExactTripCount : FullUnrollMaxTripCount;
UP.Count = FullUnrollTripCount;		UP.Count = FullUnrollTripCount;
		if (FullUnrollTripCount && FullUnrollTripCount <= UP.FullUnrollMaxCount) {
UnrollFactor =		// When computing the unrolled size, note that BEInsns are not replicated
shouldFullUnroll(L, TTI, DT, SE, EphValues, FullUnrollTripCount, UCE, UP);		// like the rest of the loop body.
		if (UCE.getUnrolledLoopSize(UP) < UP.Threshold) {
// if shouldFullUnroll can do the unrolling, some side parameteres should be
// set
if (UnrollFactor) {
UP.Count = *UnrollFactor;
UseUpperBound = (FullUnrollMaxTripCount == FullUnrollTripCount);		UseUpperBound = (FullUnrollMaxTripCount == FullUnrollTripCount);
TripCount = FullUnrollTripCount;
TripMultiple = UP.UpperBound ? 1 : TripMultiple;
return ExplicitUnroll;		return ExplicitUnroll;
} else {		} else {
		Lint: Pre-merge checks Inline Actions clang-tidy: warning: do not use 'else' after 'return' [llvm-else-after-return] not useful Lint: Pre-merge checks: clang-tidy: warning: do not use 'else' after 'return' [llvm-else-after-return] [[https://github.
UP.Count = FullUnrollTripCount;		// The loop isn't that small, but we still can fully unroll it if that
		// helps to remove a significant number of instructions.
		// To check that, run additional analysis on the loop.
		if (Optional<EstimatedUnrollCost> Cost = analyzeLoopUnrollCost(
		L, FullUnrollTripCount, DT, SE, EphValues, TTI,
		UP.Threshold * UP.MaxPercentThresholdBoost / 100,
		UP.MaxIterationsCountToAnalyze)) {
		unsigned Boost =
		getFullUnrollBoostingFactor(*Cost, UP.MaxPercentThresholdBoost);
		if (Cost->UnrolledCost < UP.Threshold * Boost / 100) {
		UseUpperBound = (FullUnrollMaxTripCount == FullUnrollTripCount);
		return ExplicitUnroll;
		}
		}
		}
}		}

// 4th priority is loop peeling.		// 4th priority is loop peeling.
computePeelCount(L, LoopSize, PP, TripCount, SE, UP.Threshold);		computePeelCount(L, LoopSize, PP, TripCount, SE, UP.Threshold);
if (PP.PeelCount) {		if (PP.PeelCount) {
UP.Runtime = false;		UP.Runtime = false;
UP.Count = 1;		UP.Count = 1;
return ExplicitUnroll;		return ExplicitUnroll;
}		}

// Before starting partial unrolling, set up.partial to true,
// if user explicitly asked for unrolling
if (TripCount)
UP.Partial \|= ExplicitUnroll;

// 5th priority is partial unrolling.		// 5th priority is partial unrolling.
// Try partial unroll only when TripCount could be statically calculated.		// Try partial unroll only when TripCount could be statically calculated.
UnrollFactor = shouldPartialUnroll(LoopSize, TripCount, UCE, UP);		if (TripCount) {
		UP.Partial \|= ExplicitUnroll;
if (UnrollFactor) {		if (!UP.Partial) {
UP.Count = *UnrollFactor;		LLVM_DEBUG(dbgs() << " will not try to unroll partially because "
		<< "-unroll-allow-partial not given\n");
if ((PragmaFullUnroll \|\| PragmaEnableUnroll) && TripCount &&		UP.Count = 0;
UP.Count != TripCount)		return false;
ORE->emit([&]() {		}
return OptimizationRemarkMissed(DEBUG_TYPE,		if (UP.Count == 0)
"FullUnrollAsDirectedTooLarge",		UP.Count = TripCount;
L->getStartLoc(), L->getHeader())
<< "Unable to fully unroll loop as directed by unroll pragma "
"because "
"unrolled size is too large.";
});

if (UP.PartialThreshold != NoThreshold) {		if (UP.PartialThreshold != NoThreshold) {
if (UP.Count == 0) {		// Reduce unroll count to be modulo of TripCount for partial unrolling.
		if (UCE.getUnrolledLoopSize(UP) > UP.PartialThreshold)
		UP.Count =
		(std::max(UP.PartialThreshold, UP.BEInsns + 1) - UP.BEInsns) /
		(LoopSize - UP.BEInsns);
		if (UP.Count > UP.MaxCount)
		UP.Count = UP.MaxCount;
		while (UP.Count != 0 && TripCount % UP.Count != 0)
		UP.Count--;
		if (UP.AllowRemainder && UP.Count <= 1) {
		// If there is no Count that is modulo of TripCount, set Count to
		// largest power-of-two factor that satisfies the threshold limit.
		// As we'll create fixup loop, do the type of unrolling only if
		// remainder loop is allowed.
		UP.Count = UP.DefaultUnrollRuntimeCount;
		while (UP.Count != 0 &&
		UCE.getUnrolledLoopSize(UP) > UP.PartialThreshold)
		UP.Count >>= 1;
		}
		if (UP.Count < 2) {
if (PragmaEnableUnroll)		if (PragmaEnableUnroll)
ORE->emit([&]() {		ORE->emit([&]() {
return OptimizationRemarkMissed(DEBUG_TYPE,		return OptimizationRemarkMissed(DEBUG_TYPE,
"UnrollAsDirectedTooLarge",		"UnrollAsDirectedTooLarge",
L->getStartLoc(), L->getHeader())		L->getStartLoc(), L->getHeader())
<< "Unable to unroll loop as directed by unroll(enable) "		<< "Unable to unroll loop as directed by unroll(enable) "
"pragma "		"pragma "
"because unrolled size is too large.";		"because unrolled size is too large.";
});		});
		UP.Count = 0;
}		}
		} else {
		UP.Count = TripCount;
}		}
		if (UP.Count > UP.MaxCount)
		UP.Count = UP.MaxCount;
		if ((PragmaFullUnroll \|\| PragmaEnableUnroll) && TripCount &&
		UP.Count != TripCount)
		ORE->emit([&]() {
		return OptimizationRemarkMissed(DEBUG_TYPE,
		"FullUnrollAsDirectedTooLarge",
		L->getStartLoc(), L->getHeader())
		<< "Unable to fully unroll loop as directed by unroll pragma "
		"because "
		"unrolled size is too large.";
		});
		LLVM_DEBUG(dbgs() << " partially unrolling with count: " << UP.Count
		<< "\n");
return ExplicitUnroll;		return ExplicitUnroll;
}		}
assert(TripCount == 0 &&		assert(TripCount == 0 &&
"All cases when TripCount is constant should be covered here.");		"All cases when TripCount is constant should be covered here.");
if (PragmaFullUnroll)		if (PragmaFullUnroll)
ORE->emit([&]() {		ORE->emit([&]() {
return OptimizationRemarkMissed(		return OptimizationRemarkMissed(
DEBUG_TYPE, "CantFullUnrollAsDirectedRuntimeTripCount",		DEBUG_TYPE, "CantFullUnrollAsDirectedRuntimeTripCount",
Show All 20 Lines	bool llvm::computeUnrollCount(
if (L->getHeader()->getParent()->hasProfileData()) {		if (L->getHeader()->getParent()->hasProfileData()) {
if (auto ProfileTripCount = getLoopEstimatedTripCount(L)) {		if (auto ProfileTripCount = getLoopEstimatedTripCount(L)) {
if (*ProfileTripCount < FlatLoopTripCountThreshold)		if (*ProfileTripCount < FlatLoopTripCountThreshold)
return false;		return false;
else		else
UP.AllowExpensiveTripCount = true;		UP.AllowExpensiveTripCount = true;
}		}
}		}

		// Reduce count based on the type of unrolling and the threshold values.
UP.Runtime \|= PragmaEnableUnroll \|\| PragmaCount > 0 \|\| UserUnrollCount;		UP.Runtime \|= PragmaEnableUnroll \|\| PragmaCount > 0 \|\| UserUnrollCount;
if (!UP.Runtime) {		if (!UP.Runtime) {
LLVM_DEBUG(		LLVM_DEBUG(
dbgs() << " will not try to unroll loop with runtime trip count "		dbgs() << " will not try to unroll loop with runtime trip count "
<< "-unroll-runtime not given\n");		<< "-unroll-runtime not given\n");
UP.Count = 0;		UP.Count = 0;
return false;		return false;
}		}
Show All 18 Lines	LLVM_DEBUG(
"specific or because the loop contains a convergent "		"specific or because the loop contains a convergent "
"instruction), so unroll count must divide the trip "		"instruction), so unroll count must divide the trip "
"multiple, "		"multiple, "
<< TripMultiple << ". Reducing unroll count from " << OrigCount		<< TripMultiple << ". Reducing unroll count from " << OrigCount
<< " to " << UP.Count << ".\n");		<< " to " << UP.Count << ".\n");

using namespace ore;		using namespace ore;

if (unrollCountPragmaValue(L) > 0 && !UP.AllowRemainder)		if (PragmaCount > 0 && !UP.AllowRemainder)
ORE->emit([&]() {		ORE->emit([&]() {
return OptimizationRemarkMissed(DEBUG_TYPE,		return OptimizationRemarkMissed(DEBUG_TYPE,
"DifferentUnrollCountFromDirected",		"DifferentUnrollCountFromDirected",
L->getStartLoc(), L->getHeader())		L->getStartLoc(), L->getHeader())
<< "Unable to unroll loop the number of times directed by "		<< "Unable to unroll loop the number of times directed by "
"unroll_count pragma because remainder loop is restricted "		"unroll_count pragma because remainder loop is restricted "
"(that could architecture specific or because the loop "		"(that could architecture specific or because the loop "
"contains a convergent instruction) and so must have an "		"contains a convergent instruction) and so must have an "
▲ Show 20 Lines • Show All 503 Lines • Show Last 20 Lines

This is an archive of the discontinued LLVM Phabricator instance.

Revert "[NFC] factor out unrolling decision logic"ClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 367283

llvm/lib/Transforms/Scalar/LoopUnrollPass.cpp

Revert "[NFC] factor out unrolling decision logic"
ClosedPublic