[Polly] [OptDiag] Updating Polly Diagnostics Remarks

[tarunr]

Summary

Utilizing newer llvm diagnostic remark API in order to enable use of opt-viewer tool.
Polly Diagnostic Remarks also now appear in yaml remark file.

In this patch, I've added the OptimizationRemarkEmitter into certain classes where remarks are being emitted and update the remark emit calls itself. I also provide each remark a BasicBlock or Instruction from where it is being called, in order to compute the hotness of the remark.

[grosser]

Very cool. This looks good to me.

Not for this patch, but it would be amazing if you could use this opportunity:

1. Add this change to the release notes
2. Add a brief section about Polly's optimization remarks to the documentation. I am especially interested how to use the hotness information!

[grosser]

@tarunr : Do you plan to commit this patch or do you need somebody to commit this patch for you?

[tarunr]

Rebasing,added support for a new remark.

polly/trunk/include/polly/ScopDetection.h

 #ifndef POLLY_SCOP_DETECTION_H
 #define POLLY_SCOP_DETECTION_H
 
 #include "polly/ScopDetectionDiagnostic.h"
 #include "polly/Support/ScopHelper.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/AliasSetTracker.h"
+#include "llvm/Analysis/OptimizationDiagnosticInfo.h"
 #include "llvm/Analysis/RegionInfo.h"
 #include "llvm/Pass.h"
 #include <map>
 #include <memory>
 #include <set>
 
 using namespace llvm;
 
private:
   /// @param Assert Throw an assert in verify mode or not.
   /// @param Args Argument list that gets passed to the constructor of RR.
   template <class RR, typename... Args>
   inline bool invalid(DetectionContext &Context, bool Assert,
                       Args &&... Arguments) const;
 
 public:
   ScopDetection(Function &F, const DominatorTree &DT, ScalarEvolution &SE,
-                LoopInfo &LI, RegionInfo &RI, AliasAnalysis &AA);
+                LoopInfo &LI, RegionInfo &RI, AliasAnalysis &AA,
+                OptimizationRemarkEmitter &ORE);
 
   /// Get the RegionInfo stored in this pass.
   ///
   /// This was added to give the DOT printer easy access to this information.
   RegionInfo *getRI() const { return &RI; }
 
   /// Get the LoopInfo stored in this pass.
   LoopInfo *getLI() const { return &LI; }
public:
   /// @param SE The scalar evolution analysis.
   /// @param MinProfitableTrips The minimum number of trip counts from which
   ///                           a loop is assumed to be profitable and
   ///                           consequently is counted.
   /// returns A tuple of number of loops and their maximal depth.
   static ScopDetection::LoopStats
   countBeneficialLoops(Region *R, ScalarEvolution &SE, LoopInfo &LI,
                        unsigned MinProfitableTrips);
+
+  /// OptimizationRemarkEmitter object used to emit diagnostic remarks
+  OptimizationRemarkEmitter &ORE;
 };
 
 struct ScopAnalysis : public AnalysisInfoMixin<ScopAnalysis> {
   static AnalysisKey Key;
   using Result = ScopDetection;
   Result run(Function &F, FunctionAnalysisManager &FAM);
 };
 

polly/trunk/include/polly/ScopDetectionDiagnostic.h

 #ifndef POLLY_SCOP_DETECTION_DIAGNOSTIC_H
 #define POLLY_SCOP_DETECTION_DIAGNOSTIC_H
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Analysis/AliasSetTracker.h"
 #include "llvm/Analysis/LoopInfo.h"
+#include "llvm/Analysis/OptimizationDiagnosticInfo.h"
 #include "llvm/Analysis/ScalarEvolutionExpressions.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/Casting.h"
 #include <memory>
 #include <string>
 
 using namespace llvm;

 
 class RejectLog;
 /// Emit optimization remarks about the rejected regions to the user.
 ///
 /// This emits the content of the reject log as optimization remarks.
 /// Remember to at least track failures (-polly-detect-track-failures).
 /// @param P The region delimiters (entry & exit) we emit remarks for.
 /// @param Log The error log containing all messages being emitted as remark.
-void emitRejectionRemarks(const BBPair &P, const RejectLog &Log);
+void emitRejectionRemarks(const BBPair &P, const RejectLog &Log,
+                          OptimizationRemarkEmitter &ORE);
 
 // Discriminator for LLVM-style RTTI (dyn_cast<> et al.)
 enum class RejectReasonKind {
   // CFG Category
   CFG,
   InvalidTerminator,
   IrreducibleRegion,
   UnreachableInExit,

 
 public:
   RejectReasonKind getKind() const { return Kind; }
 
   RejectReason(RejectReasonKind K);
 
   virtual ~RejectReason() {}
 
+  /// Generate the remark name to identify this remark.
+  ///
+  /// @return A short string that identifies the error.
+  virtual std::string getRemarkName() const = 0;
+
+  /// Get the Basic Block containing this remark.
+  ///
+  /// @return The Basic Block containing this remark.
+  virtual const Value *getRemarkBB() const = 0;
+
   /// Generate a reasonable diagnostic message describing this error.
   ///
   /// @return A debug message representing this error.
   virtual std::string getMessage() const = 0;
 
   /// Generate a message for the end-user describing this error.
   ///
   /// The message provided has to be suitable for the end-user. So it should
public:
 
   /// @name LLVM-RTTI interface
   //@{
   static bool classof(const RejectReason *RR);
   //@}
 
   /// @name RejectReason interface
   //@{
+  virtual std::string getRemarkName() const override;
+  virtual const Value *getRemarkBB() const override;
   virtual std::string getMessage() const override;
   virtual const DebugLoc &getDebugLoc() const override;
   //@}
 };
 
 //===----------------------------------------------------------------------===//
 /// Captures irreducible regions in CFG.
 class ReportIrreducibleRegion : public ReportCFG {
   Region *R;
   DebugLoc DbgLoc;
 
 public:
   ReportIrreducibleRegion(Region *R, DebugLoc DbgLoc)
       : ReportCFG(RejectReasonKind::IrreducibleRegion), R(R), DbgLoc(DbgLoc) {}
 
   /// @name LLVM-RTTI interface
   //@{
   static bool classof(const RejectReason *RR);
   //@}
 
   /// @name RejectReason interface
   //@{
+  virtual std::string getRemarkName() const override;
+  virtual const Value *getRemarkBB() const override;
   virtual std::string getMessage() const override;
   virtual std::string getEndUserMessage() const override;
   virtual const DebugLoc &getDebugLoc() const override;
   //@}
 };
 
 //===----------------------------------------------------------------------===//
 /// Captures regions with an unreachable in the exit block.
 class ReportUnreachableInExit : public ReportCFG {
   BasicBlock *BB;
   DebugLoc DbgLoc;
 
 public:
   ReportUnreachableInExit(BasicBlock *BB, DebugLoc DbgLoc)
       : ReportCFG(RejectReasonKind::UnreachableInExit), BB(BB), DbgLoc(DbgLoc) {
   }
 
   /// @name LLVM-RTTI interface
   //@{
   static bool classof(const RejectReason *RR);
   //@}
 
   /// @name RejectReason interface
   //@{
+  virtual std::string getRemarkName() const override;
+  virtual const Value *getRemarkBB() const override;
   virtual std::string getMessage() const override;
   virtual std::string getEndUserMessage() const override;
   virtual const DebugLoc &getDebugLoc() const override;
   //@}
 };
 
 //===----------------------------------------------------------------------===//
 /// Base class for non-affine reject reasons.
 ///
 /// Scop candidates that violate restrictions to affinity are reported under
 /// this class.
 class ReportAffFunc : public RejectReason {
   //===--------------------------------------------------------------------===//
 
+protected:
   // The instruction that caused non-affinity to occur.
   const Instruction *Inst;
 
 public:
   ReportAffFunc(const RejectReasonKind K, const Instruction *Inst);
 
   /// @name LLVM-RTTI interface
   //@{
public:
 
   /// @name LLVM-RTTI interface
   //@{
   static bool classof(const RejectReason *RR);
   //@}
 
   /// @name RejectReason interface
   //@{
+  virtual std::string getRemarkName() const override;
+  virtual const Value *getRemarkBB() const override;
   virtual std::string getMessage() const override;
   //@}
 };
 
 //===----------------------------------------------------------------------===//
 /// Captures an invalid condition
 ///
 /// Conditions have to be either constants or icmp instructions.
public:
 
   /// @name LLVM-RTTI interface
   //@{
   static bool classof(const RejectReason *RR);
   //@}
 
   /// @name RejectReason interface
   //@{
