lib/Analysis/ScopDetectionDiagnostic.cpp

   1 //===- ScopDetectionDiagnostic.cpp - Error diagnostics --------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // Small set of diagnostic helper classes to encapsulate any errors occurred
  11 // during the detection of Scops.
  12 //
  13 // The ScopDetection defines a set of error classes (via Statistic variables)
  14 // that groups a number of individual errors into a group, e.g. non-affinity
  15 // related errors.
  16 // On error we generate an object that carries enough additional information
  17 // to diagnose the error and generate a helpful error message.
  18 //
  19 //===----------------------------------------------------------------------===//
  20
  21 #include "polly/ScopDetectionDiagnostic.h"
  22 #include "llvm/ADT/SmallPtrSet.h"
  23 #include "llvm/ADT/SmallVector.h"
  24 #include "llvm/ADT/Statistic.h"
  25 #include "llvm/ADT/StringRef.h"
  26 #include "llvm/ADT/Twine.h"
  27 #include "llvm/Analysis/AliasSetTracker.h"
  28 #include "llvm/Analysis/LoopInfo.h"
  29 #include "llvm/Analysis/OptimizationRemarkEmitter.h"
  30 #include "llvm/Analysis/RegionInfo.h"
  31 #include "llvm/Analysis/ScalarEvolution.h"
  32 #include "llvm/IR/BasicBlock.h"
  33 #include "llvm/IR/CFG.h"
  34 #include "llvm/IR/DebugLoc.h"
  35 #include "llvm/IR/DiagnosticInfo.h"
  36 #include "llvm/IR/Instruction.h"
  37 #include "llvm/IR/Value.h"
  38 #include "llvm/Support/raw_ostream.h"
  39 #include <algorithm>
  40 #include <cassert>
  41 #include <string>
  42 #include <utility>
  43
  44 using namespace llvm;
  45
  46 #define DEBUG_TYPE "polly-detect"
  47
  48 #define SCOP_STAT(NAME, DESC)                                                  \
  49   {                                                                            \
  50     "polly-detect", "NAME", "Number of rejected regions: " DESC, {0}, {        \
  51       false                                                                    \
  52     }                                                                          \
  53   }
  54
  55 Statistic RejectStatistics[] = {
  56     SCOP_STAT(CFG, ""),
  57     SCOP_STAT(InvalidTerminator, "Unsupported terminator instruction"),
  58     SCOP_STAT(UnreachableInExit, "Unreachable in exit block"),
  59     SCOP_STAT(IrreducibleRegion, "Irreducible loops"),
  60     SCOP_STAT(LastCFG, ""),
  61     SCOP_STAT(AffFunc, ""),
  62     SCOP_STAT(UndefCond, "Undefined branch condition"),
  63     SCOP_STAT(InvalidCond, "Non-integer branch condition"),
  64     SCOP_STAT(UndefOperand, "Undefined operands in comparison"),
  65     SCOP_STAT(NonAffBranch, "Non-affine branch condition"),
  66     SCOP_STAT(NoBasePtr, "No base pointer"),
  67     SCOP_STAT(UndefBasePtr, "Undefined base pointer"),
  68     SCOP_STAT(VariantBasePtr, "Variant base pointer"),
  69     SCOP_STAT(NonAffineAccess, "Non-affine memory accesses"),
  70     SCOP_STAT(DifferentElementSize, "Accesses with differing sizes"),
  71     SCOP_STAT(LastAffFunc, ""),
  72     SCOP_STAT(LoopBound, "Uncomputable loop bounds"),
  73     SCOP_STAT(LoopHasNoExit, "Loop without exit"),
  74     SCOP_STAT(LoopHasMultipleExits, "Loop with multiple exits"),
  75     SCOP_STAT(LoopOnlySomeLatches, "Not all loop latches in scop"),
  76     SCOP_STAT(FuncCall, "Function call with side effects"),
  77     SCOP_STAT(NonSimpleMemoryAccess,
  78               "Compilated access semantics (volatile or atomic)"),
  79     SCOP_STAT(Alias, "Base address aliasing"),
  80     SCOP_STAT(Other, ""),
  81     SCOP_STAT(IntToPtr, "Integer to pointer conversions"),
  82     SCOP_STAT(Alloca, "Stack allocations"),
  83     SCOP_STAT(UnknownInst, "Unknown Instructions"),
  84     SCOP_STAT(Entry, "Contains entry block"),
  85     SCOP_STAT(Unprofitable, "Assumed to be unprofitable"),
  86     SCOP_STAT(LastOther, ""),
  87 };
  88
  89 namespace polly {
  90
  91 /// Small string conversion via raw_string_stream.
  92 template <typename T> std::string operator+(Twine LHS, const T &RHS) {
  93   std::string Buf;
  94   raw_string_ostream fmt(Buf);
  95   fmt << RHS;
  96   fmt.flush();
  97
  98   return LHS.concat(Buf).str();
  99 }
 100 } // namespace polly
 101
 102 namespace llvm {
 103
 104 // Lexicographic order on (line, col) of our debug locations.
 105 static bool operator<(const DebugLoc &LHS, const DebugLoc &RHS) {
 106   return LHS.getLine() < RHS.getLine() ||
 107          (LHS.getLine() == RHS.getLine() && LHS.getCol() < RHS.getCol());
 108 }
 109 } // namespace llvm
 110
 111 namespace polly {
 112
 113 BBPair getBBPairForRegion(const Region *R) {
 114   return std::make_pair(R->getEntry(), R->getExit());
 115 }
 116
 117 void getDebugLocations(const BBPair &P, DebugLoc &Begin, DebugLoc &End) {
 118   SmallPtrSet<BasicBlock *, 32> Seen;
 119   SmallVector<BasicBlock *, 32> Todo;
 120   Todo.push_back(P.first);
 121   while (!Todo.empty()) {
 122     auto *BB = Todo.pop_back_val();
 123     if (BB == P.second)
 124       continue;
 125     if (!Seen.insert(BB).second)
 126       continue;
 127     Todo.append(succ_begin(BB), succ_end(BB));
 128     for (const Instruction &Inst : *BB) {
 129       DebugLoc DL = Inst.getDebugLoc();
 130       if (!DL)
 131         continue;
 132
 133       Begin = Begin ? std::min(Begin, DL) : DL;
 134       End = End ? std::max(End, DL) : DL;
 135     }
 136   }
 137 }
 138
 139 void emitRejectionRemarks(const BBPair &P, const RejectLog &Log,
 140                           OptimizationRemarkEmitter &ORE) {
 141   DebugLoc Begin, End;
 142   getDebugLocations(P, Begin, End);
 143
 144   ORE.emit(
 145       OptimizationRemarkMissed(DEBUG_TYPE, "RejectionErrors", Begin, P.first)
 146       << "The following errors keep this region from being a Scop.");
 147
 148   for (RejectReasonPtr RR : Log) {
 149
 150     if (const DebugLoc &Loc = RR->getDebugLoc())
 151       ORE.emit(OptimizationRemarkMissed(DEBUG_TYPE, RR->getRemarkName(), Loc,
 152                                         RR->getRemarkBB())
 153                << RR->getEndUserMessage());
 154     else
 155       ORE.emit(OptimizationRemarkMissed(DEBUG_TYPE, RR->getRemarkName(), Begin,
 156                                         RR->getRemarkBB())
 157                << RR->getEndUserMessage());
 158   }
 159
 160   /* Check to see if Region is a top level region, getExit = NULL*/
 161   if (P.second)
 162     ORE.emit(
 163         OptimizationRemarkMissed(DEBUG_TYPE, "InvalidScopEnd", End, P.second)
 164         << "Invalid Scop candidate ends here.");
 165   else
 166     ORE.emit(
 167         OptimizationRemarkMissed(DEBUG_TYPE, "InvalidScopEnd", End, P.first)
 168         << "Invalid Scop candidate ends here.");
 169 }
 170
 171 //===----------------------------------------------------------------------===//
 172 // RejectReason.
 173
 174 RejectReason::RejectReason(RejectReasonKind K) : Kind(K) {
 175   RejectStatistics[static_cast<int>(K)]++;
 176 }
 177
 178 const DebugLoc RejectReason::Unknown = DebugLoc();
 179
 180 const DebugLoc &RejectReason::getDebugLoc() const {
 181   // Allocate an empty DebugLoc and return it a reference to it.
 182   return Unknown;
 183 }
 184
 185 // RejectLog.
 186 void RejectLog::print(raw_ostream &OS, int level) const {
 187   int j = 0;
 188   for (auto Reason : ErrorReports)
 189     OS.indent(level) << "[" << j++ << "] " << Reason->getMessage() << "\n";
 190 }
 191
 192 //===----------------------------------------------------------------------===//
 193 // ReportCFG.
 194
 195 ReportCFG::ReportCFG(const RejectReasonKind K) : RejectReason(K) {}
 196
 197 bool ReportCFG::classof(const RejectReason *RR) {
 198   return RR->getKind() >= RejectReasonKind::CFG &&
 199          RR->getKind() <= RejectReasonKind::LastCFG;
 200 }
 201
 202 //===----------------------------------------------------------------------===//
 203 // ReportInvalidTerminator.
 204
 205 std::string ReportInvalidTerminator::getRemarkName() const {
 206   return "InvalidTerminator";
 207 }
 208
 209 const Value *ReportInvalidTerminator::getRemarkBB() const { return BB; }
 210
 211 std::string ReportInvalidTerminator::getMessage() const {
 212   return ("Invalid instruction terminates BB: " + BB->getName()).str();
 213 }
 214
 215 const DebugLoc &ReportInvalidTerminator::getDebugLoc() const {
 216   return BB->getTerminator()->getDebugLoc();
 217 }
 218
 219 bool ReportInvalidTerminator::classof(const RejectReason *RR) {
 220   return RR->getKind() == RejectReasonKind::InvalidTerminator;
 221 }
 222
 223 //===----------------------------------------------------------------------===//
 224 // UnreachableInExit.
 225
 226 std::string ReportUnreachableInExit::getRemarkName() const {
 227   return "UnreachableInExit";
 228 }
 229
 230 const Value *ReportUnreachableInExit::getRemarkBB() const { return BB; }
 231
 232 std::string ReportUnreachableInExit::getMessage() const {
 233   std::string BBName = BB->getName();
 234   return "Unreachable in exit block" + BBName;
 235 }
 236
 237 const DebugLoc &ReportUnreachableInExit::getDebugLoc() const { return DbgLoc; }
 238
 239 std::string ReportUnreachableInExit::getEndUserMessage() const {
 240   return "Unreachable in exit block.";
 241 }
 242
 243 bool ReportUnreachableInExit::classof(const RejectReason *RR) {
 244   return RR->getKind() == RejectReasonKind::UnreachableInExit;
 245 }
 246
 247 //===----------------------------------------------------------------------===//
 248 // ReportIrreducibleRegion.
 249
 250 std::string ReportIrreducibleRegion::getRemarkName() const {
 251   return "IrreducibleRegion";
 252 }
 253
 254 const Value *ReportIrreducibleRegion::getRemarkBB() const {
 255   return R->getEntry();
 256 }
 257
 258 std::string ReportIrreducibleRegion::getMessage() const {
 259   return "Irreducible region encountered: " + R->getNameStr();
 260 }
 261
 262 const DebugLoc &ReportIrreducibleRegion::getDebugLoc() const { return DbgLoc; }
 263
 264 std::string ReportIrreducibleRegion::getEndUserMessage() const {
 265   return "Irreducible region encountered in control flow.";
 266 }
 267
 268 bool ReportIrreducibleRegion::classof(const RejectReason *RR) {
 269   return RR->getKind() == RejectReasonKind::IrreducibleRegion;
 270 }
 271
 272 //===----------------------------------------------------------------------===//
 273 // ReportAffFunc.
 274
 275 ReportAffFunc::ReportAffFunc(const RejectReasonKind K, const Instruction *Inst)
 276     : RejectReason(K), Inst(Inst) {}
 277
 278 bool ReportAffFunc::classof(const RejectReason *RR) {
 279   return RR->getKind() >= RejectReasonKind::AffFunc &&
 280          RR->getKind() <= RejectReasonKind::LastAffFunc;
 281 }
 282
 283 //===----------------------------------------------------------------------===//
 284 // ReportUndefCond.
 285
 286 std::string ReportUndefCond::getRemarkName() const { return "UndefCond"; }
 287
 288 const Value *ReportUndefCond::getRemarkBB() const { return BB; }
 289
 290 std::string ReportUndefCond::getMessage() const {
 291   return ("Condition based on 'undef' value in BB: " + BB->getName()).str();
 292 }
 293
 294 bool ReportUndefCond::classof(const RejectReason *RR) {
 295   return RR->getKind() == RejectReasonKind::UndefCond;
 296 }
 297
 298 //===----------------------------------------------------------------------===//
 299 // ReportInvalidCond.
 300
 301 std::string ReportInvalidCond::getRemarkName() const { return "InvalidCond"; }
 302
 303 const Value *ReportInvalidCond::getRemarkBB() const { return BB; }
 304
 305 std::string ReportInvalidCond::getMessage() const {
 306   return ("Condition in BB '" + BB->getName()).str() +
 307          "' neither constant nor an icmp instruction";
 308 }
 309
 310 bool ReportInvalidCond::classof(const RejectReason *RR) {
 311   return RR->getKind() == RejectReasonKind::InvalidCond;
 312 }
 313
 314 //===----------------------------------------------------------------------===//
 315 // ReportUndefOperand.
 316
 317 std::string ReportUndefOperand::getRemarkName() const { return "UndefOperand"; }
 318
 319 const Value *ReportUndefOperand::getRemarkBB() const { return BB; }
 320
 321 std::string ReportUndefOperand::getMessage() const {
 322   return ("undef operand in branch at BB: " + BB->getName()).str();
 323 }
 324
 325 bool ReportUndefOperand::classof(const RejectReason *RR) {
 326   return RR->getKind() == RejectReasonKind::UndefOperand;
 327 }
 328
 329 //===----------------------------------------------------------------------===//
 330 // ReportNonAffBranch.
 331
 332 std::string ReportNonAffBranch::getRemarkName() const { return "NonAffBranch"; }
 333
 334 const Value *ReportNonAffBranch::getRemarkBB() const { return BB; }
 335
 336 std::string ReportNonAffBranch::getMessage() const {
 337   return ("Non affine branch in BB '" + BB->getName()).str() +
 338          "' with LHS: " + *LHS + " and RHS: " + *RHS;
 339 }
 340
 341 bool ReportNonAffBranch::classof(const RejectReason *RR) {
 342   return RR->getKind() == RejectReasonKind::NonAffBranch;
 343 }
 344
 345 //===----------------------------------------------------------------------===//
 346 // ReportNoBasePtr.
 347
 348 std::string ReportNoBasePtr::getRemarkName() const { return "NoBasePtr"; }
 349
 350 const Value *ReportNoBasePtr::getRemarkBB() const { return Inst->getParent(); }
 351
 352 std::string ReportNoBasePtr::getMessage() const { return "No base pointer"; }
 353
 354 bool ReportNoBasePtr::classof(const RejectReason *RR) {
 355   return RR->getKind() == RejectReasonKind::NoBasePtr;
 356 }
 357
 358 //===----------------------------------------------------------------------===//
 359 // ReportUndefBasePtr.
 360
 361 std::string ReportUndefBasePtr::getRemarkName() const { return "UndefBasePtr"; }
 362
 363 const Value *ReportUndefBasePtr::getRemarkBB() const {
 364   return Inst->getParent();
 365 }
 366
 367 std::string ReportUndefBasePtr::getMessage() const {
 368   return "Undefined base pointer";
 369 }
 370
 371 bool ReportUndefBasePtr::classof(const RejectReason *RR) {
 372   return RR->getKind() == RejectReasonKind::UndefBasePtr;
 373 }
 374
 375 //===----------------------------------------------------------------------===//
 376 // ReportVariantBasePtr.
 377
 378 std::string ReportVariantBasePtr::getRemarkName() const {
 379   return "VariantBasePtr";
 380 }
 381
 382 const Value *ReportVariantBasePtr::getRemarkBB() const {
 383   return Inst->getParent();
 384 }
 385
 386 std::string ReportVariantBasePtr::getMessage() const {
 387   return "Base address not invariant in current region:" + *BaseValue;
 388 }
 389
 390 std::string ReportVariantBasePtr::getEndUserMessage() const {
 391   return "The base address of this array is not invariant inside the loop";
 392 }
 393
 394 bool ReportVariantBasePtr::classof(const RejectReason *RR) {
 395   return RR->getKind() == RejectReasonKind::VariantBasePtr;
 396 }
 397
 398 //===----------------------------------------------------------------------===//
 399 // ReportDifferentArrayElementSize
 400
 401 std::string ReportDifferentArrayElementSize::getRemarkName() const {
 402   return "DifferentArrayElementSize";
 403 }
 404
 405 const Value *ReportDifferentArrayElementSize::getRemarkBB() const {
 406   return Inst->getParent();
 407 }
 408
 409 std::string ReportDifferentArrayElementSize::getMessage() const {
 410   return "Access to one array through data types of different size";
 411 }
 412
 413 bool ReportDifferentArrayElementSize::classof(const RejectReason *RR) {
 414   return RR->getKind() == RejectReasonKind::DifferentElementSize;
 415 }
 416
 417 std::string ReportDifferentArrayElementSize::getEndUserMessage() const {
 418   StringRef BaseName = BaseValue->getName();
 419   std::string Name = BaseName.empty() ? "UNKNOWN" : BaseName;
 420   return "The array \"" + Name +
 421          "\" is accessed through elements that differ "
 422          "in size";
 423 }
 424
 425 //===----------------------------------------------------------------------===//
 426 // ReportNonAffineAccess.
 427
 428 std::string ReportNonAffineAccess::getRemarkName() const {
 429   return "NonAffineAccess";
 430 }
 431
 432 const Value *ReportNonAffineAccess::getRemarkBB() const {
 433   return Inst->getParent();
 434 }
 435
 436 std::string ReportNonAffineAccess::getMessage() const {
 437   return "Non affine access function: " + *AccessFunction;
 438 }
 439
 440 bool ReportNonAffineAccess::classof(const RejectReason *RR) {
 441   return RR->getKind() == RejectReasonKind::NonAffineAccess;
 442 }
 443
 444 std::string ReportNonAffineAccess::getEndUserMessage() const {
 445   StringRef BaseName = BaseValue->getName();
 446   std::string Name = BaseName.empty() ? "UNKNOWN" : BaseName;
 447   return "The array subscript of \"" + Name + "\" is not affine";
 448 }
 449
 450 //===----------------------------------------------------------------------===//
 451 // ReportLoopBound.
 452
 453 ReportLoopBound::ReportLoopBound(Loop *L, const SCEV *LoopCount)
 454     : RejectReason(RejectReasonKind::LoopBound), L(L), LoopCount(LoopCount),
 455       Loc(L->getStartLoc()) {}
 456
 457 std::string ReportLoopBound::getRemarkName() const { return "LoopBound"; }
 458
 459 const Value *ReportLoopBound::getRemarkBB() const { return L->getHeader(); }
 460
 461 std::string ReportLoopBound::getMessage() const {
 462   return "Non affine loop bound '" + *LoopCount +
 463          "' in loop: " + L->getHeader()->getName();
 464 }
 465
 466 const DebugLoc &ReportLoopBound::getDebugLoc() const { return Loc; }
 467
 468 bool ReportLoopBound::classof(const RejectReason *RR) {
 469   return RR->getKind() == RejectReasonKind::LoopBound;
 470 }
 471
 472 std::string ReportLoopBound::getEndUserMessage() const {
 473   return "Failed to derive an affine function from the loop bounds.";
 474 }
 475
 476 //===----------------------------------------------------------------------===//
 477 // ReportLoopHasNoExit.
 478
 479 std::string ReportLoopHasNoExit::getRemarkName() const {
 480   return "LoopHasNoExit";
 481 }
 482
 483 const Value *ReportLoopHasNoExit::getRemarkBB() const { return L->getHeader(); }
 484
 485 std::string ReportLoopHasNoExit::getMessage() const {
 486   return "Loop " + L->getHeader()->getName() + " has no exit.";
 487 }
 488
 489 bool ReportLoopHasNoExit::classof(const RejectReason *RR) {
 490   return RR->getKind() == RejectReasonKind::LoopHasNoExit;
 491 }
 492
 493 const DebugLoc &ReportLoopHasNoExit::getDebugLoc() const { return Loc; }
 494
 495 std::string ReportLoopHasNoExit::getEndUserMessage() const {
 496   return "Loop cannot be handled because it has no exit.";
 497 }
 498
 499 //===----------------------------------------------------------------------===//
 500 // ReportLoopHasMultipleExits.
 501
 502 std::string ReportLoopHasMultipleExits::getRemarkName() const {
 503   return "ReportLoopHasMultipleExits";
 504 }
 505
 506 const Value *ReportLoopHasMultipleExits::getRemarkBB() const {
 507   return L->getHeader();
 508 }
 509
 510 std::string ReportLoopHasMultipleExits::getMessage() const {
 511   return "Loop " + L->getHeader()->getName() + " has multiple exits.";
 512 }
 513
 514 bool ReportLoopHasMultipleExits::classof(const RejectReason *RR) {
 515   return RR->getKind() == RejectReasonKind::LoopHasMultipleExits;
 516 }
 517
 518 const DebugLoc &ReportLoopHasMultipleExits::getDebugLoc() const { return Loc; }
 519
 520 std::string ReportLoopHasMultipleExits::getEndUserMessage() const {
 521   return "Loop cannot be handled because it has multiple exits.";
 522 }
 523
 524 //===----------------------------------------------------------------------===//
 525 // ReportLoopOnlySomeLatches
 526
 527 std::string ReportLoopOnlySomeLatches::getRemarkName() const {
 528   return "LoopHasNoExit";
 529 }
 530
 531 const Value *ReportLoopOnlySomeLatches::getRemarkBB() const {
 532   return L->getHeader();
 533 }
 534
 535 std::string ReportLoopOnlySomeLatches::getMessage() const {
 536   return "Not all latches of loop " + L->getHeader()->getName() +
 537          " part of scop.";
 538 }
 539
 540 bool ReportLoopOnlySomeLatches::classof(const RejectReason *RR) {
 541   return RR->getKind() == RejectReasonKind::LoopHasNoExit;
 542 }
 543
 544 const DebugLoc &ReportLoopOnlySomeLatches::getDebugLoc() const { return Loc; }
 545
 546 std::string ReportLoopOnlySomeLatches::getEndUserMessage() const {
 547   return "Loop cannot be handled because not all latches are part of loop "
 548          "region.";
 549 }
 550
 551 //===----------------------------------------------------------------------===//
 552 // ReportFuncCall.
 553
 554 ReportFuncCall::ReportFuncCall(Instruction *Inst)
 555     : RejectReason(RejectReasonKind::FuncCall), Inst(Inst) {}
 556
 557 std::string ReportFuncCall::getRemarkName() const { return "FuncCall"; }
 558
 559 const Value *ReportFuncCall::getRemarkBB() const { return Inst->getParent(); }
 560
 561 std::string ReportFuncCall::getMessage() const {
 562   return "Call instruction: " + *Inst;
 563 }
 564
 565 const DebugLoc &ReportFuncCall::getDebugLoc() const {
 566   return Inst->getDebugLoc();
 567 }
 568
 569 std::string ReportFuncCall::getEndUserMessage() const {
 570   return "This function call cannot be handled. "
 571          "Try to inline it.";
 572 }
 573
 574 bool ReportFuncCall::classof(const RejectReason *RR) {
 575   return RR->getKind() == RejectReasonKind::FuncCall;
 576 }
 577
 578 //===----------------------------------------------------------------------===//
 579 // ReportNonSimpleMemoryAccess
 580
 581 ReportNonSimpleMemoryAccess::ReportNonSimpleMemoryAccess(Instruction *Inst)
 582     : ReportOther(RejectReasonKind::NonSimpleMemoryAccess), Inst(Inst) {}
 583
 584 std::string ReportNonSimpleMemoryAccess::getRemarkName() const {
 585   return "NonSimpleMemoryAccess";
 586 }
 587
 588 const Value *ReportNonSimpleMemoryAccess::getRemarkBB() const {
 589   return Inst->getParent();
 590 }
 591
 592 std::string ReportNonSimpleMemoryAccess::getMessage() const {
 593   return "Non-simple memory access: " + *Inst;
 594 }
 595
 596 const DebugLoc &ReportNonSimpleMemoryAccess::getDebugLoc() const {
 597   return Inst->getDebugLoc();
 598 }
 599
 600 std::string ReportNonSimpleMemoryAccess::getEndUserMessage() const {
 601   return "Volatile memory accesses or memory accesses for atomic types "
 602          "are not supported.";
 603 }
 604
 605 bool ReportNonSimpleMemoryAccess::classof(const RejectReason *RR) {
 606   return RR->getKind() == RejectReasonKind::NonSimpleMemoryAccess;
 607 }
 608
 609 //===----------------------------------------------------------------------===//
 610 // ReportAlias.
 611
 612 ReportAlias::ReportAlias(Instruction *Inst, AliasSet &AS)
 613     : RejectReason(RejectReasonKind::Alias), Inst(Inst) {
 614   for (const auto &I : AS)
 615     Pointers.push_back(I.getValue());
 616 }
 617
 618 std::string ReportAlias::formatInvalidAlias(std::string Prefix,
 619                                             std::string Suffix) const {
 620   std::string Message;
 621   raw_string_ostream OS(Message);
 622
 623   OS << Prefix;
 624
 625   for (PointerSnapshotTy::const_iterator PI = Pointers.begin(),
 626                                          PE = Pointers.end();
 627        ;) {
 628     const Value *V = *PI;
 629     assert(V && "Diagnostic info does not match found LLVM-IR anymore.");
 630
 631     if (V->getName().empty())
 632       OS << "\" <unknown> \"";
 633     else
 634       OS << "\"" << V->getName() << "\"";
 635
 636     ++PI;
 637
 638     if (PI != PE)
 639       OS << ", ";
 640     else
 641       break;
 642   }
 643
 644   OS << Suffix;
 645
 646   return OS.str();
 647 }
 648
 649 std::string ReportAlias::getRemarkName() const { return "Alias"; }
 650
 651 const Value *ReportAlias::getRemarkBB() const { return Inst->getParent(); }
 652
 653 std::string ReportAlias::getMessage() const {
 654   return formatInvalidAlias("Possible aliasing: ");
 655 }
 656
 657 std::string ReportAlias::getEndUserMessage() const {
 658   return formatInvalidAlias("Accesses to the arrays ",
 659                             " may access the same memory.");
 660 }
 661
 662 const DebugLoc &ReportAlias::getDebugLoc() const { return Inst->getDebugLoc(); }
 663
 664 bool ReportAlias::classof(const RejectReason *RR) {
 665   return RR->getKind() == RejectReasonKind::Alias;
 666 }
 667
 668 //===----------------------------------------------------------------------===//
 669 // ReportOther.
 670
 671 std::string ReportOther::getRemarkName() const { return "UnknownRejectReason"; }
 672
 673 std::string ReportOther::getMessage() const { return "Unknown reject reason"; }
 674
 675 ReportOther::ReportOther(const RejectReasonKind K) : RejectReason(K) {}
 676
 677 bool ReportOther::classof(const RejectReason *RR) {
 678   return RR->getKind() >= RejectReasonKind::Other &&
 679          RR->getKind() <= RejectReasonKind::LastOther;
 680 }
 681
 682 //===----------------------------------------------------------------------===//
 683 // ReportIntToPtr.
 684 ReportIntToPtr::ReportIntToPtr(Instruction *BaseValue)
 685     : ReportOther(RejectReasonKind::IntToPtr), BaseValue(BaseValue) {}
 686
 687 std::string ReportIntToPtr::getRemarkName() const { return "IntToPtr"; }
 688
 689 const Value *ReportIntToPtr::getRemarkBB() const {
 690   return BaseValue->getParent();
 691 }
 692
 693 std::string ReportIntToPtr::getMessage() const {
 694   return "Find bad intToptr prt: " + *BaseValue;
 695 }
 696
 697 const DebugLoc &ReportIntToPtr::getDebugLoc() const {
 698   return BaseValue->getDebugLoc();
 699 }
 700
 701 bool ReportIntToPtr::classof(const RejectReason *RR) {
 702   return RR->getKind() == RejectReasonKind::IntToPtr;
 703 }
 704
 705 //===----------------------------------------------------------------------===//
 706 // ReportAlloca.
 707
 708 ReportAlloca::ReportAlloca(Instruction *Inst)
 709     : ReportOther(RejectReasonKind::Alloca), Inst(Inst) {}
 710
 711 std::string ReportAlloca::getRemarkName() const { return "Alloca"; }
 712
 713 const Value *ReportAlloca::getRemarkBB() const { return Inst->getParent(); }
 714
 715 std::string ReportAlloca::getMessage() const {
 716   return "Alloca instruction: " + *Inst;
 717 }
 718
 719 const DebugLoc &ReportAlloca::getDebugLoc() const {
 720   return Inst->getDebugLoc();
 721 }
 722
 723 bool ReportAlloca::classof(const RejectReason *RR) {
 724   return RR->getKind() == RejectReasonKind::Alloca;
 725 }
 726
 727 //===----------------------------------------------------------------------===//
 728 // ReportUnknownInst.
 729
 730 ReportUnknownInst::ReportUnknownInst(Instruction *Inst)
 731     : ReportOther(RejectReasonKind::UnknownInst), Inst(Inst) {}
 732
 733 std::string ReportUnknownInst::getRemarkName() const { return "UnknownInst"; }
 734
 735 const Value *ReportUnknownInst::getRemarkBB() const {
 736   return Inst->getParent();
 737 }
 738
 739 std::string ReportUnknownInst::getMessage() const {
 740   return "Unknown instruction: " + *Inst;
 741 }
 742
 743 const DebugLoc &ReportUnknownInst::getDebugLoc() const {
 744   return Inst->getDebugLoc();
 745 }
 746
 747 bool ReportUnknownInst::classof(const RejectReason *RR) {
 748   return RR->getKind() == RejectReasonKind::UnknownInst;
 749 }
 750
 751 //===----------------------------------------------------------------------===//
 752 // ReportEntry.
 753
 754 ReportEntry::ReportEntry(BasicBlock *BB)
 755     : ReportOther(RejectReasonKind::Entry), BB(BB) {}
 756
 757 std::string ReportEntry::getRemarkName() const { return "Entry"; }
 758
 759 const Value *ReportEntry::getRemarkBB() const { return BB; }
 760
 761 std::string ReportEntry::getMessage() const {
 762   return "Region containing entry block of function is invalid!";
 763 }
 764
 765 std::string ReportEntry::getEndUserMessage() const {
 766   return "Scop contains function entry (not yet supported).";
 767 }
 768
 769 const DebugLoc &ReportEntry::getDebugLoc() const {
 770   return BB->getTerminator()->getDebugLoc();
 771 }
 772
 773 bool ReportEntry::classof(const RejectReason *RR) {
 774   return RR->getKind() == RejectReasonKind::Entry;
 775 }
 776
 777 //===----------------------------------------------------------------------===//
 778 // ReportUnprofitable.
 779
 780 ReportUnprofitable::ReportUnprofitable(Region *R)
 781     : ReportOther(RejectReasonKind::Unprofitable), R(R) {}
 782
 783 std::string ReportUnprofitable::getRemarkName() const { return "Unprofitable"; }
 784
 785 const Value *ReportUnprofitable::getRemarkBB() const { return R->getEntry(); }
 786
 787 std::string ReportUnprofitable::getMessage() const {
 788   return "Region can not profitably be optimized!";
 789 }
 790
 791 std::string ReportUnprofitable::getEndUserMessage() const {
 792   return "No profitable polyhedral optimization found";
 793 }
 794
 795 const DebugLoc &ReportUnprofitable::getDebugLoc() const {
 796   for (const BasicBlock *BB : R->blocks())
 797     for (const Instruction &Inst : *BB)
 798       if (const DebugLoc &DL = Inst.getDebugLoc())
 799         return DL;
 800
 801   return R->getEntry()->getTerminator()->getDebugLoc();
 802 }
 803
 804 bool ReportUnprofitable::classof(const RejectReason *RR) {
 805   return RR->getKind() == RejectReasonKind::Unprofitable;
 806 }
 807 } // namespace polly