void emitRejectionRemarks(const BBPair &P, const RejectLog &Log);
// Discriminator for LLVM-style RTTI (dyn_cast<> et al.)
-enum RejectReasonKind {
+enum class RejectReasonKind {
// CFG Category
- rrkCFG,
- rrkInvalidTerminator,
- rrkCondition,
- rrkLastCFG,
- rrkIrreducibleRegion,
+ CFG,
+ InvalidTerminator,
+ Condition,
+ LastCFG,
+ IrreducibleRegion,
// Non-Affinity
- rrkAffFunc,
- rrkUndefCond,
- rrkInvalidCond,
- rrkUndefOperand,
- rrkNonAffBranch,
- rrkNoBasePtr,
- rrkUndefBasePtr,
- rrkVariantBasePtr,
- rrkNonAffineAccess,
- rrkDifferentElementSize,
- rrkLastAffFunc,
-
- rrkLoopBound,
- rrkLoopHasNoExit,
-
- rrkFuncCall,
- rrkNonSimpleMemoryAccess,
-
- rrkAlias,
+ AffFunc,
+ UndefCond,
+ InvalidCond,
+ UndefOperand,
+ NonAffBranch,
+ NoBasePtr,
+ UndefBasePtr,
+ VariantBasePtr,
+ NonAffineAccess,
+ DifferentElementSize,
+ LastAffFunc,
+
+ LoopBound,
+ LoopHasNoExit,
+
+ FuncCall,
+ NonSimpleMemoryAccess,
+
+ Alias,
// Other
- rrkOther,
- rrkIntToPtr,
- rrkAlloca,
- rrkUnknownInst,
- rrkEntry,
- rrkUnprofitable,
- rrkLastOther
+ Other,
+ IntToPtr,
+ Alloca,
+ UnknownInst,
+ Entry,
+ Unprofitable,
+ LastOther
};
//===----------------------------------------------------------------------===//
public:
ReportInvalidTerminator(BasicBlock *BB)
- : ReportCFG(rrkInvalidTerminator), BB(BB) {}
+ : ReportCFG(RejectReasonKind::InvalidTerminator), BB(BB) {}
/// @name LLVM-RTTI interface
//@{
public:
ReportIrreducibleRegion(Region *R, DebugLoc DbgLoc)
- : ReportCFG(rrkIrreducibleRegion), R(R), DbgLoc(DbgLoc) {}
+ : ReportCFG(RejectReasonKind::IrreducibleRegion), R(R), DbgLoc(DbgLoc) {}
/// @name LLVM-RTTI interface
//@{
public:
ReportUndefCond(const Instruction *Inst, BasicBlock *BB)
- : ReportAffFunc(rrkUndefCond, Inst), BB(BB) {}
+ : ReportAffFunc(RejectReasonKind::UndefCond, Inst), BB(BB) {}
/// @name LLVM-RTTI interface
//@{
public:
ReportInvalidCond(const Instruction *Inst, BasicBlock *BB)
- : ReportAffFunc(rrkInvalidCond, Inst), BB(BB) {}
+ : ReportAffFunc(RejectReasonKind::InvalidCond, Inst), BB(BB) {}
/// @name LLVM-RTTI interface
//@{
public:
ReportUndefOperand(BasicBlock *BB, const Instruction *Inst)
- : ReportAffFunc(rrkUndefOperand, Inst), BB(BB) {}
+ : ReportAffFunc(RejectReasonKind::UndefOperand, Inst), BB(BB) {}
/// @name LLVM-RTTI interface
//@{
public:
ReportNonAffBranch(BasicBlock *BB, const SCEV *LHS, const SCEV *RHS,
const Instruction *Inst)
- : ReportAffFunc(rrkNonAffBranch, Inst), BB(BB), LHS(LHS), RHS(RHS) {}
+ : ReportAffFunc(RejectReasonKind::NonAffBranch, Inst), BB(BB), LHS(LHS),
+ RHS(RHS) {}
const SCEV *lhs() { return LHS; }
const SCEV *rhs() { return RHS; }
//===--------------------------------------------------------------------===//
public:
ReportNoBasePtr(const Instruction *Inst)
- : ReportAffFunc(rrkNoBasePtr, Inst) {}
+ : ReportAffFunc(RejectReasonKind::NoBasePtr, Inst) {}
/// @name LLVM-RTTI interface
//@{
//===--------------------------------------------------------------------===//
public:
ReportUndefBasePtr(const Instruction *Inst)
- : ReportAffFunc(rrkUndefBasePtr, Inst) {}
+ : ReportAffFunc(RejectReasonKind::UndefBasePtr, Inst) {}
/// @name LLVM-RTTI interface
//@{
public:
ReportVariantBasePtr(Value *BaseValue, const Instruction *Inst)
- : ReportAffFunc(rrkVariantBasePtr, Inst), BaseValue(BaseValue) {}
+ : ReportAffFunc(RejectReasonKind::VariantBasePtr, Inst),
+ BaseValue(BaseValue) {}
/// @name LLVM-RTTI interface
//@{
public:
ReportNonAffineAccess(const SCEV *AccessFunction, const Instruction *Inst,
const Value *V)
- : ReportAffFunc(rrkNonAffineAccess, Inst), AccessFunction(AccessFunction),
- BaseValue(V) {}
+ : ReportAffFunc(RejectReasonKind::NonAffineAccess, Inst),
+ AccessFunction(AccessFunction), BaseValue(V) {}
const SCEV *get() { return AccessFunction; }
public:
ReportDifferentArrayElementSize(const Instruction *Inst, const Value *V)
- : ReportAffFunc(rrkDifferentElementSize, Inst), BaseValue(V) {}
+ : ReportAffFunc(RejectReasonKind::DifferentElementSize, Inst),
+ BaseValue(V) {}
/// @name LLVM-RTTI interface
//@{
public:
ReportLoopHasNoExit(Loop *L)
- : RejectReason(rrkLoopHasNoExit), L(L), Loc(L->getStartLoc()) {}
+ : RejectReason(RejectReasonKind::LoopHasNoExit), L(L),
+ Loc(L->getStartLoc()) {}
/// @name LLVM-RTTI interface
//@{
}
bool ReportCFG::classof(const RejectReason *RR) {
- return RR->getKind() >= rrkCFG && RR->getKind() <= rrkLastCFG;
+ return RR->getKind() >= RejectReasonKind::CFG &&
+ RR->getKind() <= RejectReasonKind::LastCFG;
}
//===----------------------------------------------------------------------===//
}
bool ReportInvalidTerminator::classof(const RejectReason *RR) {
- return RR->getKind() == rrkInvalidTerminator;
+ return RR->getKind() == RejectReasonKind::InvalidTerminator;
}
//===----------------------------------------------------------------------===//
}
bool ReportIrreducibleRegion::classof(const RejectReason *RR) {
- return RR->getKind() == rrkIrreducibleRegion;
+ return RR->getKind() == RejectReasonKind::IrreducibleRegion;
}
//===----------------------------------------------------------------------===//
}
bool ReportAffFunc::classof(const RejectReason *RR) {
- return RR->getKind() >= rrkAffFunc && RR->getKind() <= rrkLastAffFunc;
+ return RR->getKind() >= RejectReasonKind::AffFunc &&
+ RR->getKind() <= RejectReasonKind::LastAffFunc;
}
//===----------------------------------------------------------------------===//
}
bool ReportUndefCond::classof(const RejectReason *RR) {
- return RR->getKind() == rrkUndefCond;
+ return RR->getKind() == RejectReasonKind::UndefCond;
}
//===----------------------------------------------------------------------===//
}
bool ReportInvalidCond::classof(const RejectReason *RR) {
- return RR->getKind() == rrkInvalidCond;
+ return RR->getKind() == RejectReasonKind::InvalidCond;
}
//===----------------------------------------------------------------------===//
}
bool ReportUndefOperand::classof(const RejectReason *RR) {
- return RR->getKind() == rrkUndefOperand;
+ return RR->getKind() == RejectReasonKind::UndefOperand;
}
//===----------------------------------------------------------------------===//
}
bool ReportNonAffBranch::classof(const RejectReason *RR) {
- return RR->getKind() == rrkNonAffBranch;
+ return RR->getKind() == RejectReasonKind::NonAffBranch;
}
//===----------------------------------------------------------------------===//
std::string ReportNoBasePtr::getMessage() const { return "No base pointer"; }
bool ReportNoBasePtr::classof(const RejectReason *RR) {
- return RR->getKind() == rrkNoBasePtr;
+ return RR->getKind() == RejectReasonKind::NoBasePtr;
}
//===----------------------------------------------------------------------===//
}
bool ReportUndefBasePtr::classof(const RejectReason *RR) {
- return RR->getKind() == rrkUndefBasePtr;
+ return RR->getKind() == RejectReasonKind::UndefBasePtr;
}
//===----------------------------------------------------------------------===//
}
bool ReportVariantBasePtr::classof(const RejectReason *RR) {
- return RR->getKind() == rrkVariantBasePtr;
+ return RR->getKind() == RejectReasonKind::VariantBasePtr;
}
//===----------------------------------------------------------------------===//
}
bool ReportDifferentArrayElementSize::classof(const RejectReason *RR) {
- return RR->getKind() == rrkDifferentElementSize;
+ return RR->getKind() == RejectReasonKind::DifferentElementSize;
}
std::string ReportDifferentArrayElementSize::getEndUserMessage() const {
}
bool ReportNonAffineAccess::classof(const RejectReason *RR) {
- return RR->getKind() == rrkNonAffineAccess;
+ return RR->getKind() == RejectReasonKind::NonAffineAccess;
}
std::string ReportNonAffineAccess::getEndUserMessage() const {
// ReportLoopBound.
ReportLoopBound::ReportLoopBound(Loop *L, const SCEV *LoopCount)
- : RejectReason(rrkLoopBound), L(L), LoopCount(LoopCount),
+ : RejectReason(RejectReasonKind::LoopBound), L(L), LoopCount(LoopCount),
Loc(L->getStartLoc()) {
++BadLoopBoundForScop;
}
const DebugLoc &ReportLoopBound::getDebugLoc() const { return Loc; }
bool ReportLoopBound::classof(const RejectReason *RR) {
- return RR->getKind() == rrkLoopBound;
+ return RR->getKind() == RejectReasonKind::LoopBound;
}
std::string ReportLoopBound::getEndUserMessage() const {
}
bool ReportLoopHasNoExit::classof(const RejectReason *RR) {
- return RR->getKind() == rrkLoopHasNoExit;
+ return RR->getKind() == RejectReasonKind::LoopHasNoExit;
}
const DebugLoc &ReportLoopHasNoExit::getDebugLoc() const { return Loc; }
// ReportFuncCall.
ReportFuncCall::ReportFuncCall(Instruction *Inst)
- : RejectReason(rrkFuncCall), Inst(Inst) {
+ : RejectReason(RejectReasonKind::FuncCall), Inst(Inst) {
++BadFuncCallForScop;
}
}
bool ReportFuncCall::classof(const RejectReason *RR) {
- return RR->getKind() == rrkFuncCall;
+ return RR->getKind() == RejectReasonKind::FuncCall;
}
//===----------------------------------------------------------------------===//
// ReportNonSimpleMemoryAccess
ReportNonSimpleMemoryAccess::ReportNonSimpleMemoryAccess(Instruction *Inst)
- : ReportOther(rrkNonSimpleMemoryAccess), Inst(Inst) {}
+ : ReportOther(RejectReasonKind::NonSimpleMemoryAccess), Inst(Inst) {}
std::string ReportNonSimpleMemoryAccess::getMessage() const {
return "Non-simple memory access: " + *Inst;
}
bool ReportNonSimpleMemoryAccess::classof(const RejectReason *RR) {
- return RR->getKind() == rrkNonSimpleMemoryAccess;
+ return RR->getKind() == RejectReasonKind::NonSimpleMemoryAccess;
}
//===----------------------------------------------------------------------===//
// ReportAlias.
ReportAlias::ReportAlias(Instruction *Inst, AliasSet &AS)
- : RejectReason(rrkAlias), Inst(Inst) {
+ : RejectReason(RejectReasonKind::Alias), Inst(Inst) {
for (const auto &I : AS)
Pointers.push_back(I.getValue());
const DebugLoc &ReportAlias::getDebugLoc() const { return Inst->getDebugLoc(); }
bool ReportAlias::classof(const RejectReason *RR) {
- return RR->getKind() == rrkAlias;
+ return RR->getKind() == RejectReasonKind::Alias;
}
//===----------------------------------------------------------------------===//
}
bool ReportOther::classof(const RejectReason *RR) {
- return RR->getKind() >= rrkOther && RR->getKind() <= rrkLastOther;
+ return RR->getKind() >= RejectReasonKind::Other &&
+ RR->getKind() <= RejectReasonKind::LastOther;
}
//===----------------------------------------------------------------------===//
// ReportIntToPtr.
ReportIntToPtr::ReportIntToPtr(Instruction *BaseValue)
- : ReportOther(rrkIntToPtr), BaseValue(BaseValue) {}
+ : ReportOther(RejectReasonKind::IntToPtr), BaseValue(BaseValue) {}
std::string ReportIntToPtr::getMessage() const {
return "Find bad intToptr prt: " + *BaseValue;
}
bool ReportIntToPtr::classof(const RejectReason *RR) {
- return RR->getKind() == rrkIntToPtr;
+ return RR->getKind() == RejectReasonKind::IntToPtr;
}
//===----------------------------------------------------------------------===//
// ReportAlloca.
ReportAlloca::ReportAlloca(Instruction *Inst)
- : ReportOther(rrkAlloca), Inst(Inst) {}
+ : ReportOther(RejectReasonKind::Alloca), Inst(Inst) {}
std::string ReportAlloca::getMessage() const {
return "Alloca instruction: " + *Inst;
}
bool ReportAlloca::classof(const RejectReason *RR) {
- return RR->getKind() == rrkAlloca;
+ return RR->getKind() == RejectReasonKind::Alloca;
}
//===----------------------------------------------------------------------===//
// ReportUnknownInst.
ReportUnknownInst::ReportUnknownInst(Instruction *Inst)
- : ReportOther(rrkUnknownInst), Inst(Inst) {}
+ : ReportOther(RejectReasonKind::UnknownInst), Inst(Inst) {}
std::string ReportUnknownInst::getMessage() const {
return "Unknown instruction: " + *Inst;
}
bool ReportUnknownInst::classof(const RejectReason *RR) {
- return RR->getKind() == rrkUnknownInst;
+ return RR->getKind() == RejectReasonKind::UnknownInst;
}
//===----------------------------------------------------------------------===//
// ReportEntry.
-ReportEntry::ReportEntry(BasicBlock *BB) : ReportOther(rrkEntry), BB(BB) {}
+ReportEntry::ReportEntry(BasicBlock *BB)
+ : ReportOther(RejectReasonKind::Entry), BB(BB) {}
std::string ReportEntry::getMessage() const {
return "Region containing entry block of function is invalid!";
}
bool ReportEntry::classof(const RejectReason *RR) {
- return RR->getKind() == rrkEntry;
+ return RR->getKind() == RejectReasonKind::Entry;
}
//===----------------------------------------------------------------------===//
// ReportUnprofitable.
ReportUnprofitable::ReportUnprofitable(Region *R)
- : ReportOther(rrkUnprofitable), R(R) {}
+ : ReportOther(RejectReasonKind::Unprofitable), R(R) {}
std::string ReportUnprofitable::getMessage() const {
return "Region can not profitably be optimized!";
}
bool ReportUnprofitable::classof(const RejectReason *RR) {
- return RR->getKind() == rrkUnprofitable;
+ return RR->getKind() == RejectReasonKind::Unprofitable;
}
} // namespace polly