+  virtual std::string getRemarkName() const override;
+  virtual const Value *getRemarkBB() const override;
   virtual std::string getMessage() const override;
   //@}
 };
 
 //===----------------------------------------------------------------------===//
 /// Captures an undefined operand.
 class ReportUndefOperand : public ReportAffFunc {
   //===--------------------------------------------------------------------===//
 
   // The BasicBlock we found the undefined operand in.
   BasicBlock *BB;
 
 public:
   ReportUndefOperand(BasicBlock *BB, const Instruction *Inst)
       : ReportAffFunc(RejectReasonKind::UndefOperand, Inst), BB(BB) {}
 
   /// @name LLVM-RTTI interface
   //@{
   static bool classof(const RejectReason *RR);
   //@}
 
   /// @name RejectReason interface
   //@{
+  virtual std::string getRemarkName() const override;
+  virtual const Value *getRemarkBB() const override;
   virtual std::string getMessage() const override;
   //@}
 };
 
 //===----------------------------------------------------------------------===//
 /// Captures a non-affine branch.
 class ReportNonAffBranch : public ReportAffFunc {
   //===--------------------------------------------------------------------===//
public:
 
   /// @name LLVM-RTTI interface
   //@{
   static bool classof(const RejectReason *RR);
   //@}
 
   /// @name RejectReason interface
   //@{
+  virtual std::string getRemarkName() const override;
+  virtual const Value *getRemarkBB() const override;
   virtual std::string getMessage() const override;
   //@}
 };
 
 //===----------------------------------------------------------------------===//
 /// Captures a missing base pointer.
 class ReportNoBasePtr : public ReportAffFunc {
   //===--------------------------------------------------------------------===//
 public:
   ReportNoBasePtr(const Instruction *Inst)
       : ReportAffFunc(RejectReasonKind::NoBasePtr, Inst) {}
 
   /// @name LLVM-RTTI interface
   //@{
   static bool classof(const RejectReason *RR);
   //@}
 
   /// @name RejectReason interface
   //@{
+  virtual std::string getRemarkName() const override;
+  virtual const Value *getRemarkBB() const override;
   virtual std::string getMessage() const override;
   //@}
 };
 
 //===----------------------------------------------------------------------===//
 /// Captures an undefined base pointer.
 class ReportUndefBasePtr : public ReportAffFunc {
   //===--------------------------------------------------------------------===//
 public:
   ReportUndefBasePtr(const Instruction *Inst)
       : ReportAffFunc(RejectReasonKind::UndefBasePtr, Inst) {}
 
   /// @name LLVM-RTTI interface
   //@{
   static bool classof(const RejectReason *RR);
   //@}
 
   /// @name RejectReason interface
   //@{
+  virtual std::string getRemarkName() const override;
+  virtual const Value *getRemarkBB() const override;
   virtual std::string getMessage() const override;
   //@}
 };
 
 //===----------------------------------------------------------------------===//
 /// Captures a base pointer that is not invariant in the region.
 class ReportVariantBasePtr : public ReportAffFunc {
   //===--------------------------------------------------------------------===//
 
   // The variant base pointer.
   Value *BaseValue;
 
 public:
   ReportVariantBasePtr(Value *BaseValue, const Instruction *Inst)
       : ReportAffFunc(RejectReasonKind::VariantBasePtr, Inst),
         BaseValue(BaseValue) {}
 
   /// @name LLVM-RTTI interface
   //@{
   static bool classof(const RejectReason *RR);
   //@}
 
   /// @name RejectReason interface
   //@{
+  virtual std::string getRemarkName() const override;
+  virtual const Value *getRemarkBB() const override;
   virtual std::string getMessage() const override;
   virtual std::string getEndUserMessage() const override;
   //@}
 };
 
 //===----------------------------------------------------------------------===//
 /// Captures a non-affine access function.
 class ReportNonAffineAccess : public ReportAffFunc {
public:
 
   /// @name LLVM-RTTI interface
   //@{
   static bool classof(const RejectReason *RR);
   //@}
 
   /// @name RejectReason interface
   //@{
+  virtual std::string getRemarkName() const override;
+  virtual const Value *getRemarkBB() const override;
   virtual std::string getMessage() const override;
   virtual std::string getEndUserMessage() const override;
   //@}
 };
 
 //===----------------------------------------------------------------------===//
 /// Report array accesses with differing element size.
 class ReportDifferentArrayElementSize : public ReportAffFunc {
public:
 
   /// @name LLVM-RTTI interface
   //@{
   static bool classof(const RejectReason *RR);
   //@}
 
   /// @name RejectReason interface
   //@{
+  virtual std::string getRemarkName() const override;
+  virtual const Value *getRemarkBB() const override;
   virtual std::string getMessage() const override;
   virtual std::string getEndUserMessage() const override;
   //@}
 };
 
 //===----------------------------------------------------------------------===//
 /// Captures errors with non affine loop bounds.
 class ReportLoopBound : public RejectReason {
public:
 
   /// @name LLVM-RTTI interface
   //@{
   static bool classof(const RejectReason *RR);
   //@}
 
   /// @name RejectReason interface
   //@{
+  virtual std::string getRemarkName() const override;
+  virtual const Value *getRemarkBB() const override;
   virtual std::string getMessage() const override;
   virtual const DebugLoc &getDebugLoc() const override;
   virtual std::string getEndUserMessage() const override;
   //@}
 };
 
 //===----------------------------------------------------------------------===//
 /// Captures errors when loop has no exit.
public:
 
   /// @name LLVM-RTTI interface
   //@{
   static bool classof(const RejectReason *RR);
   //@}
 
   /// @name RejectReason interface
   //@{
+  virtual std::string getRemarkName() const override;
+  virtual const Value *getRemarkBB() const override;
   virtual std::string getMessage() const override;
   virtual const DebugLoc &getDebugLoc() const override;
   virtual std::string getEndUserMessage() const override;
   //@}
 };
 
 //===----------------------------------------------------------------------===//
 /// Captures errors when not all loop latches are part of the scop.
public:
 
   /// @name LLVM-RTTI interface
   //@{
   static bool classof(const RejectReason *RR);
   //@}
 
   /// @name RejectReason interface
   //@{
+  virtual std::string getRemarkName() const override;
+  virtual const Value *getRemarkBB() const override;
   virtual std::string getMessage() const override;
   virtual const DebugLoc &getDebugLoc() const override;
   virtual std::string getEndUserMessage() const override;
   //@}
 };
 
 //===----------------------------------------------------------------------===//
 /// Captures errors with non-side-effect-known function calls.
 class ReportFuncCall : public RejectReason {
   //===--------------------------------------------------------------------===//
 
   // The offending call instruction.
   Instruction *Inst;
 
 public:
   ReportFuncCall(Instruction *Inst);
 
   /// @name LLVM-RTTI interface
   //@{
   static bool classof(const RejectReason *RR);
   //@}
 
   /// @name RejectReason interface
   //@{
+  virtual std::string getRemarkName() const override;
+  virtual const Value *getRemarkBB() const override;
   virtual std::string getMessage() const override;
   virtual const DebugLoc &getDebugLoc() const override;
   virtual std::string getEndUserMessage() const override;
   //@}
 };
 
 //===----------------------------------------------------------------------===//
 /// Captures errors with aliasing.
public:
 
   /// @name LLVM-RTTI interface
   //@{
   static bool classof(const RejectReason *RR);
   //@}
 
   /// @name RejectReason interface
   //@{
+  virtual std::string getRemarkName() const override;
+  virtual const Value *getRemarkBB() const override;
   virtual std::string getMessage() const override;
   virtual const DebugLoc &getDebugLoc() const override;
   virtual std::string getEndUserMessage() const override;
   //@}
 };
 
 //===----------------------------------------------------------------------===//
 /// Base class for otherwise ungrouped reject reasons.
 class ReportOther : public RejectReason {
   //===--------------------------------------------------------------------===//
 public:
   ReportOther(const RejectReasonKind K);
 
   /// @name LLVM-RTTI interface
   //@{
   static bool classof(const RejectReason *RR);
   //@}
 
   /// @name RejectReason interface
   //@{
+  virtual std::string getRemarkName() const override;
   virtual std::string getMessage() const override;
   //@}
 };
 
 //===----------------------------------------------------------------------===//
 /// Captures errors with bad IntToPtr instructions.
 class ReportIntToPtr : public ReportOther {
   //===--------------------------------------------------------------------===//
 
   // The offending base value.
   Instruction *BaseValue;
 
 public:
   ReportIntToPtr(Instruction *BaseValue);
 
   /// @name LLVM-RTTI interface
   //@{
   static bool classof(const RejectReason *RR);
   //@}
 
   /// @name RejectReason interface
   //@{
+  virtual std::string getRemarkName() const override;
+  virtual const Value *getRemarkBB() const override;
   virtual std::string getMessage() const override;
   virtual const DebugLoc &getDebugLoc() const override;
   //@}
 };
 
 //===----------------------------------------------------------------------===//
 /// Captures errors with alloca instructions.
 class ReportAlloca : public ReportOther {
   //===--------------------------------------------------------------------===//
   Instruction *Inst;
 
 public:
   ReportAlloca(Instruction *Inst);
 
   /// @name LLVM-RTTI interface
   //@{
   static bool classof(const RejectReason *RR);
   //@}
 
   /// @name RejectReason interface
   //@{
+  virtual std::string getRemarkName() const override;
+  virtual const Value *getRemarkBB() const override;
   virtual std::string getMessage() const override;
   virtual const DebugLoc &getDebugLoc() const override;
   //@}
 };
 
 //===----------------------------------------------------------------------===//
 /// Captures errors with unknown instructions.
 class ReportUnknownInst : public ReportOther {
   //===--------------------------------------------------------------------===//
   Instruction *Inst;
 
 public:
   ReportUnknownInst(Instruction *Inst);
 
   /// @name LLVM-RTTI interface
   //@{
   static bool classof(const RejectReason *RR);
   //@}
 
   /// @name RejectReason interface
   //@{
+  virtual std::string getRemarkName() const override;
+  virtual const Value *getRemarkBB() const override;
   virtual std::string getMessage() const override;
   virtual const DebugLoc &getDebugLoc() const override;
   //@}
 };
 
 //===----------------------------------------------------------------------===//
 /// Captures errors with regions containing the function entry block.
 class ReportEntry : public ReportOther {
   //===--------------------------------------------------------------------===//
   BasicBlock *BB;
 
 public:
   ReportEntry(BasicBlock *BB);
 
   /// @name LLVM-RTTI interface
   //@{
   static bool classof(const RejectReason *RR);
   //@}
 
   /// @name RejectReason interface
   //@{
+  virtual std::string getRemarkName() const override;
+  virtual const Value *getRemarkBB() const override;
   virtual std::string getMessage() const override;
   virtual std::string getEndUserMessage() const override;
   virtual const DebugLoc &getDebugLoc() const override;
   //@}
 };
 
 //===----------------------------------------------------------------------===//
 /// Report regions that seem not profitable to be optimized.
 class ReportUnprofitable : public ReportOther {
   //===--------------------------------------------------------------------===//
   Region *R;
 
 public:
   ReportUnprofitable(Region *R);
 
   /// @name LLVM-RTTI interface
   //@{
   static bool classof(const RejectReason *RR);
   //@}
 
   /// @name RejectReason interface
   //@{
+  virtual std::string getRemarkName() const override;
+  virtual const Value *getRemarkBB() const override;
   virtual std::string getMessage() const override;
   virtual std::string getEndUserMessage() const override;
   virtual const DebugLoc &getDebugLoc() const override;
   //@}
 };
 
 //===----------------------------------------------------------------------===//
 /// Captures errors with non-simple memory accesses.
 class ReportNonSimpleMemoryAccess : public ReportOther {
   //===--------------------------------------------------------------------===//
 
   // The offending call instruction.
   Instruction *Inst;
 
 public:
   ReportNonSimpleMemoryAccess(Instruction *Inst);
 
   /// @name LLVM-RTTI interface
   //@{
   static bool classof(const RejectReason *RR);
   //@}
 
   /// @name RejectReason interface
   //@{
+  virtual std::string getRemarkName() const override;
+  virtual const Value *getRemarkBB() const override;
   virtual std::string getMessage() const override;
   virtual const DebugLoc &getDebugLoc() const override;
   virtual std::string getEndUserMessage() const override;
   //@}
 };
 
 } // namespace polly
 
 #endif // POLLY_SCOP_DETECTION_DIAGNOSTIC_H

