2004-04-18 13:20:17 +08:00
|
|
|
//===-- LoopUnroll.cpp - Loop unroller pass -------------------------------===//
|
2005-04-22 07:48:37 +08:00
|
|
|
//
|
2004-04-18 13:20:17 +08:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-30 04:36:04 +08:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2005-04-22 07:48:37 +08:00
|
|
|
//
|
2004-04-18 13:20:17 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This pass implements a simple loop unroller. It works best when loops have
|
|
|
|
// been canonicalized by the -indvars pass, allowing it to determine the trip
|
|
|
|
// counts of loops easily.
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "llvm/Transforms/Scalar.h"
|
2014-09-07 20:44:26 +08:00
|
|
|
#include "llvm/Analysis/AssumptionTracker.h"
|
2011-01-02 15:35:53 +08:00
|
|
|
#include "llvm/Analysis/CodeMetrics.h"
|
2014-09-18 08:34:14 +08:00
|
|
|
#include "llvm/Analysis/FunctionTargetTransformInfo.h"
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/Analysis/LoopPass.h"
|
2010-07-27 02:11:16 +08:00
|
|
|
#include "llvm/Analysis/ScalarEvolution.h"
|
2013-01-21 21:04:33 +08:00
|
|
|
#include "llvm/Analysis/TargetTransformInfo.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/DataLayout.h"
|
2014-06-17 07:53:02 +08:00
|
|
|
#include "llvm/IR/DiagnosticInfo.h"
|
2014-01-13 17:26:24 +08:00
|
|
|
#include "llvm/IR/Dominators.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/IntrinsicInst.h"
|
2014-06-17 07:53:02 +08:00
|
|
|
#include "llvm/IR/Metadata.h"
|
2004-09-02 06:55:40 +08:00
|
|
|
#include "llvm/Support/CommandLine.h"
|
|
|
|
#include "llvm/Support/Debug.h"
|
2009-07-25 08:23:56 +08:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2008-05-14 08:24:14 +08:00
|
|
|
#include "llvm/Transforms/Utils/UnrollLoop.h"
|
2008-05-16 17:30:00 +08:00
|
|
|
#include <climits>
|
2004-04-18 13:20:17 +08:00
|
|
|
|
2008-05-14 08:24:14 +08:00
|
|
|
using namespace llvm;
|
2004-04-18 13:20:17 +08:00
|
|
|
|
2014-04-22 10:55:47 +08:00
|
|
|
#define DEBUG_TYPE "loop-unroll"
|
|
|
|
|
2008-05-13 08:00:25 +08:00
|
|
|
static cl::opt<unsigned>
|
2010-09-11 01:57:00 +08:00
|
|
|
UnrollThreshold("unroll-threshold", cl::init(150), cl::Hidden,
|
2008-05-13 08:00:25 +08:00
|
|
|
cl::desc("The cut-off point for automatic loop unrolling"));
|
2007-05-12 04:53:41 +08:00
|
|
|
|
2008-05-13 08:00:25 +08:00
|
|
|
static cl::opt<unsigned>
|
|
|
|
UnrollCount("unroll-count", cl::init(0), cl::Hidden,
|
2014-06-17 07:53:02 +08:00
|
|
|
cl::desc("Use this unroll count for all loops including those with "
|
|
|
|
"unroll_count pragma values, for testing purposes"));
|
2004-04-18 13:20:17 +08:00
|
|
|
|
2008-07-29 21:21:23 +08:00
|
|
|
static cl::opt<bool>
|
|
|
|
UnrollAllowPartial("unroll-allow-partial", cl::init(false), cl::Hidden,
|
|
|
|
cl::desc("Allows loops to be partially unrolled until "
|
|
|
|
"-unroll-threshold loop size is reached."));
|
|
|
|
|
2011-12-09 14:19:40 +08:00
|
|
|
static cl::opt<bool>
|
|
|
|
UnrollRuntime("unroll-runtime", cl::ZeroOrMore, cl::init(false), cl::Hidden,
|
|
|
|
cl::desc("Unroll loops with run-time trip counts"));
|
|
|
|
|
2014-06-17 07:53:02 +08:00
|
|
|
static cl::opt<unsigned>
|
|
|
|
PragmaUnrollThreshold("pragma-unroll-threshold", cl::init(16 * 1024), cl::Hidden,
|
2014-07-24 01:31:37 +08:00
|
|
|
cl::desc("Unrolled size limit for loops with an unroll(full) or "
|
2014-06-17 07:53:02 +08:00
|
|
|
"unroll_count pragma."));
|
|
|
|
|
2008-05-13 08:00:25 +08:00
|
|
|
namespace {
|
2009-09-02 14:11:42 +08:00
|
|
|
class LoopUnroll : public LoopPass {
|
2004-04-18 13:20:17 +08:00
|
|
|
public:
|
2007-05-03 09:11:54 +08:00
|
|
|
static char ID; // Pass ID, replacement for typeid
|
2013-11-05 08:08:03 +08:00
|
|
|
LoopUnroll(int T = -1, int C = -1, int P = -1, int R = -1) : LoopPass(ID) {
|
2011-04-14 10:27:25 +08:00
|
|
|
CurrentThreshold = (T == -1) ? UnrollThreshold : unsigned(T);
|
|
|
|
CurrentCount = (C == -1) ? UnrollCount : unsigned(C);
|
2011-04-14 00:15:29 +08:00
|
|
|
CurrentAllowPartial = (P == -1) ? UnrollAllowPartial : (bool)P;
|
2013-11-05 08:08:03 +08:00
|
|
|
CurrentRuntime = (R == -1) ? UnrollRuntime : (bool)R;
|
2011-04-14 00:15:29 +08:00
|
|
|
|
|
|
|
UserThreshold = (T != -1) || (UnrollThreshold.getNumOccurrences() > 0);
|
2013-09-12 03:25:43 +08:00
|
|
|
UserAllowPartial = (P != -1) ||
|
|
|
|
(UnrollAllowPartial.getNumOccurrences() > 0);
|
2013-11-05 08:08:03 +08:00
|
|
|
UserRuntime = (R != -1) || (UnrollRuntime.getNumOccurrences() > 0);
|
2013-09-12 03:25:43 +08:00
|
|
|
UserCount = (C != -1) || (UnrollCount.getNumOccurrences() > 0);
|
2011-07-23 08:29:16 +08:00
|
|
|
|
2010-10-20 01:21:58 +08:00
|
|
|
initializeLoopUnrollPass(*PassRegistry::getPassRegistry());
|
|
|
|
}
|
2007-05-02 05:15:47 +08:00
|
|
|
|
2007-05-12 04:53:41 +08:00
|
|
|
/// A magic value for use with the Threshold parameter to indicate
|
|
|
|
/// that the loop unroll should be performed regardless of how much
|
|
|
|
/// code expansion would result.
|
|
|
|
static const unsigned NoThreshold = UINT_MAX;
|
2011-07-23 08:29:16 +08:00
|
|
|
|
2010-09-08 07:15:30 +08:00
|
|
|
// Threshold to use when optsize is specified (and there is no
|
|
|
|
// explicit -unroll-threshold).
|
|
|
|
static const unsigned OptSizeUnrollThreshold = 50;
|
2011-07-23 08:29:16 +08:00
|
|
|
|
2011-12-09 14:19:40 +08:00
|
|
|
// Default unroll count for loops with run-time trip count if
|
|
|
|
// -unroll-count is not set
|
|
|
|
static const unsigned UnrollRuntimeCount = 8;
|
|
|
|
|
2011-04-14 00:15:29 +08:00
|
|
|
unsigned CurrentCount;
|
2010-09-08 07:15:30 +08:00
|
|
|
unsigned CurrentThreshold;
|
2011-04-14 00:15:29 +08:00
|
|
|
bool CurrentAllowPartial;
|
2013-11-05 08:08:03 +08:00
|
|
|
bool CurrentRuntime;
|
2013-09-12 03:25:43 +08:00
|
|
|
bool UserCount; // CurrentCount is user-specified.
|
2011-04-14 00:15:29 +08:00
|
|
|
bool UserThreshold; // CurrentThreshold is user-specified.
|
2013-09-12 03:25:43 +08:00
|
|
|
bool UserAllowPartial; // CurrentAllowPartial is user-specified.
|
2013-11-05 08:08:03 +08:00
|
|
|
bool UserRuntime; // CurrentRuntime is user-specified.
|
2007-05-12 04:53:41 +08:00
|
|
|
|
2014-03-05 17:10:37 +08:00
|
|
|
bool runOnLoop(Loop *L, LPPassManager &LPM) override;
|
2004-04-18 13:20:17 +08:00
|
|
|
|
|
|
|
/// This transformation requires natural loop information & requires that
|
|
|
|
/// loop preheaders be inserted into the CFG...
|
|
|
|
///
|
2014-03-05 17:10:37 +08:00
|
|
|
void getAnalysisUsage(AnalysisUsage &AU) const override {
|
2014-09-07 20:44:26 +08:00
|
|
|
AU.addRequired<AssumptionTracker>();
|
2010-07-27 02:11:16 +08:00
|
|
|
AU.addRequired<LoopInfo>();
|
|
|
|
AU.addPreserved<LoopInfo>();
|
2004-04-18 13:20:17 +08:00
|
|
|
AU.addRequiredID(LoopSimplifyID);
|
2010-07-27 02:11:16 +08:00
|
|
|
AU.addPreservedID(LoopSimplifyID);
|
2006-08-25 05:28:19 +08:00
|
|
|
AU.addRequiredID(LCSSAID);
|
|
|
|
AU.addPreservedID(LCSSAID);
|
2011-08-10 12:29:49 +08:00
|
|
|
AU.addRequired<ScalarEvolution>();
|
2010-08-30 01:21:35 +08:00
|
|
|
AU.addPreserved<ScalarEvolution>();
|
2013-01-21 21:04:33 +08:00
|
|
|
AU.addRequired<TargetTransformInfo>();
|
2014-09-18 08:34:14 +08:00
|
|
|
AU.addRequired<FunctionTargetTransformInfo>();
|
2008-07-03 15:04:22 +08:00
|
|
|
// FIXME: Loop unroll requires LCSSA. And LCSSA requires dom info.
|
|
|
|
// If loop unroll does not preserve dom info then LCSSA pass on next
|
|
|
|
// loop will receive invalid dom info.
|
|
|
|
// For now, recreate dom info, if loop is unrolled.
|
2014-01-13 21:07:17 +08:00
|
|
|
AU.addPreserved<DominatorTreeWrapperPass>();
|
2004-04-18 13:20:17 +08:00
|
|
|
}
|
2014-06-17 07:53:02 +08:00
|
|
|
|
|
|
|
// Fill in the UnrollingPreferences parameter with values from the
|
|
|
|
// TargetTransformationInfo.
|
2014-09-18 08:34:14 +08:00
|
|
|
void getUnrollingPreferences(Loop *L, const FunctionTargetTransformInfo &FTTI,
|
2014-06-17 07:53:02 +08:00
|
|
|
TargetTransformInfo::UnrollingPreferences &UP) {
|
|
|
|
UP.Threshold = CurrentThreshold;
|
|
|
|
UP.OptSizeThreshold = OptSizeUnrollThreshold;
|
|
|
|
UP.PartialThreshold = CurrentThreshold;
|
|
|
|
UP.PartialOptSizeThreshold = OptSizeUnrollThreshold;
|
|
|
|
UP.Count = CurrentCount;
|
|
|
|
UP.MaxCount = UINT_MAX;
|
|
|
|
UP.Partial = CurrentAllowPartial;
|
|
|
|
UP.Runtime = CurrentRuntime;
|
2014-09-18 08:34:14 +08:00
|
|
|
FTTI.getUnrollingPreferences(L, UP);
|
2014-06-17 07:53:02 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Select and return an unroll count based on parameters from
|
|
|
|
// user, unroll preferences, unroll pragmas, or a heuristic.
|
|
|
|
// SetExplicitly is set to true if the unroll count is is set by
|
|
|
|
// the user or a pragma rather than selected heuristically.
|
|
|
|
unsigned
|
2014-07-24 01:31:37 +08:00
|
|
|
selectUnrollCount(const Loop *L, unsigned TripCount, bool PragmaFullUnroll,
|
2014-06-17 07:53:02 +08:00
|
|
|
unsigned PragmaCount,
|
|
|
|
const TargetTransformInfo::UnrollingPreferences &UP,
|
|
|
|
bool &SetExplicitly);
|
|
|
|
|
|
|
|
// Select threshold values used to limit unrolling based on a
|
|
|
|
// total unrolled size. Parameters Threshold and PartialThreshold
|
|
|
|
// are set to the maximum unrolled size for fully and partially
|
|
|
|
// unrolled loops respectively.
|
|
|
|
void selectThresholds(const Loop *L, bool HasPragma,
|
|
|
|
const TargetTransformInfo::UnrollingPreferences &UP,
|
|
|
|
unsigned &Threshold, unsigned &PartialThreshold) {
|
|
|
|
// Determine the current unrolling threshold. While this is
|
|
|
|
// normally set from UnrollThreshold, it is overridden to a
|
|
|
|
// smaller value if the current function is marked as
|
|
|
|
// optimize-for-size, and the unroll threshold was not user
|
|
|
|
// specified.
|
|
|
|
Threshold = UserThreshold ? CurrentThreshold : UP.Threshold;
|
|
|
|
PartialThreshold = UserThreshold ? CurrentThreshold : UP.PartialThreshold;
|
|
|
|
if (!UserThreshold &&
|
|
|
|
L->getHeader()->getParent()->getAttributes().
|
|
|
|
hasAttribute(AttributeSet::FunctionIndex,
|
|
|
|
Attribute::OptimizeForSize)) {
|
|
|
|
Threshold = UP.OptSizeThreshold;
|
|
|
|
PartialThreshold = UP.PartialOptSizeThreshold;
|
|
|
|
}
|
|
|
|
if (HasPragma) {
|
|
|
|
// If the loop has an unrolling pragma, we want to be more
|
|
|
|
// aggressive with unrolling limits. Set thresholds to at
|
|
|
|
// least the PragmaTheshold value which is larger than the
|
|
|
|
// default limits.
|
|
|
|
if (Threshold != NoThreshold)
|
|
|
|
Threshold = std::max<unsigned>(Threshold, PragmaUnrollThreshold);
|
|
|
|
if (PartialThreshold != NoThreshold)
|
|
|
|
PartialThreshold =
|
|
|
|
std::max<unsigned>(PartialThreshold, PragmaUnrollThreshold);
|
|
|
|
}
|
|
|
|
}
|
2004-04-18 13:20:17 +08:00
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2008-05-13 08:00:25 +08:00
|
|
|
char LoopUnroll::ID = 0;
|
2010-10-13 03:48:12 +08:00
|
|
|
INITIALIZE_PASS_BEGIN(LoopUnroll, "loop-unroll", "Unroll loops", false, false)
|
2013-01-21 21:04:33 +08:00
|
|
|
INITIALIZE_AG_DEPENDENCY(TargetTransformInfo)
|
2014-09-07 20:44:26 +08:00
|
|
|
INITIALIZE_PASS_DEPENDENCY(AssumptionTracker)
|
2014-09-18 08:34:14 +08:00
|
|
|
INITIALIZE_PASS_DEPENDENCY(FunctionTargetTransformInfo)
|
2010-10-13 03:48:12 +08:00
|
|
|
INITIALIZE_PASS_DEPENDENCY(LoopInfo)
|
|
|
|
INITIALIZE_PASS_DEPENDENCY(LoopSimplify)
|
|
|
|
INITIALIZE_PASS_DEPENDENCY(LCSSA)
|
2011-10-20 07:56:07 +08:00
|
|
|
INITIALIZE_PASS_DEPENDENCY(ScalarEvolution)
|
2010-10-13 03:48:12 +08:00
|
|
|
INITIALIZE_PASS_END(LoopUnroll, "loop-unroll", "Unroll loops", false, false)
|
2008-05-13 08:00:25 +08:00
|
|
|
|
2013-11-05 08:08:03 +08:00
|
|
|
Pass *llvm::createLoopUnrollPass(int Threshold, int Count, int AllowPartial,
|
|
|
|
int Runtime) {
|
|
|
|
return new LoopUnroll(Threshold, Count, AllowPartial, Runtime);
|
2011-04-14 00:15:29 +08:00
|
|
|
}
|
2004-04-18 13:20:17 +08:00
|
|
|
|
2014-04-01 07:23:51 +08:00
|
|
|
Pass *llvm::createSimpleLoopUnrollPass() {
|
|
|
|
return llvm::createLoopUnrollPass(-1, -1, 0, 0);
|
|
|
|
}
|
|
|
|
|
2007-05-08 23:14:19 +08:00
|
|
|
/// ApproximateLoopSize - Approximate the size of the loop.
|
2011-10-01 09:39:05 +08:00
|
|
|
static unsigned ApproximateLoopSize(const Loop *L, unsigned &NumCalls,
|
2013-01-21 21:04:33 +08:00
|
|
|
bool &NotDuplicatable,
|
2014-09-07 21:49:57 +08:00
|
|
|
const TargetTransformInfo &TTI,
|
|
|
|
AssumptionTracker *AT) {
|
|
|
|
SmallPtrSet<const Value *, 32> EphValues;
|
|
|
|
CodeMetrics::collectEphemeralValues(L, AT, EphValues);
|
|
|
|
|
2009-10-31 22:54:17 +08:00
|
|
|
CodeMetrics Metrics;
|
2008-06-23 04:18:58 +08:00
|
|
|
for (Loop::block_iterator I = L->block_begin(), E = L->block_end();
|
2009-10-31 22:54:17 +08:00
|
|
|
I != E; ++I)
|
2014-09-07 21:49:57 +08:00
|
|
|
Metrics.analyzeBasicBlock(*I, TTI, EphValues);
|
2010-09-10 04:32:23 +08:00
|
|
|
NumCalls = Metrics.NumInlineCandidates;
|
2012-12-21 00:04:27 +08:00
|
|
|
NotDuplicatable = Metrics.notDuplicatable;
|
2011-07-23 08:29:16 +08:00
|
|
|
|
2010-09-10 03:07:31 +08:00
|
|
|
unsigned LoopSize = Metrics.NumInsts;
|
2011-07-23 08:29:16 +08:00
|
|
|
|
2010-09-10 03:07:31 +08:00
|
|
|
// Don't allow an estimate of size zero. This would allows unrolling of loops
|
|
|
|
// with huge iteration counts, which is a compile time problem even if it's
|
|
|
|
// not a problem for code quality.
|
|
|
|
if (LoopSize == 0) LoopSize = 1;
|
2011-07-23 08:29:16 +08:00
|
|
|
|
2010-09-10 03:07:31 +08:00
|
|
|
return LoopSize;
|
2004-04-18 13:20:17 +08:00
|
|
|
}
|
|
|
|
|
2014-07-24 01:31:37 +08:00
|
|
|
// 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.
|
2014-09-04 05:04:12 +08:00
|
|
|
static const MDNode *GetUnrollMetadata(const Loop *L, StringRef Name) {
|
2014-06-17 07:53:02 +08:00
|
|
|
MDNode *LoopID = L->getLoopID();
|
2014-07-24 01:31:37 +08:00
|
|
|
if (!LoopID)
|
|
|
|
return nullptr;
|
2014-06-17 07:53:02 +08:00
|
|
|
|
|
|
|
// 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) {
|
|
|
|
const MDNode *MD = dyn_cast<MDNode>(LoopID->getOperand(i));
|
2014-07-24 01:31:37 +08:00
|
|
|
if (!MD)
|
|
|
|
continue;
|
2014-06-17 07:53:02 +08:00
|
|
|
|
|
|
|
const MDString *S = dyn_cast<MDString>(MD->getOperand(0));
|
2014-07-24 01:31:37 +08:00
|
|
|
if (!S)
|
|
|
|
continue;
|
2014-06-17 07:53:02 +08:00
|
|
|
|
2014-07-24 01:31:37 +08:00
|
|
|
if (Name.equals(S->getString()))
|
|
|
|
return MD;
|
2014-06-17 07:53:02 +08:00
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2014-07-24 01:31:37 +08:00
|
|
|
// Returns true if the loop has an unroll(full) pragma.
|
|
|
|
static bool HasUnrollFullPragma(const Loop *L) {
|
|
|
|
return GetUnrollMetadata(L, "llvm.loop.unroll.full");
|
2014-06-17 07:53:02 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Returns true if the loop has an unroll(disable) pragma.
|
|
|
|
static bool HasUnrollDisablePragma(const Loop *L) {
|
2014-07-24 01:31:37 +08:00
|
|
|
return GetUnrollMetadata(L, "llvm.loop.unroll.disable");
|
2014-06-17 07:53:02 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// If loop has an unroll_count pragma return the (necessarily
|
|
|
|
// positive) value from the pragma. Otherwise return 0.
|
|
|
|
static unsigned UnrollCountPragmaValue(const Loop *L) {
|
2014-07-24 01:31:37 +08:00
|
|
|
const MDNode *MD = GetUnrollMetadata(L, "llvm.loop.unroll.count");
|
|
|
|
if (MD) {
|
|
|
|
assert(MD->getNumOperands() == 2 &&
|
|
|
|
"Unroll count hint metadata should have two operands.");
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
llvm-svn: 223802
2014-12-10 02:38:53 +08:00
|
|
|
unsigned Count =
|
|
|
|
mdconst::extract<ConstantInt>(MD->getOperand(1))->getZExtValue();
|
2014-06-17 07:53:02 +08:00
|
|
|
assert(Count >= 1 && "Unroll count must be positive.");
|
|
|
|
return Count;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-07-19 05:04:33 +08:00
|
|
|
// Remove existing unroll metadata and add unroll disable metadata to
|
|
|
|
// indicate the loop has already been unrolled. This prevents a loop
|
|
|
|
// from being unrolled more than is directed by a pragma if the loop
|
|
|
|
// unrolling pass is run more than once (which it generally is).
|
|
|
|
static void SetLoopAlreadyUnrolled(Loop *L) {
|
|
|
|
MDNode *LoopID = L->getLoopID();
|
|
|
|
if (!LoopID) return;
|
|
|
|
|
|
|
|
// First remove any existing loop unrolling metadata.
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
llvm-svn: 223802
2014-12-10 02:38:53 +08:00
|
|
|
SmallVector<Metadata *, 4> MDs;
|
2014-07-19 05:04:33 +08:00
|
|
|
// Reserve first location for self reference to the LoopID metadata node.
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
llvm-svn: 223802
2014-12-10 02:38:53 +08:00
|
|
|
MDs.push_back(nullptr);
|
2014-07-19 05:04:33 +08:00
|
|
|
for (unsigned i = 1, ie = LoopID->getNumOperands(); i < ie; ++i) {
|
|
|
|
bool IsUnrollMetadata = false;
|
|
|
|
MDNode *MD = dyn_cast<MDNode>(LoopID->getOperand(i));
|
|
|
|
if (MD) {
|
|
|
|
const MDString *S = dyn_cast<MDString>(MD->getOperand(0));
|
|
|
|
IsUnrollMetadata = S && S->getString().startswith("llvm.loop.unroll.");
|
|
|
|
}
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
llvm-svn: 223802
2014-12-10 02:38:53 +08:00
|
|
|
if (!IsUnrollMetadata)
|
|
|
|
MDs.push_back(LoopID->getOperand(i));
|
2014-07-19 05:04:33 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Add unroll(disable) metadata to disable future unrolling.
|
|
|
|
LLVMContext &Context = L->getHeader()->getContext();
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
llvm-svn: 223802
2014-12-10 02:38:53 +08:00
|
|
|
SmallVector<Metadata *, 1> DisableOperands;
|
2014-07-24 01:31:37 +08:00
|
|
|
DisableOperands.push_back(MDString::get(Context, "llvm.loop.unroll.disable"));
|
2014-07-19 05:29:41 +08:00
|
|
|
MDNode *DisableNode = MDNode::get(Context, DisableOperands);
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
llvm-svn: 223802
2014-12-10 02:38:53 +08:00
|
|
|
MDs.push_back(DisableNode);
|
2014-07-19 05:04:33 +08:00
|
|
|
|
IR: Split Metadata from Value
Split `Metadata` away from the `Value` class hierarchy, as part of
PR21532. Assembly and bitcode changes are in the wings, but this is the
bulk of the change for the IR C++ API.
I have a follow-up patch prepared for `clang`. If this breaks other
sub-projects, I apologize in advance :(. Help me compile it on Darwin
I'll try to fix it. FWIW, the errors should be easy to fix, so it may
be simpler to just fix it yourself.
This breaks the build for all metadata-related code that's out-of-tree.
Rest assured the transition is mechanical and the compiler should catch
almost all of the problems.
Here's a quick guide for updating your code:
- `Metadata` is the root of a class hierarchy with three main classes:
`MDNode`, `MDString`, and `ValueAsMetadata`. It is distinct from
the `Value` class hierarchy. It is typeless -- i.e., instances do
*not* have a `Type`.
- `MDNode`'s operands are all `Metadata *` (instead of `Value *`).
- `TrackingVH<MDNode>` and `WeakVH` referring to metadata can be
replaced with `TrackingMDNodeRef` and `TrackingMDRef`, respectively.
If you're referring solely to resolved `MDNode`s -- post graph
construction -- just use `MDNode*`.
- `MDNode` (and the rest of `Metadata`) have only limited support for
`replaceAllUsesWith()`.
As long as an `MDNode` is pointing at a forward declaration -- the
result of `MDNode::getTemporary()` -- it maintains a side map of its
uses and can RAUW itself. Once the forward declarations are fully
resolved RAUW support is dropped on the ground. This means that
uniquing collisions on changing operands cause nodes to become
"distinct". (This already happened fairly commonly, whenever an
operand went to null.)
If you're constructing complex (non self-reference) `MDNode` cycles,
you need to call `MDNode::resolveCycles()` on each node (or on a
top-level node that somehow references all of the nodes). Also,
don't do that. Metadata cycles (and the RAUW machinery needed to
construct them) are expensive.
- An `MDNode` can only refer to a `Constant` through a bridge called
`ConstantAsMetadata` (one of the subclasses of `ValueAsMetadata`).
As a side effect, accessing an operand of an `MDNode` that is known
to be, e.g., `ConstantInt`, takes three steps: first, cast from
`Metadata` to `ConstantAsMetadata`; second, extract the `Constant`;
third, cast down to `ConstantInt`.
The eventual goal is to introduce `MDInt`/`MDFloat`/etc. and have
metadata schema owners transition away from using `Constant`s when
the type isn't important (and they don't care about referring to
`GlobalValue`s).
In the meantime, I've added transitional API to the `mdconst`
namespace that matches semantics with the old code, in order to
avoid adding the error-prone three-step equivalent to every call
site. If your old code was:
MDNode *N = foo();
bar(isa <ConstantInt>(N->getOperand(0)));
baz(cast <ConstantInt>(N->getOperand(1)));
bak(cast_or_null <ConstantInt>(N->getOperand(2)));
bat(dyn_cast <ConstantInt>(N->getOperand(3)));
bay(dyn_cast_or_null<ConstantInt>(N->getOperand(4)));
you can trivially match its semantics with:
MDNode *N = foo();
bar(mdconst::hasa <ConstantInt>(N->getOperand(0)));
baz(mdconst::extract <ConstantInt>(N->getOperand(1)));
bak(mdconst::extract_or_null <ConstantInt>(N->getOperand(2)));
bat(mdconst::dyn_extract <ConstantInt>(N->getOperand(3)));
bay(mdconst::dyn_extract_or_null<ConstantInt>(N->getOperand(4)));
and when you transition your metadata schema to `MDInt`:
MDNode *N = foo();
bar(isa <MDInt>(N->getOperand(0)));
baz(cast <MDInt>(N->getOperand(1)));
bak(cast_or_null <MDInt>(N->getOperand(2)));
bat(dyn_cast <MDInt>(N->getOperand(3)));
bay(dyn_cast_or_null<MDInt>(N->getOperand(4)));
- A `CallInst` -- specifically, intrinsic instructions -- can refer to
metadata through a bridge called `MetadataAsValue`. This is a
subclass of `Value` where `getType()->isMetadataTy()`.
`MetadataAsValue` is the *only* class that can legally refer to a
`LocalAsMetadata`, which is a bridged form of non-`Constant` values
like `Argument` and `Instruction`. It can also refer to any other
`Metadata` subclass.
(I'll break all your testcases in a follow-up commit, when I propagate
this change to assembly.)
llvm-svn: 223802
2014-12-10 02:38:53 +08:00
|
|
|
MDNode *NewLoopID = MDNode::get(Context, MDs);
|
2014-07-19 05:04:33 +08:00
|
|
|
// Set operand 0 to refer to the loop id itself.
|
|
|
|
NewLoopID->replaceOperandWith(0, NewLoopID);
|
|
|
|
L->setLoopID(NewLoopID);
|
|
|
|
}
|
|
|
|
|
2014-06-17 07:53:02 +08:00
|
|
|
unsigned LoopUnroll::selectUnrollCount(
|
2014-07-24 01:31:37 +08:00
|
|
|
const Loop *L, unsigned TripCount, bool PragmaFullUnroll,
|
2014-06-17 07:53:02 +08:00
|
|
|
unsigned PragmaCount, const TargetTransformInfo::UnrollingPreferences &UP,
|
|
|
|
bool &SetExplicitly) {
|
|
|
|
SetExplicitly = true;
|
|
|
|
|
|
|
|
// User-specified count (either as a command-line option or
|
|
|
|
// constructor parameter) has highest precedence.
|
|
|
|
unsigned Count = UserCount ? CurrentCount : 0;
|
|
|
|
|
|
|
|
// If there is no user-specified count, unroll pragmas have the next
|
|
|
|
// highest precendence.
|
|
|
|
if (Count == 0) {
|
|
|
|
if (PragmaCount) {
|
|
|
|
Count = PragmaCount;
|
2014-07-24 01:31:37 +08:00
|
|
|
} else if (PragmaFullUnroll) {
|
2014-06-17 07:53:02 +08:00
|
|
|
Count = TripCount;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Count == 0)
|
|
|
|
Count = UP.Count;
|
|
|
|
|
|
|
|
if (Count == 0) {
|
|
|
|
SetExplicitly = false;
|
|
|
|
if (TripCount == 0)
|
|
|
|
// Runtime trip count.
|
|
|
|
Count = UnrollRuntimeCount;
|
|
|
|
else
|
|
|
|
// Conservative heuristic: if we know the trip count, see if we can
|
|
|
|
// completely unroll (subject to the threshold, checked below); otherwise
|
|
|
|
// try to find greatest modulo of the trip count which is still under
|
|
|
|
// threshold value.
|
|
|
|
Count = TripCount;
|
|
|
|
}
|
|
|
|
if (TripCount && Count > TripCount)
|
|
|
|
return TripCount;
|
|
|
|
return Count;
|
|
|
|
}
|
|
|
|
|
2007-03-07 09:38:05 +08:00
|
|
|
bool LoopUnroll::runOnLoop(Loop *L, LPPassManager &LPM) {
|
2014-02-06 08:07:05 +08:00
|
|
|
if (skipOptnoneFunction(L))
|
|
|
|
return false;
|
|
|
|
|
2008-05-14 08:24:14 +08:00
|
|
|
LoopInfo *LI = &getAnalysis<LoopInfo>();
|
2011-08-12 07:36:16 +08:00
|
|
|
ScalarEvolution *SE = &getAnalysis<ScalarEvolution>();
|
2013-01-21 21:04:33 +08:00
|
|
|
const TargetTransformInfo &TTI = getAnalysis<TargetTransformInfo>();
|
2014-09-18 08:34:14 +08:00
|
|
|
const FunctionTargetTransformInfo &FTTI =
|
|
|
|
getAnalysis<FunctionTargetTransformInfo>();
|
2014-09-07 20:44:26 +08:00
|
|
|
AssumptionTracker *AT = &getAnalysis<AssumptionTracker>();
|
2007-05-12 04:53:41 +08:00
|
|
|
|
2007-05-08 23:19:19 +08:00
|
|
|
BasicBlock *Header = L->getHeader();
|
2010-01-05 09:27:44 +08:00
|
|
|
DEBUG(dbgs() << "Loop Unroll: F[" << Header->getParent()->getName()
|
2009-07-25 08:23:56 +08:00
|
|
|
<< "] Loop %" << Header->getName() << "\n");
|
2011-07-23 08:29:16 +08:00
|
|
|
|
2014-06-17 07:53:02 +08:00
|
|
|
if (HasUnrollDisablePragma(L)) {
|
|
|
|
return false;
|
2014-04-02 02:50:30 +08:00
|
|
|
}
|
2014-07-24 01:31:37 +08:00
|
|
|
bool PragmaFullUnroll = HasUnrollFullPragma(L);
|
2014-06-17 07:53:02 +08:00
|
|
|
unsigned PragmaCount = UnrollCountPragmaValue(L);
|
2014-07-24 01:31:37 +08:00
|
|
|
bool HasPragma = PragmaFullUnroll || PragmaCount > 0;
|
2014-06-17 07:53:02 +08:00
|
|
|
|
|
|
|
TargetTransformInfo::UnrollingPreferences UP;
|
2014-09-18 08:34:14 +08:00
|
|
|
getUnrollingPreferences(L, FTTI, UP);
|
2004-04-18 13:20:17 +08:00
|
|
|
|
2011-08-12 07:36:16 +08:00
|
|
|
// Find trip count and trip multiple if count is not available
|
|
|
|
unsigned TripCount = 0;
|
2011-07-23 08:33:05 +08:00
|
|
|
unsigned TripMultiple = 1;
|
2014-10-11 08:12:11 +08:00
|
|
|
// If there are multiple exiting blocks but one of them is the latch, use the
|
|
|
|
// latch for the trip count estimation. Otherwise insist on a single exiting
|
|
|
|
// block for the trip count estimation.
|
|
|
|
BasicBlock *ExitingBlock = L->getLoopLatch();
|
|
|
|
if (!ExitingBlock || !L->isLoopExiting(ExitingBlock))
|
|
|
|
ExitingBlock = L->getExitingBlock();
|
|
|
|
if (ExitingBlock) {
|
|
|
|
TripCount = SE->getSmallConstantTripCount(L, ExitingBlock);
|
|
|
|
TripMultiple = SE->getSmallConstantTripMultiple(L, ExitingBlock);
|
2011-08-12 07:36:16 +08:00
|
|
|
}
|
2013-09-12 03:25:43 +08:00
|
|
|
|
2014-06-17 07:53:02 +08:00
|
|
|
// Select an initial unroll count. This may be reduced later based
|
|
|
|
// on size thresholds.
|
|
|
|
bool CountSetExplicitly;
|
2014-07-24 01:31:37 +08:00
|
|
|
unsigned Count = selectUnrollCount(L, TripCount, PragmaFullUnroll,
|
|
|
|
PragmaCount, UP, CountSetExplicitly);
|
2014-06-17 07:53:02 +08:00
|
|
|
|
|
|
|
unsigned NumInlineCandidates;
|
|
|
|
bool notDuplicatable;
|
|
|
|
unsigned LoopSize =
|
2014-09-07 21:49:57 +08:00
|
|
|
ApproximateLoopSize(L, NumInlineCandidates, notDuplicatable, TTI, AT);
|
2014-06-17 07:53:02 +08:00
|
|
|
DEBUG(dbgs() << " Loop Size = " << LoopSize << "\n");
|
|
|
|
uint64_t UnrolledSize = (uint64_t)LoopSize * Count;
|
|
|
|
if (notDuplicatable) {
|
|
|
|
DEBUG(dbgs() << " Not unrolling loop which contains non-duplicatable"
|
|
|
|
<< " instructions.\n");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
if (NumInlineCandidates != 0) {
|
|
|
|
DEBUG(dbgs() << " Not unrolling loop with inlinable calls.\n");
|
|
|
|
return false;
|
|
|
|
}
|
2011-12-09 14:19:40 +08:00
|
|
|
|
2014-06-17 07:53:02 +08:00
|
|
|
unsigned Threshold, PartialThreshold;
|
|
|
|
selectThresholds(L, HasPragma, UP, Threshold, PartialThreshold);
|
|
|
|
|
|
|
|
// Given Count, TripCount and thresholds determine the type of
|
|
|
|
// unrolling which is to be performed.
|
|
|
|
enum { Full = 0, Partial = 1, Runtime = 2 };
|
|
|
|
int Unrolling;
|
|
|
|
if (TripCount && Count == TripCount) {
|
|
|
|
if (Threshold != NoThreshold && UnrolledSize > Threshold) {
|
|
|
|
DEBUG(dbgs() << " Too large to fully unroll with count: " << Count
|
|
|
|
<< " because size: " << UnrolledSize << ">" << Threshold
|
|
|
|
<< "\n");
|
|
|
|
Unrolling = Partial;
|
|
|
|
} else {
|
|
|
|
Unrolling = Full;
|
|
|
|
}
|
|
|
|
} else if (TripCount && Count < TripCount) {
|
|
|
|
Unrolling = Partial;
|
|
|
|
} else {
|
|
|
|
Unrolling = Runtime;
|
2007-05-12 04:53:41 +08:00
|
|
|
}
|
2007-03-03 07:31:34 +08:00
|
|
|
|
2014-06-17 07:53:02 +08:00
|
|
|
// Reduce count based on the type of unrolling and the threshold values.
|
|
|
|
unsigned OriginalCount = Count;
|
|
|
|
bool AllowRuntime = UserRuntime ? CurrentRuntime : UP.Runtime;
|
|
|
|
if (Unrolling == Partial) {
|
|
|
|
bool AllowPartial = UserAllowPartial ? CurrentAllowPartial : UP.Partial;
|
|
|
|
if (!AllowPartial && !CountSetExplicitly) {
|
|
|
|
DEBUG(dbgs() << " will not try to unroll partially because "
|
|
|
|
<< "-unroll-allow-partial not given\n");
|
2012-12-21 00:04:27 +08:00
|
|
|
return false;
|
|
|
|
}
|
2014-06-17 07:53:02 +08:00
|
|
|
if (PartialThreshold != NoThreshold && UnrolledSize > PartialThreshold) {
|
|
|
|
// Reduce unroll count to be modulo of TripCount for partial unrolling.
|
|
|
|
Count = PartialThreshold / LoopSize;
|
|
|
|
while (Count != 0 && TripCount % Count != 0)
|
|
|
|
Count--;
|
|
|
|
}
|
|
|
|
} else if (Unrolling == Runtime) {
|
|
|
|
if (!AllowRuntime && !CountSetExplicitly) {
|
|
|
|
DEBUG(dbgs() << " will not try to unroll loop with runtime trip count "
|
|
|
|
<< "-unroll-runtime not given\n");
|
2010-09-10 04:02:23 +08:00
|
|
|
return false;
|
2010-02-06 07:21:31 +08:00
|
|
|
}
|
2014-06-17 07:53:02 +08:00
|
|
|
// Reduce unroll count to be the largest power-of-two factor of
|
|
|
|
// the original count which satisfies the threshold limit.
|
|
|
|
while (Count != 0 && UnrolledSize > PartialThreshold) {
|
|
|
|
Count >>= 1;
|
|
|
|
UnrolledSize = LoopSize * Count;
|
|
|
|
}
|
|
|
|
if (Count > UP.MaxCount)
|
|
|
|
Count = UP.MaxCount;
|
|
|
|
DEBUG(dbgs() << " partially unrolling with count: " << Count << "\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
if (HasPragma) {
|
2014-07-24 04:05:44 +08:00
|
|
|
if (PragmaCount != 0)
|
|
|
|
// If loop has an unroll count pragma mark loop as unrolled to prevent
|
|
|
|
// unrolling beyond that requested by the pragma.
|
|
|
|
SetLoopAlreadyUnrolled(L);
|
2014-07-19 05:04:33 +08:00
|
|
|
|
2014-06-17 07:53:02 +08:00
|
|
|
// Emit optimization remarks if we are unable to unroll the loop
|
|
|
|
// as directed by a pragma.
|
|
|
|
DebugLoc LoopLoc = L->getStartLoc();
|
|
|
|
Function *F = Header->getParent();
|
|
|
|
LLVMContext &Ctx = F->getContext();
|
2014-07-24 01:31:37 +08:00
|
|
|
if (PragmaFullUnroll && PragmaCount == 0) {
|
2014-06-17 07:53:02 +08:00
|
|
|
if (TripCount && Count != TripCount) {
|
|
|
|
emitOptimizationRemarkMissed(
|
|
|
|
Ctx, DEBUG_TYPE, *F, LoopLoc,
|
2014-07-24 01:31:37 +08:00
|
|
|
"Unable to fully unroll loop as directed by unroll(full) pragma "
|
2014-06-17 07:53:02 +08:00
|
|
|
"because unrolled size is too large.");
|
|
|
|
} else if (!TripCount) {
|
|
|
|
emitOptimizationRemarkMissed(
|
|
|
|
Ctx, DEBUG_TYPE, *F, LoopLoc,
|
2014-07-24 01:31:37 +08:00
|
|
|
"Unable to fully unroll loop as directed by unroll(full) pragma "
|
2014-06-17 07:53:02 +08:00
|
|
|
"because loop has a runtime trip count.");
|
2009-08-13 11:00:57 +08:00
|
|
|
}
|
2014-06-17 07:53:02 +08:00
|
|
|
} else if (PragmaCount > 0 && Count != OriginalCount) {
|
|
|
|
emitOptimizationRemarkMissed(
|
|
|
|
Ctx, DEBUG_TYPE, *F, LoopLoc,
|
|
|
|
"Unable to unroll loop the number of times directed by "
|
|
|
|
"unroll_count pragma because unrolled size is too large.");
|
2007-05-12 04:53:41 +08:00
|
|
|
}
|
2004-04-18 13:20:17 +08:00
|
|
|
}
|
2005-04-22 07:48:37 +08:00
|
|
|
|
2014-06-17 07:53:02 +08:00
|
|
|
if (Unrolling != Full && Count < 2) {
|
|
|
|
// Partial unrolling by 1 is a nop. For full unrolling, a factor
|
|
|
|
// of 1 makes sense because loop control can be eliminated.
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2008-05-14 08:24:14 +08:00
|
|
|
// Unroll the loop.
|
2014-09-07 20:44:26 +08:00
|
|
|
if (!UnrollLoop(L, Count, TripCount, AllowRuntime, TripMultiple, LI, this,
|
|
|
|
&LPM, AT))
|
2008-05-14 08:24:14 +08:00
|
|
|
return false;
|
2004-04-18 13:20:17 +08:00
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|