polly/trunk/include/polly/ScopInfo.h

private:
   ParameterSetTy Parameters;
 
   /// Mapping from parameters to their ids.
   DenseMap<const SCEV *, isl_id *> ParameterIds;
 
   /// The context of the SCoP created during SCoP detection.
   ScopDetection::DetectionContext &DC;
 
+  /// OptimizationRemarkEmitter object for displaying diagnostic remarks
+  OptimizationRemarkEmitter &ORE;
+
   /// Isl context.
   ///
   /// We need a shared_ptr with reference counter to delete the context when all
   /// isl objects are deleted. We will distribute the shared_ptr to all objects
   /// that use the context to create isl objects, and increase the reference
   /// counter. By doing this, we guarantee that the context is deleted when we
   /// delete the last object that creates isl objects with the context.
   std::shared_ptr<isl_ctx> IslCtx;
private:
   /// A number that uniquely represents a Scop within its function
   const int ID;
 
   /// Return the ID for a new Scop within a function
   static int getNextID(std::string ParentFunc);
 
   /// Scop constructor; invoked from ScopBuilder::buildScop.
   Scop(Region &R, ScalarEvolution &SE, LoopInfo &LI,
-       ScopDetection::DetectionContext &DC);
+       ScopDetection::DetectionContext &DC, OptimizationRemarkEmitter &ORE);
 
   //@}
 
   /// Initialize this ScopBuilder.
   void init(AliasAnalysis &AA, AssumptionCache &AC, DominatorTree &DT,
             LoopInfo &LI);
 
   /// Propagate domains that are known due to graph properties.
public:
   /// Use 'clang -Rpass-analysis=polly-scops' or 'opt
   /// -pass-remarks-analysis=polly-scops' to output the assumptions.
   ///
   /// @param Kind The assumption kind describing the underlying cause.
   /// @param Set  The relations between parameters that are assumed to hold.
   /// @param Loc  The location in the source that caused this assumption.
   /// @param Sign Enum to indicate if the assumptions in @p Set are positive
   ///             (needed/assumptions) or negative (invalid/restrictions).
+  /// @param BB   The block in which this assumption was taken. Used to
+  ///             calculate hotness when emitting remark.
   ///
   /// @returns True if the assumption is not trivial.
   bool trackAssumption(AssumptionKind Kind, __isl_keep isl_set *Set,
-                       DebugLoc Loc, AssumptionSign Sign);
+                       DebugLoc Loc, AssumptionSign Sign, BasicBlock *BB);
 
   /// Add assumptions to assumed context.
   ///
   /// The assumptions added will be assumed to hold during the execution of the
   /// scop. However, as they are generally not statically provable, at code
   /// generation time run-time checks will be generated that ensure the
   /// assumptions hold.
   ///
   /// WARNING: We currently exploit in simplifyAssumedContext the knowledge
   ///          that assumptions do not change the set of statement instances
   ///          executed.
   ///
   /// @param Kind The assumption kind describing the underlying cause.
   /// @param Set  The relations between parameters that are assumed to hold.
   /// @param Loc  The location in the source that caused this assumption.
   /// @param Sign Enum to indicate if the assumptions in @p Set are positive
   ///             (needed/assumptions) or negative (invalid/restrictions).
+  /// @param BB   The block in which this assumption was taken. Used to
+  ///             calculate hotness when emitting remark.
   void addAssumption(AssumptionKind Kind, __isl_take isl_set *Set, DebugLoc Loc,
-                     AssumptionSign Sign);
+                     AssumptionSign Sign, BasicBlock *BB);
 
   /// Record an assumption for later addition to the assumed context.
   ///
   /// This function will add the assumption to the RecordedAssumptions. This
   /// collection will be added (@see addAssumption) to the assumed context once
   /// all paramaters are known and the context is fully build.
   ///
   /// @param Kind The assumption kind describing the underlying cause.
public:
   ///
   /// This method adds an assumption to the scop that is always invalid. As a
   /// result, the scop will not be optimized later on. This function is commonly
   /// called when a condition makes it impossible (or too compile time
   /// expensive) to process this scop any further.
   ///
   /// @param Kind The assumption kind describing the underlying cause.
   /// @param Loc  The location in the source that triggered .
-  void invalidate(AssumptionKind Kind, DebugLoc Loc);
+  /// @param BB   The BasicBlock where it was triggered.
+  void invalidate(AssumptionKind Kind, DebugLoc Loc, BasicBlock *BB = nullptr);
 
   /// Get the invalid context for this Scop.
   ///
   /// @return The invalid context of this Scop.
   __isl_give isl_set *getInvalidContext() const;
 
   /// Return true if and only if the InvalidContext is trivial (=empty).
   bool hasTrivialInvalidContext() const {

polly/trunk/lib/Analysis/ScopBuilder.cpp

bool ScopBuilder::buildAccessMultiDimParam(MemAccInst Inst, ScopStmt *Stmt) {
   // element size used for delinearization differs the delinearization is
   // incorrect. Hence, we invalidate the scop.
   //
   // TODO: Handle delinearization with differing element sizes.
   auto DelinearizedSize =
       cast<SCEVConstant>(Sizes.back())->getAPInt().getSExtValue();
   Sizes.pop_back();
   if (ElementSize != DelinearizedSize)
-    scop->invalidate(DELINEARIZATION, Inst->getDebugLoc());
+    scop->invalidate(DELINEARIZATION, Inst->getDebugLoc(), Inst->getParent());
 
   addArrayAccess(Stmt, Inst, AccType, BasePointer->getValue(), ElementType,
                  true, AccItr->second.DelinearizedSubscripts, Sizes, Val);
   return true;
 }
 
 bool ScopBuilder::buildAccessMemIntrinsic(MemAccInst Inst, ScopStmt *Stmt) {
   auto *MemIntr = dyn_cast_or_null<MemIntrinsic>(Inst);

 
 /// Return the block that is the representing block for @p RN.
 static inline BasicBlock *getRegionNodeBasicBlock(RegionNode *RN) {
   return RN->isSubRegion() ? RN->getNodeAs<Region>()->getEntry()
                            : RN->getNodeAs<BasicBlock>();
 }
 
 void ScopBuilder::buildScop(Region &R, AssumptionCache &AC) {
-  scop.reset(new Scop(R, SE, LI, *SD.getDetectionContext(&R)));
+  scop.reset(new Scop(R, SE, LI, *SD.getDetectionContext(&R), SD.ORE));
 
   buildStmts(R);
   buildAccessFunctions();
 
   // In case the region does not have an exiting block we will later (during
   // code generation) split the exit block. This will move potential PHI nodes
   // from the current exit block into the new region exiting block. Hence, PHI
   // nodes that are at this point not part of the region will be.

 #endif
 }
 
 ScopBuilder::ScopBuilder(Region *R, AssumptionCache &AC, AliasAnalysis &AA,
                          const DataLayout &DL, DominatorTree &DT, LoopInfo &LI,
                          ScopDetection &SD, ScalarEvolution &SE)
     : AA(AA), DL(DL), DT(DT), LI(LI), SD(SD), SE(SE) {
 
-  Function *F = R->getEntry()->getParent();
-
   DebugLoc Beg, End;
-  getDebugLocations(getBBPairForRegion(R), Beg, End);
+  auto P = getBBPairForRegion(R);
+  getDebugLocations(P, Beg, End);
+
   std::string Msg = "SCoP begins here.";
-  emitOptimizationRemarkAnalysis(F->getContext(), DEBUG_TYPE, *F, Beg, Msg);
+  SD.ORE.emit(OptimizationRemarkAnalysis(DEBUG_TYPE, "ScopEntry", Beg, P.first)
+              << Msg);
 
   buildScop(*R, AC);
 
   DEBUG(scop->print(dbgs()));
 
   if (!scop->hasFeasibleRuntimeContext()) {
     InfeasibleScops++;
     Msg = "SCoP ends here but was dismissed.";
     scop.reset();
   } else {
     Msg = "SCoP ends here.";
     ++ScopFound;
     if (scop->getMaxLoopDepth() > 0)
       ++RichScopFound;
   }
 
-  emitOptimizationRemarkAnalysis(F->getContext(), DEBUG_TYPE, *F, End, Msg);
+  if (R->isTopLevelRegion())
+    SD.ORE.emit(OptimizationRemarkAnalysis(DEBUG_TYPE, "ScopEnd", End, P.first)
+                << Msg);
+  else
+    SD.ORE.emit(OptimizationRemarkAnalysis(DEBUG_TYPE, "ScopEnd", End, P.second)
+                << Msg);
 }

polly/trunk/lib/Analysis/ScopDetection.cpp

if (FnName.count(Name) > 0)
       return true;
   return false;
 }
 //===----------------------------------------------------------------------===//
 // ScopDetection.
 
 ScopDetection::ScopDetection(Function &F, const DominatorTree &DT,
                              ScalarEvolution &SE, LoopInfo &LI, RegionInfo &RI,
-                             AliasAnalysis &AA)
-    : DT(DT), SE(SE), LI(LI), RI(RI), AA(AA) {
+                             AliasAnalysis &AA, OptimizationRemarkEmitter &ORE)
+    : DT(DT), SE(SE), LI(LI), RI(RI), AA(AA), ORE(ORE) {
 
   if (!PollyProcessUnprofitable && LI.empty())
     return;
 
   Region *TopRegion = RI.getTopLevelRegion();
 
   if (OnlyFunctions.size() > 0 && !IsFnNameListedInOnlyFunctions(F.getName()))
     return;
for (const Region *R : *this) {
     F.getContext().diagnose(Diagnostic);
   }
 }
 
 void ScopDetection::emitMissedRemarks(const Function &F) {
   for (auto &DIt : DetectionContextMap) {
     auto &DC = DIt.getSecond();
     if (DC.Log.hasErrors())
-      emitRejectionRemarks(DIt.getFirst(), DC.Log);
+      emitRejectionRemarks(DIt.getFirst(), DC.Log, ORE);
   }
 }
 
 bool ScopDetection::isReducibleRegion(Region &R, DebugLoc &DbgLoc) const {
   /// Enum for coloring BBs in Region.
   ///
   /// WHITE - Unvisited BB in DFS walk.
   /// GREY - BBs which are currently on the DFS stack for processing.

 }
 
 bool ScopDetectionWrapperPass::runOnFunction(llvm::Function &F) {
   auto &LI = getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
   auto &RI = getAnalysis<RegionInfoPass>().getRegionInfo();
   auto &AA = getAnalysis<AAResultsWrapperPass>().getAAResults();
   auto &SE = getAnalysis<ScalarEvolutionWrapperPass>().getSE();
   auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
-  Result.reset(new ScopDetection(F, DT, SE, LI, RI, AA));
+  auto &ORE = getAnalysis<OptimizationRemarkEmitterWrapperPass>().getORE();
+  Result.reset(new ScopDetection(F, DT, SE, LI, RI, AA, ORE));
   return false;
 }
 
 void ScopDetectionWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
   AU.addRequired<LoopInfoWrapperPass>();
   AU.addRequiredTransitive<ScalarEvolutionWrapperPass>();
   AU.addRequired<DominatorTreeWrapperPass>();
+  AU.addRequired<OptimizationRemarkEmitterWrapperPass>();
   // We also need AA and RegionInfo when we are verifying analysis.
   AU.addRequiredTransitive<AAResultsWrapperPass>();
   AU.addRequiredTransitive<RegionInfoPass>();
   AU.setPreservesAll();
 }
 
 void ScopDetectionWrapperPass::print(raw_ostream &OS, const Module *) const {
   for (const Region *R : Result->ValidRegions)

 AnalysisKey ScopAnalysis::Key;
 
 ScopDetection ScopAnalysis::run(Function &F, FunctionAnalysisManager &FAM) {
   auto &LI = FAM.getResult<LoopAnalysis>(F);
   auto &RI = FAM.getResult<RegionInfoAnalysis>(F);
   auto &AA = FAM.getResult<AAManager>(F);
   auto &SE = FAM.getResult<ScalarEvolutionAnalysis>(F);
   auto &DT = FAM.getResult<DominatorTreeAnalysis>(F);
-  return {F, DT, SE, LI, RI, AA};
+  auto &ORE = FAM.getResult<OptimizationRemarkEmitterAnalysis>(F);
+  return {F, DT, SE, LI, RI, AA, ORE};
 }
 
 PreservedAnalyses ScopAnalysisPrinterPass::run(Function &F,
                                                FunctionAnalysisManager &FAM) {
   auto &SD = FAM.getResult<ScopAnalysis>(F);
   for (const Region *R : SD.ValidRegions)
     Stream << "Valid Region for Scop: " << R->getNameStr() << '\n';
 
   Stream << "\n";
   return PreservedAnalyses::all();
 }
 
 Pass *polly::createScopDetectionWrapperPassPass() {
   return new ScopDetectionWrapperPass();
 }
 
 INITIALIZE_PASS_BEGIN(ScopDetectionWrapperPass, "polly-detect",
                       "Polly - Detect static control parts (SCoPs)", false,
                       false);
 INITIALIZE_PASS_DEPENDENCY(AAResultsWrapperPass);
 INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass);
 INITIALIZE_PASS_DEPENDENCY(RegionInfoPass);
 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass);
 INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass);
+INITIALIZE_PASS_DEPENDENCY(OptimizationRemarkEmitterWrapperPass);
 INITIALIZE_PASS_END(ScopDetectionWrapperPass, "polly-detect",
                     "Polly - Detect static control parts (SCoPs)", false, false)

polly/trunk/lib/Analysis/ScopDetectionDiagnostic.cpp

 //
 //===----------------------------------------------------------------------===//
 #include "polly/ScopDetectionDiagnostic.h"
 #include "polly/Support/ScopLocation.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/AliasSetTracker.h"
 #include "llvm/Analysis/LoopInfo.h"
+#include "llvm/Analysis/OptimizationDiagnosticInfo.h"
 #include "llvm/Analysis/RegionInfo.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/DebugLoc.h"
 #include "llvm/IR/DiagnosticInfo.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Value.h"
 
for (const Instruction &Inst : *BB) {
         continue;
 
       Begin = Begin ? std::min(Begin, DL) : DL;
       End = End ? std::max(End, DL) : DL;
     }
   }
 }
 
-void emitRejectionRemarks(const BBPair &P, const RejectLog &Log) {
-  Function &F = *P.first->getParent();
-  LLVMContext &Ctx = F.getContext();
-
+void emitRejectionRemarks(const BBPair &P, const RejectLog &Log,
+                          OptimizationRemarkEmitter &ORE) {
   DebugLoc Begin, End;
   getDebugLocations(P, Begin, End);
 
-  emitOptimizationRemarkMissed(
-      Ctx, DEBUG_TYPE, F, Begin,
-      "The following errors keep this region from being a Scop.");
+  ORE.emit(
+      OptimizationRemarkMissed(DEBUG_TYPE, "RejectionErrors", Begin, P.first)
+      << "The following errors keep this region from being a Scop.");
 
   for (RejectReasonPtr RR : Log) {
+
     if (const DebugLoc &Loc = RR->getDebugLoc())
-      emitOptimizationRemarkMissed(Ctx, DEBUG_TYPE, F, Loc,
-                                   RR->getEndUserMessage());
+      ORE.emit(OptimizationRemarkMissed(DEBUG_TYPE, RR->getRemarkName(), Loc,
+                                        RR->getRemarkBB())
+               << RR->getEndUserMessage());
     else
-      emitOptimizationRemarkMissed(Ctx, DEBUG_TYPE, F, Begin,
-                                   RR->getEndUserMessage());
+      ORE.emit(OptimizationRemarkMissed(DEBUG_TYPE, RR->getRemarkName(), Begin,
+                                        RR->getRemarkBB())
+               << RR->getEndUserMessage());
   }
 
-  emitOptimizationRemarkMissed(Ctx, DEBUG_TYPE, F, End,
-                               "Invalid Scop candidate ends here.");
+  /* Check to see if Region is a top level region, getExit = NULL*/
+  if (P.second)
+    ORE.emit(
+        OptimizationRemarkMissed(DEBUG_TYPE, "InvalidScopEnd", End, P.second)
+        << "Invalid Scop candidate ends here.");
+  else
+    ORE.emit(
+        OptimizationRemarkMissed(DEBUG_TYPE, "InvalidScopEnd", End, P.first)
+        << "Invalid Scop candidate ends here.");
 }
 
 //===----------------------------------------------------------------------===//
 // RejectReason.
 
 RejectReason::RejectReason(RejectReasonKind K) : Kind(K) {
   RejectStatistics[static_cast<int>(K)]++;
 }

 bool ReportCFG::classof(const RejectReason *RR) {
   return RR->getKind() >= RejectReasonKind::CFG &&
          RR->getKind() <= RejectReasonKind::LastCFG;
 }
 
 //===----------------------------------------------------------------------===//
 // ReportInvalidTerminator.
 
+std::string ReportInvalidTerminator::getRemarkName() const {
+  return "InvalidTerminator";
+}
+
+const Value *ReportInvalidTerminator::getRemarkBB() const { return BB; }
+
 std::string ReportInvalidTerminator::getMessage() const {
   return ("Invalid instruction terminates BB: " + BB->getName()).str();
 }
 
 const DebugLoc &ReportInvalidTerminator::getDebugLoc() const {
   return BB->getTerminator()->getDebugLoc();
 }
 
 bool ReportInvalidTerminator::classof(const RejectReason *RR) {
   return RR->getKind() == RejectReasonKind::InvalidTerminator;
 }
 
 //===----------------------------------------------------------------------===//
 // UnreachableInExit.
 
+std::string ReportUnreachableInExit::getRemarkName() const {
+  return "UnreachableInExit";
+}
+
+const Value *ReportUnreachableInExit::getRemarkBB() const { return BB; }
+
 std::string ReportUnreachableInExit::getMessage() const {
   std::string BBName = BB->getName();
   return "Unreachable in exit block" + BBName;
 }
 
 const DebugLoc &ReportUnreachableInExit::getDebugLoc() const { return DbgLoc; }
 
 std::string ReportUnreachableInExit::getEndUserMessage() const {
   return "Unreachable in exit block.";
 }
 
 bool ReportUnreachableInExit::classof(const RejectReason *RR) {
   return RR->getKind() == RejectReasonKind::UnreachableInExit;
 }
 
 //===----------------------------------------------------------------------===//
 // ReportIrreducibleRegion.
 
+std::string ReportIrreducibleRegion::getRemarkName() const {
+  return "IrreducibleRegion";
+}
+
+const Value *ReportIrreducibleRegion::getRemarkBB() const {
+  return R->getEntry();
+}
+
 std::string ReportIrreducibleRegion::getMessage() const {
   return "Irreducible region encountered: " + R->getNameStr();
 }
 
 const DebugLoc &ReportIrreducibleRegion::getDebugLoc() const { return DbgLoc; }
 
 std::string ReportIrreducibleRegion::getEndUserMessage() const {
   return "Irreducible region encountered in control flow.";

 bool ReportAffFunc::classof(const RejectReason *RR) {
   return RR->getKind() >= RejectReasonKind::AffFunc &&
          RR->getKind() <= RejectReasonKind::LastAffFunc;
 }
 
 //===----------------------------------------------------------------------===//
 // ReportUndefCond.
 
+std::string ReportUndefCond::getRemarkName() const { return "UndefCond"; }
+
+const Value *ReportUndefCond::getRemarkBB() const { return BB; }
+
 std::string ReportUndefCond::getMessage() const {
   return ("Condition based on 'undef' value in BB: " + BB->getName()).str();
 }
 
 bool ReportUndefCond::classof(const RejectReason *RR) {
   return RR->getKind() == RejectReasonKind::UndefCond;
 }
 
 //===----------------------------------------------------------------------===//
 // ReportInvalidCond.
 
+std::string ReportInvalidCond::getRemarkName() const { return "InvalidCond"; }
+
+const Value *ReportInvalidCond::getRemarkBB() const { return BB; }
+
 std::string ReportInvalidCond::getMessage() const {
   return ("Condition in BB '" + BB->getName()).str() +
          "' neither constant nor an icmp instruction";
 }
 
 bool ReportInvalidCond::classof(const RejectReason *RR) {
   return RR->getKind() == RejectReasonKind::InvalidCond;
 }
 
 //===----------------------------------------------------------------------===//
 // ReportUndefOperand.
 
+std::string ReportUndefOperand::getRemarkName() const { return "UndefOperand"; }
+
+const Value *ReportUndefOperand::getRemarkBB() const { return BB; }
+
 std::string ReportUndefOperand::getMessage() const {
   return ("undef operand in branch at BB: " + BB->getName()).str();
 }
 
 bool ReportUndefOperand::classof(const RejectReason *RR) {
   return RR->getKind() == RejectReasonKind::UndefOperand;
 }
 
 //===----------------------------------------------------------------------===//
 // ReportNonAffBranch.
 
+std::string ReportNonAffBranch::getRemarkName() const { return "NonAffBranch"; }
+
+const Value *ReportNonAffBranch::getRemarkBB() const { return BB; }
+
 std::string ReportNonAffBranch::getMessage() const {
   return ("Non affine branch in BB '" + BB->getName()).str() +
          "' with LHS: " + *LHS + " and RHS: " + *RHS;
 }
 
 bool ReportNonAffBranch::classof(const RejectReason *RR) {
   return RR->getKind() == RejectReasonKind::NonAffBranch;
 }
 
 //===----------------------------------------------------------------------===//
 // ReportNoBasePtr.
 
+std::string ReportNoBasePtr::getRemarkName() const { return "NoBasePtr"; }
+
+const Value *ReportNoBasePtr::getRemarkBB() const { return Inst->getParent(); }
+
 std::string ReportNoBasePtr::getMessage() const { return "No base pointer"; }
 
 bool ReportNoBasePtr::classof(const RejectReason *RR) {
   return RR->getKind() == RejectReasonKind::NoBasePtr;
 }
 
 //===----------------------------------------------------------------------===//
 // ReportUndefBasePtr.
 
+std::string ReportUndefBasePtr::getRemarkName() const { return "UndefBasePtr"; }
+
+const Value *ReportUndefBasePtr::getRemarkBB() const {
+  return Inst->getParent();
+}
+
 std::string ReportUndefBasePtr::getMessage() const {
   return "Undefined base pointer";
 }
 
 bool ReportUndefBasePtr::classof(const RejectReason *RR) {
   return RR->getKind() == RejectReasonKind::UndefBasePtr;
 }
 
 //===----------------------------------------------------------------------===//
 // ReportVariantBasePtr.
 
+std::string ReportVariantBasePtr::getRemarkName() const {
+  return "VariantBasePtr";
+}
+
+const Value *ReportVariantBasePtr::getRemarkBB() const {
+  return Inst->getParent();
+}
+
 std::string ReportVariantBasePtr::getMessage() const {
   return "Base address not invariant in current region:" + *BaseValue;
 }
 
 std::string ReportVariantBasePtr::getEndUserMessage() const {
   return "The base address of this array is not invariant inside the loop";
 }
 
 bool ReportVariantBasePtr::classof(const RejectReason *RR) {
   return RR->getKind() == RejectReasonKind::VariantBasePtr;
 }
 
 //===----------------------------------------------------------------------===//
 // ReportDifferentArrayElementSize
 
+std::string ReportDifferentArrayElementSize::getRemarkName() const {
+  return "DifferentArrayElementSize";
+}
+
+const Value *ReportDifferentArrayElementSize::getRemarkBB() const {
+  return Inst->getParent();
+}
+
 std::string ReportDifferentArrayElementSize::getMessage() const {
   return "Access to one array through data types of different size";
 }
 
 bool ReportDifferentArrayElementSize::classof(const RejectReason *RR) {
   return RR->getKind() == RejectReasonKind::DifferentElementSize;
 }
 
 std::string ReportDifferentArrayElementSize::getEndUserMessage() const {
   llvm::StringRef BaseName = BaseValue->getName();
   std::string Name = (BaseName.size() > 0) ? BaseName : "UNKNOWN";
   return "The array \"" + Name +
          "\" is accessed through elements that differ "
          "in size";
 }
 
 //===----------------------------------------------------------------------===//
 // ReportNonAffineAccess.
 
+std::string ReportNonAffineAccess::getRemarkName() const {
+  return "NonAffineAccess";
+}
+
+const Value *ReportNonAffineAccess::getRemarkBB() const {
+  return Inst->getParent();
+}
+
 std::string ReportNonAffineAccess::getMessage() const {
   return "Non affine access function: " + *AccessFunction;
 }
 
 bool ReportNonAffineAccess::classof(const RejectReason *RR) {
   return RR->getKind() == RejectReasonKind::NonAffineAccess;
 }
 
 std::string ReportNonAffineAccess::getEndUserMessage() const {
   llvm::StringRef BaseName = BaseValue->getName();
   std::string Name = (BaseName.size() > 0) ? BaseName : "UNKNOWN";
   return "The array subscript of \"" + Name + "\" is not affine";
 }
 
 //===----------------------------------------------------------------------===//
 // ReportLoopBound.
 
 ReportLoopBound::ReportLoopBound(Loop *L, const SCEV *LoopCount)
     : RejectReason(RejectReasonKind::LoopBound), L(L), LoopCount(LoopCount),
       Loc(L->getStartLoc()) {}
 
+std::string ReportLoopBound::getRemarkName() const { return "LoopBound"; }
+
+const Value *ReportLoopBound::getRemarkBB() const { return L->getHeader(); }
+
 std::string ReportLoopBound::getMessage() const {
   return "Non affine loop bound '" + *LoopCount +
          "' in loop: " + L->getHeader()->getName();
 }
 
 const DebugLoc &ReportLoopBound::getDebugLoc() const { return Loc; }
 
 bool ReportLoopBound::classof(const RejectReason *RR) {
   return RR->getKind() == RejectReasonKind::LoopBound;
 }
 
 std::string ReportLoopBound::getEndUserMessage() const {
   return "Failed to derive an affine function from the loop bounds.";
 }
 
 //===----------------------------------------------------------------------===//
 // ReportLoopHasNoExit.
 
+std::string ReportLoopHasNoExit::getRemarkName() const {
+  return "LoopHasNoExit";
+}
+
+const Value *ReportLoopHasNoExit::getRemarkBB() const { return L->getHeader(); }
+
 std::string ReportLoopHasNoExit::getMessage() const {
   return "Loop " + L->getHeader()->getName() + " has no exit.";
 }
 
 bool ReportLoopHasNoExit::classof(const RejectReason *RR) {
   return RR->getKind() == RejectReasonKind::LoopHasNoExit;
 }
 
 const DebugLoc &ReportLoopHasNoExit::getDebugLoc() const { return Loc; }
 
 std::string ReportLoopHasNoExit::getEndUserMessage() const {
   return "Loop cannot be handled because it has no exit.";
 }
 
 //===----------------------------------------------------------------------===//
 // ReportLoopOnlySomeLatches
 
+std::string ReportLoopOnlySomeLatches::getRemarkName() const {
+  return "LoopHasNoExit";
+}
+
+const Value *ReportLoopOnlySomeLatches::getRemarkBB() const {
+  return L->getHeader();
+}
+
 std::string ReportLoopOnlySomeLatches::getMessage() const {
   return "Not all latches of loop " + L->getHeader()->getName() +
          " part of scop.";
 }
 
 bool ReportLoopOnlySomeLatches::classof(const RejectReason *RR) {
   return RR->getKind() == RejectReasonKind::LoopHasNoExit;
 }
 
 const DebugLoc &ReportLoopOnlySomeLatches::getDebugLoc() const { return Loc; }
 
 std::string ReportLoopOnlySomeLatches::getEndUserMessage() const {
   return "Loop cannot be handled because not all latches are part of loop "
          "region.";
 }
 
 //===----------------------------------------------------------------------===//
 // ReportFuncCall.
 
 ReportFuncCall::ReportFuncCall(Instruction *Inst)
     : RejectReason(RejectReasonKind::FuncCall), Inst(Inst) {}
 
+std::string ReportFuncCall::getRemarkName() const { return "FuncCall"; }
+
+const Value *ReportFuncCall::getRemarkBB() const { return Inst->getParent(); }
+
 std::string ReportFuncCall::getMessage() const {
   return "Call instruction: " + *Inst;
 }
 
 const DebugLoc &ReportFuncCall::getDebugLoc() const {
   return Inst->getDebugLoc();
 }
 
 std::string ReportFuncCall::getEndUserMessage() const {
   return "This function call cannot be handled. "
          "Try to inline it.";
 }
 
 bool ReportFuncCall::classof(const RejectReason *RR) {
   return RR->getKind() == RejectReasonKind::FuncCall;
 }
 
 //===----------------------------------------------------------------------===//
 // ReportNonSimpleMemoryAccess
 
 ReportNonSimpleMemoryAccess::ReportNonSimpleMemoryAccess(Instruction *Inst)
     : ReportOther(RejectReasonKind::NonSimpleMemoryAccess), Inst(Inst) {}
 
+std::string ReportNonSimpleMemoryAccess::getRemarkName() const {
+  return "NonSimpleMemoryAccess";
+}
+
+const Value *ReportNonSimpleMemoryAccess::getRemarkBB() const {
+  return Inst->getParent();
+}
+
 std::string ReportNonSimpleMemoryAccess::getMessage() const {
   return "Non-simple memory access: " + *Inst;
 }
 
 const DebugLoc &ReportNonSimpleMemoryAccess::getDebugLoc() const {
   return Inst->getDebugLoc();
 }
 
else
       break;
   }
 
   OS << Suffix;
 
   return OS.str();
 }
 
+std::string ReportAlias::getRemarkName() const { return "Alias"; }
+
+const Value *ReportAlias::getRemarkBB() const { return Inst->getParent(); }
+
 std::string ReportAlias::getMessage() const {
   return formatInvalidAlias("Possible aliasing: ");
 }
 
 std::string ReportAlias::getEndUserMessage() const {
   return formatInvalidAlias("Accesses to the arrays ",
                             " may access the same memory.");
 }
 
 const DebugLoc &ReportAlias::getDebugLoc() const { return Inst->getDebugLoc(); }
 
 bool ReportAlias::classof(const RejectReason *RR) {
   return RR->getKind() == RejectReasonKind::Alias;
 }
 
 //===----------------------------------------------------------------------===//
 // ReportOther.
 
+std::string ReportOther::getRemarkName() const { return "UnknownRejectReason"; }
+
 std::string ReportOther::getMessage() const { return "Unknown reject reason"; }
 
 ReportOther::ReportOther(const RejectReasonKind K) : RejectReason(K) {}
 
 bool ReportOther::classof(const RejectReason *RR) {
   return RR->getKind() >= RejectReasonKind::Other &&
          RR->getKind() <= RejectReasonKind::LastOther;
 }
 
 //===----------------------------------------------------------------------===//
 // ReportIntToPtr.
 ReportIntToPtr::ReportIntToPtr(Instruction *BaseValue)
     : ReportOther(RejectReasonKind::IntToPtr), BaseValue(BaseValue) {}
 
+std::string ReportIntToPtr::getRemarkName() const { return "IntToPtr"; }
+
+const Value *ReportIntToPtr::getRemarkBB() const {
+  return BaseValue->getParent();
+}
+
 std::string ReportIntToPtr::getMessage() const {
   return "Find bad intToptr prt: " + *BaseValue;
 }
 
 const DebugLoc &ReportIntToPtr::getDebugLoc() const {
   return BaseValue->getDebugLoc();
 }
 
 bool ReportIntToPtr::classof(const RejectReason *RR) {
   return RR->getKind() == RejectReasonKind::IntToPtr;
 }
 
 //===----------------------------------------------------------------------===//
 // ReportAlloca.
 
 ReportAlloca::ReportAlloca(Instruction *Inst)
     : ReportOther(RejectReasonKind::Alloca), Inst(Inst) {}
 
+std::string ReportAlloca::getRemarkName() const { return "Alloca"; }
+
+const Value *ReportAlloca::getRemarkBB() const { return Inst->getParent(); }
+
 std::string ReportAlloca::getMessage() const {
   return "Alloca instruction: " + *Inst;
 }
 
 const DebugLoc &ReportAlloca::getDebugLoc() const {
   return Inst->getDebugLoc();
 }
 
 bool ReportAlloca::classof(const RejectReason *RR) {
   return RR->getKind() == RejectReasonKind::Alloca;
 }
 
 //===----------------------------------------------------------------------===//
 // ReportUnknownInst.
 
 ReportUnknownInst::ReportUnknownInst(Instruction *Inst)
     : ReportOther(RejectReasonKind::UnknownInst), Inst(Inst) {}
 
+std::string ReportUnknownInst::getRemarkName() const { return "UnknownInst"; }
+
+const Value *ReportUnknownInst::getRemarkBB() const {
+  return Inst->getParent();
+}
+
 std::string ReportUnknownInst::getMessage() const {
   return "Unknown instruction: " + *Inst;
 }
 
 const DebugLoc &ReportUnknownInst::getDebugLoc() const {
   return Inst->getDebugLoc();
 }
 
 bool ReportUnknownInst::classof(const RejectReason *RR) {
   return RR->getKind() == RejectReasonKind::UnknownInst;
 }
 
 //===----------------------------------------------------------------------===//
 // ReportEntry.
 ReportEntry::ReportEntry(BasicBlock *BB)
     : ReportOther(RejectReasonKind::Entry), BB(BB) {}
 
+std::string ReportEntry::getRemarkName() const { return "Entry"; }
+
+const Value *ReportEntry::getRemarkBB() const { return BB; }
+
 std::string ReportEntry::getMessage() const {
   return "Region containing entry block of function is invalid!";
 }
 
 std::string ReportEntry::getEndUserMessage() const {
   return "Scop contains function entry (not yet supported).";
 }
 
 const DebugLoc &ReportEntry::getDebugLoc() const {
   return BB->getTerminator()->getDebugLoc();
 }
 
 bool ReportEntry::classof(const RejectReason *RR) {
   return RR->getKind() == RejectReasonKind::Entry;
 }
 
 //===----------------------------------------------------------------------===//
 // ReportUnprofitable.
 ReportUnprofitable::ReportUnprofitable(Region *R)
     : ReportOther(RejectReasonKind::Unprofitable), R(R) {}
 
+std::string ReportUnprofitable::getRemarkName() const { return "Unprofitable"; }
+
+const Value *ReportUnprofitable::getRemarkBB() const { return R->getEntry(); }
+
 std::string ReportUnprofitable::getMessage() const {
   return "Region can not profitably be optimized!";
 }
 
 std::string ReportUnprofitable::getEndUserMessage() const {
   return "No profitable polyhedral optimization found";
 }
 

polly/trunk/lib/Analysis/ScopInfo.cpp

buildConditionSets(Scop &S, BasicBlock *BB, Value *Condition,
   if (!TooComplex) {
     AlternativeCondSet = isl_set_subtract(isl_set_copy(Domain),
                                           isl_set_copy(ConsequenceCondSet));
     TooComplex =
         isl_set_n_basic_set(AlternativeCondSet) >= MaxDisjunctsInDomain;
   }
 
   if (TooComplex) {
-    S.invalidate(COMPLEXITY, TI ? TI->getDebugLoc() : DebugLoc());
+    S.invalidate(COMPLEXITY, TI ? TI->getDebugLoc() : DebugLoc(),
+                 TI ? TI->getParent() : nullptr /* BasicBlock */);
     isl_set_free(AlternativeCondSet);
     isl_set_free(ConsequenceCondSet);
     return false;
   }
 
   ConditionSets.push_back(ConsequenceCondSet);
   ConditionSets.push_back(isl_set_coalesce(AlternativeCondSet));
 

 
 bool Scop::isDominatedBy(const DominatorTree &DT, BasicBlock *BB) const {
   return DT.dominates(BB, getEntry());
 }
 
 void Scop::addUserAssumptions(
     AssumptionCache &AC, DominatorTree &DT, LoopInfo &LI,
     DenseMap<BasicBlock *, isl::set> &InvalidDomainMap) {
-  auto &F = getFunction();
   for (auto &Assumption : AC.assumptions()) {
     auto *CI = dyn_cast_or_null<CallInst>(Assumption);
     if (!CI || CI->getNumArgOperands() != 1)
       continue;
 
     bool InScop = contains(CI);
     if (!InScop && !isDominatedBy(DT, CI->getParent()))
       continue;
 
     auto *L = LI.getLoopFor(CI->getParent());
     auto *Val = CI->getArgOperand(0);
     ParameterSetTy DetectedParams;
     if (!isAffineConstraint(Val, &R, L, *SE, DetectedParams)) {
-      emitOptimizationRemarkAnalysis(F.getContext(), DEBUG_TYPE, F,
-                                     CI->getDebugLoc(),
-                                     "Non-affine user assumption ignored.");
+      ORE.emit(
+          OptimizationRemarkAnalysis(DEBUG_TYPE, "IgnoreUserAssumption", CI)
+          << "Non-affine user assumption ignored.");
       continue;
     }
 
     // Collect all newly introduced parameters.
     ParameterSetTy NewParams;
     for (auto *Param : DetectedParams) {
       Param = extractConstantFactor(Param, *SE).second;
       Param = getRepresentingInvariantLoadSCEV(Param);
if (!NewParams.empty()) {
 
         if (!NewParams.count(Param))
           continue;
 
         AssumptionCtx =
             isl_set_project_out(AssumptionCtx, isl_dim_param, u--, 1);
       }
     }
-
-    emitOptimizationRemarkAnalysis(
-        F.getContext(), DEBUG_TYPE, F, CI->getDebugLoc(),
-        "Use user assumption: " + stringFromIslObj(AssumptionCtx));
+    ORE.emit(OptimizationRemarkAnalysis(DEBUG_TYPE, "UserAssumption", CI)
+             << "Use user assumption: " << stringFromIslObj(AssumptionCtx));
     Context = isl_set_intersect(Context, AssumptionCtx);
   }
 }
 
 void Scop::addUserContext() {
   if (UserContextStr.empty())
     return;
 
for (unsigned u = 0; u < NumSuccs; u++) {
       InvalidDomainMap[SuccBB] = isl::manage(SuccInvalidDomain);
 
       // Check if the maximal number of domain disjunctions was reached.
       // In case this happens we will bail.
       if (NumConjucts < MaxDisjunctsInDomain)
         continue;
 
       InvalidDomainMap.erase(BB);
-      invalidate(COMPLEXITY, TI->getDebugLoc());
+      invalidate(COMPLEXITY, TI->getDebugLoc(), TI->getParent());
       return false;
     }
 
     InvalidDomainMap[BB] = InvalidDomain;
   }
 
   return true;
 }

 
 bool Scop::buildAliasGroup(Scop::AliasGroupTy &AliasGroup,
                            DenseSet<const ScopArrayInfo *> HasWriteAccess) {
   AliasGroupTy ReadOnlyAccesses;
   AliasGroupTy ReadWriteAccesses;
   SmallPtrSet<const ScopArrayInfo *, 4> ReadWriteArrays;
   SmallPtrSet<const ScopArrayInfo *, 4> ReadOnlyArrays;
 
-  auto &F = getFunction();
-
   if (AliasGroup.size() < 2)
     return true;
 
   for (MemoryAccess *Access : AliasGroup) {
-    emitOptimizationRemarkAnalysis(
-        F.getContext(), DEBUG_TYPE, F,
-        Access->getAccessInstruction()->getDebugLoc(),
-        "Possibly aliasing pointer, use restrict keyword.");
-
+    ORE.emit(OptimizationRemarkAnalysis(DEBUG_TYPE, "PossibleAlias",
+                                        Access->getAccessInstruction())
+             << "Possibly aliasing pointer, use restrict keyword.");
     const ScopArrayInfo *Array = Access->getScopArrayInfo();
     if (HasWriteAccess.count(Array)) {
       ReadWriteArrays.insert(Array);
       ReadWriteAccesses.push_back(Access);
     } else {
       ReadOnlyArrays.insert(Array);
       ReadOnlyAccesses.push_back(Access);
     }
   }
 
   // If there are no read-only pointers, and less than two read-write pointers,
   // no alias check is needed.
   if (ReadOnlyAccesses.empty() && ReadWriteArrays.size() <= 1)
     return true;
 
   // If there is no read-write pointer, no alias check is needed.
   if (ReadWriteArrays.empty())
     return true;
 
   // For non-affine accesses, no alias check can be generated as we cannot
   // compute a sufficiently tight lower and upper bound: bail out.
   for (MemoryAccess *MA : AliasGroup) {
     if (!MA->isAffine()) {
-      invalidate(ALIASING, MA->getAccessInstruction()->getDebugLoc());
+      invalidate(ALIASING, MA->getAccessInstruction()->getDebugLoc(),
+                 MA->getAccessInstruction()->getParent());
       return false;
     }
   }
 
   // Ensure that for all memory accesses for which we generate alias checks,
   // their base pointers are available.
   for (MemoryAccess *MA : AliasGroup) {
     if (MemoryAccess *BasePtrMA = lookupBasePtrAccess(MA))
int Scop::getNextID(std::string ParentFunc) {
   if (ParentFunc != CurrentFunc) {
     CurrentFunc = ParentFunc;
     NextScopID = 0;
   }
   return NextScopID++;
 }
 
 Scop::Scop(Region &R, ScalarEvolution &ScalarEvolution, LoopInfo &LI,
-           ScopDetection::DetectionContext &DC)
+           ScopDetection::DetectionContext &DC, OptimizationRemarkEmitter &ORE)
     : SE(&ScalarEvolution), R(R), name(R.getNameStr()), IsOptimized(false),
       HasSingleExitEdge(R.getExitingBlock()), HasErrorBlock(false),
-      MaxLoopDepth(0), CopyStmtsNum(0), SkipScop(false), DC(DC),
+      MaxLoopDepth(0), CopyStmtsNum(0), SkipScop(false), DC(DC), ORE(ORE),
       IslCtx(isl_ctx_alloc(), isl_ctx_free), Context(nullptr),
       Affinator(this, LI), AssumedContext(nullptr), InvalidContext(nullptr),
       Schedule(nullptr),
       ID(getNextID((*R.getEntry()->getParent()).getName().str())) {
   if (IslOnErrorAbort)
     isl_options_set_on_error(getIslCtx(), ISL_ON_ERROR_ABORT);
   buildContext();
 }
void Scop::addInvariantLoads(ScopStmt &Stmt, InvariantAccessesTy &InvMAs) {
 
   // Get the context under which the statement is executed but remove the error
   // context under which this statement is reached.
   isl_set *DomainCtx = isl_set_params(Stmt.getDomain());
   DomainCtx = isl_set_subtract(DomainCtx, StmtInvalidCtx);
 
   if (isl_set_n_basic_set(DomainCtx) >= MaxDisjunctsInDomain) {
     auto *AccInst = InvMAs.front().MA->getAccessInstruction();
-    invalidate(COMPLEXITY, AccInst->getDebugLoc());
+    invalidate(COMPLEXITY, AccInst->getDebugLoc(), AccInst->getParent());
     isl_set_free(DomainCtx);
     for (auto &InvMA : InvMAs)
       isl_set_free(InvMA.NonHoistableCtx);
     return;
   }
 
   // Project out all parameters that relate to loads in the statement. Otherwise
   // we could have cyclic dependences on the constraints under which the
isl::set Scop::getNonHoistableCtx(MemoryAccess *Access, isl::union_map Writes) {
 
   WrittenCtx = WrittenCtx.remove_divs();
   bool TooComplex =
       isl_set_n_basic_set(WrittenCtx.get()) >= MaxDisjunctsInDomain;
   if (TooComplex || !isRequiredInvariantLoad(LI))
     return nullptr;
 
   addAssumption(INVARIANTLOAD, WrittenCtx.copy(), LI->getDebugLoc(),
-                AS_RESTRICTION);
+                AS_RESTRICTION, LI->getParent());
   return WrittenCtx;
 }
 
 void Scop::verifyInvariantLoads() {
   auto &RIL = getRequiredInvariantLoads();
   for (LoadInst *LI : RIL) {
     assert(LI && contains(LI));
     ScopStmt *Stmt = getStmtFor(LI);
     if (Stmt && Stmt->getArrayAccessOrNULLFor(LI)) {
-      invalidate(INVARIANTLOAD, LI->getDebugLoc());
+      invalidate(INVARIANTLOAD, LI->getDebugLoc(), LI->getParent());
       return;
     }
   }
 }
 
 void Scop::hoistInvariantLoads() {
   if (!PollyInvariantLoadHoisting)
     return;
if (Sign == AS_ASSUMPTION) {
 
     if (isl_set_is_subset(Set, InvalidContext))
       return false;
   }
   return true;
 }
 
 bool Scop::trackAssumption(AssumptionKind Kind, __isl_keep isl_set *Set,
-                           DebugLoc Loc, AssumptionSign Sign) {
+                           DebugLoc Loc, AssumptionSign Sign, BasicBlock *BB) {
   if (PollyRemarksMinimal && !isEffectiveAssumption(Set, Sign))
     return false;
 
   // Do never emit trivial assumptions as they only clutter the output.
   if (!PollyRemarksMinimal) {
     isl_set *Univ = nullptr;
     if (Sign == AS_ASSUMPTION)
       Univ = isl_set_universe(isl_set_get_space(Set));
bool Scop::trackAssumption(AssumptionKind Kind, __isl_keep isl_set *Set,
   case INVARIANTLOAD:
     AssumptionsInvariantLoad++;
     break;
   case DELINEARIZATION:
     AssumptionsDelinearization++;
     break;
   }
 
-  auto &F = getFunction();
   auto Suffix = Sign == AS_ASSUMPTION ? " assumption:\t" : " restriction:\t";
   std::string Msg = toString(Kind) + Suffix + stringFromIslObj(Set);
-  emitOptimizationRemarkAnalysis(F.getContext(), DEBUG_TYPE, F, Loc, Msg);
+  if (BB)
+    ORE.emit(OptimizationRemarkAnalysis(DEBUG_TYPE, "AssumpRestrict", Loc, BB)
+             << Msg);
+  else
+    ORE.emit(OptimizationRemarkAnalysis(DEBUG_TYPE, "AssumpRestrict", Loc,
+                                        R.getEntry())
+             << Msg);
   return true;
 }
 
 void Scop::addAssumption(AssumptionKind Kind, __isl_take isl_set *Set,
-                         DebugLoc Loc, AssumptionSign Sign) {
+                         DebugLoc Loc, AssumptionSign Sign, BasicBlock *BB) {
   // Simplify the assumptions/restrictions first.
   Set = isl_set_gist_params(Set, getContext());
 
-  if (!trackAssumption(Kind, Set, Loc, Sign)) {
+  if (!trackAssumption(Kind, Set, Loc, Sign, BB)) {
     isl_set_free(Set);
     return;
   }
 
   if (Sign == AS_ASSUMPTION) {
     AssumedContext = isl_set_intersect(AssumedContext, Set);
     AssumedContext = isl_set_coalesce(AssumedContext);
   } else {
void Scop::recordAssumption(AssumptionKind Kind, __isl_take isl_set *Set,
   RecordedAssumptions.push_back({Kind, Sign, Set, Loc, BB});
 }
 
 void Scop::addRecordedAssumptions() {
   while (!RecordedAssumptions.empty()) {
     const Assumption &AS = RecordedAssumptions.pop_back_val();
 
     if (!AS.BB) {
-      addAssumption(AS.Kind, AS.Set, AS.Loc, AS.Sign);
+      addAssumption(AS.Kind, AS.Set, AS.Loc, AS.Sign, nullptr /* BasicBlock */);
       continue;
     }
 
     // If the domain was deleted the assumptions are void.
     isl_set *Dom = getDomainConditions(AS.BB);
     if (!Dom) {
       isl_set_free(AS.Set);
       continue;
while (!RecordedAssumptions.empty()) {
     // To avoid the complement we will register A - B as a restriction not an
     // assumption.
     isl_set *S = AS.Set;
     if (AS.Sign == AS_RESTRICTION)
       S = isl_set_params(isl_set_intersect(S, Dom));
     else /* (AS.Sign == AS_ASSUMPTION) */
       S = isl_set_params(isl_set_subtract(Dom, S));
 
-    addAssumption(AS.Kind, S, AS.Loc, AS_RESTRICTION);
+    addAssumption(AS.Kind, S, AS.Loc, AS_RESTRICTION, AS.BB);
   }
 }
 
-void Scop::invalidate(AssumptionKind Kind, DebugLoc Loc) {
-  addAssumption(Kind, isl_set_empty(getParamSpace()), Loc, AS_ASSUMPTION);
+void Scop::invalidate(AssumptionKind Kind, DebugLoc Loc, BasicBlock *BB) {
+  addAssumption(Kind, isl_set_empty(getParamSpace()), Loc, AS_ASSUMPTION, BB);
 }
 
 __isl_give isl_set *Scop::getInvalidContext() const {
   return isl_set_copy(InvalidContext);
 }
 
 void Scop::printContext(raw_ostream &OS) const {
   OS << "Context:\n";
if (PWAC.first) {
     //         SCEVAffinator::interpretAsUnsigned
     //       to deal with unsigned or "NonNegative" SCEVs.
     if (NonNegative)
       Affinator.takeNonNegativeAssumption(PWAC);
     return PWAC;
   }
 
   auto DL = BB ? BB->getTerminator()->getDebugLoc() : DebugLoc();
-  invalidate(COMPLEXITY, DL);
+  invalidate(COMPLEXITY, DL, BB);
   return Affinator.getPwAff(SE->getZero(E->getType()), BB);
 }
 
 __isl_give isl_union_set *Scop::getDomains() const {
   isl_space *EmptySpace = isl_space_params_alloc(getIslCtx(), 0);
   isl_union_set *Domain = isl_union_set_empty(EmptySpace);
 
   for (const ScopStmt &Stmt : *this)

polly/trunk/test/ScopDetectionDiagnostics/ReportUnprofitable.ll

 ; RUN: opt %loadPolly -pass-remarks-missed="polly-detect" \
 ; RUN:     -polly-detect-track-failures -polly-detect -analyze \
 ; RUN:     -polly-process-unprofitable=false < %s 2>&1| FileCheck %s
+
+; RUN: opt %loadPolly -pass-remarks-missed="polly-detect" \
+; RUN:     -polly-detect-track-failures -polly-detect -analyze \
+; RUN:     -polly-process-unprofitable=false < %s 2>&1 -pass-remarks-output=%t.yaml
+; RUN: cat %t.yaml | FileCheck -check-prefix=YAML %s
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 ; void onlyWrite(float *A) {
 ;   for (long i = 0; i < 100; i++)
 ;     A[i] = 0;
 ; }
-; 
+;
 ; void onlyRead(float *A) {
 ;   for (long i = 0; i < 100; i++)
 ;     A[i];
 ; }
 
 ; CHECK: remark: /tmp/test.c:2:3: The following errors keep this region from being a Scop.
 ; CHECK: remark: /tmp/test.c:2:3: No profitable polyhedral optimization found
 ; CHECK: remark: /tmp/test.c:3:10: Invalid Scop candidate ends here.
 
 ; CHECK: remark: /tmp/test.c:7:3: The following errors keep this region from being a Scop.
 ; CHECK: remark: /tmp/test.c:7:3: No profitable polyhedral optimization found
 ; CHECK: remark: /tmp/test.c:8:10: Invalid Scop candidate ends here.
 
+; YAML: --- !Missed
+; YAML: Pass:            polly-detect
+; YAML: Name:            RejectionErrors
+; YAML: DebugLoc:        { File: /tmp/test.c, Line: 2, Column: 3 }
+; YAML: Function:        onlyWrite
+; YAML: Args:
+; YAML:   - String:          The following errors keep this region from being a Scop.
+; YAML: ...
+; YAML: --- !Missed
+; YAML: Pass:            polly-detect
+; YAML: Name:            Unprofitable
+; YAML: DebugLoc:        { File: /tmp/test.c, Line: 2, Column: 3 }
+; YAML: Function:        onlyWrite
+; YAML: Args:
+; YAML:   - String:          No profitable polyhedral optimization found
+; YAML: ...
+; YAML: --- !Missed
+; YAML: Pass:            polly-detect
+; YAML: Name:            InvalidScopEnd
+; YAML: DebugLoc:        { File: /tmp/test.c, Line: 3, Column: 10 }
+; YAML: Function:        onlyWrite
+; YAML: Args:
+; YAML:   - String:          Invalid Scop candidate ends here.
+; YAML: ...
+; YAML: --- !Missed
+; YAML: Pass:            polly-detect
+; YAML: Name:            RejectionErrors
+; YAML: DebugLoc:        { File: /tmp/test.c, Line: 7, Column: 3 }
+; YAML: Function:        onlyRead
+; YAML: Args:
+; YAML:   - String:          The following errors keep this region from being a Scop.
+; YAML: ...
+; YAML: --- !Missed
+; YAML: Pass:            polly-detect
+; YAML: Name:            Unprofitable
+; YAML: DebugLoc:        { File: /tmp/test.c, Line: 7, Column: 3 }
+; YAML: Function:        onlyRead
+; YAML: Args:
+; YAML:   - String:          No profitable polyhedral optimization found
+; YAML: ...
+; YAML: --- !Missed
+; YAML: Pass:            polly-detect
+; YAML: Name:            InvalidScopEnd
+; YAML: DebugLoc:        { File: /tmp/test.c, Line: 8, Column: 10 }
+; YAML: Function:        onlyRead
+; YAML: Args:
+; YAML:   - String:          Invalid Scop candidate ends here.
+
 
 ; Function Attrs: nounwind uwtable
 define void @onlyWrite(float* %A) #0 !dbg !4 {
 entry:
   call void @llvm.dbg.value(metadata float* %A, i64 0, metadata !14, metadata !15), !dbg !16
   call void @llvm.dbg.value(metadata i64 0, i64 0, metadata !17, metadata !15), !dbg !20
   br label %for.cond, !dbg !21
 

polly/trunk/test/ScopInfo/user_provided_non_dominating_assumptions.ll

 ;        __builtin_assume(N >= 0);
 ;        for (int j = 0; j != M; j++) {
 ;          __builtin_assume(N >= 0);
 ;          C[i][j] += A[i * M + j] + B[i + j];
 ;        }
 ;      }
 ;    }
 ;
+
+
+; RUN: opt %loadPolly -pass-remarks-analysis="polly-scops" -polly-scops \
+; RUN:    -polly-precise-inbounds -disable-output < %s 2>&1 -pass-remarks-output=%t.yaml
+; RUN: cat %t.yaml | FileCheck -check-prefix=YAML %s
+; YAML: --- !Analysis
+; YAML: Pass:            polly-scops
+; YAML: Name:            ScopEntry
+; YAML: Function:        f
+; YAML: Args:
+; YAML:   - String:          SCoP begins here.
+; YAML: ...
+; YAML: --- !Analysis
+; YAML: Pass:            polly-scops
+; YAML: Name:            UserAssumption
+; YAML: Function:        f
+; YAML: Args:
+; YAML:   - String:          'Use user assumption: '
+; YAML:   - String:          '[i, N, M] -> {  : N <= i or (N > i and N >= 0) }'
+; YAML: ...
+; YAML: --- !Analysis
+; YAML: Pass:            polly-scops
+; YAML: Name:            AssumpRestrict
+; YAML: Function:        f
+; YAML: Args:
+; YAML:   - String:          'Inbounds assumption:      [i, N, M] -> {  : N <= i or (N > i and M <= 100) }'
+; YAML: ...
+; YAML: --- !Analysis
+; YAML: Pass:            polly-scops
+; YAML: Name:            ScopEnd
+; YAML: Function:        f
+; YAML: Args:
+; YAML:   - String:          SCoP ends here.
+; YAML: ...
+
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 define void @f(i32* noalias %A, i32* noalias %B, i32 %i, i32 %N, i32 %M, [100 x i32]* %C) {
 entry:
   %tmp = zext i32 %M to i64
   %tmp6 = sext i32 %i to i64
   %tmp7 = sext i32 %N to i64
   %tmp8 = sext i32 %M to i64