Summary: This patch outputs all the list of instructions in BlockStmts.
Reviewers: Meinersbur, grosser, bollu
Subscribers: bollu, llvm-commits, pollydev
Differential Revision: https://reviews.llvm.org/D33163
llvm-svn: 304062
const ScopStmt &operator=(const ScopStmt &) = delete;
/// Create the ScopStmt from a BasicBlock.
- ScopStmt(Scop &parent, BasicBlock &bb, Loop *SurroundingLoop);
+ ScopStmt(Scop &parent, BasicBlock &bb, Loop *SurroundingLoop,
+ std::vector<Instruction *> Instructions);
/// Create an overapproximating ScopStmt for the region @p R.
ScopStmt(Scop &parent, Region &R, Loop *SurroundingLoop);
/// The closest loop that contains this statement.
Loop *SurroundingLoop;
+ /// Vector for Instructions in a BB.
+ std::vector<Instruction *> Instructions;
+
/// Build the statement.
//@{
void buildDomain();
/// @param OS The output stream the ScopStmt is printed to.
void print(raw_ostream &OS) const;
+ /// Print the instructions in ScopStmt.
+ ///
+ void printInstructions(raw_ostream &OS) const;
+
/// Print the ScopStmt to stderr.
void dump() const;
};
///
/// @param BB The basic block we build the statement for.
/// @param SurroundingLoop The loop the created statement is contained in.
- void addScopStmt(BasicBlock *BB, Loop *SurroundingLoop);
+ /// @param Instructions The instructions in the basic block.
+ void addScopStmt(BasicBlock *BB, Loop *SurroundingLoop,
+ std::vector<Instruction *> Instructions);
/// Create a new SCoP statement for @p R.
///
if (I->isSubRegion())
buildStmts(*I->getNodeAs<Region>());
else {
+ std::vector<Instruction *> Instructions;
+ for (Instruction &Inst : *I->getNodeAs<BasicBlock>())
+ Instructions.push_back(&Inst);
Loop *SurroundingLoop = LI.getLoopFor(I->getNodeAs<BasicBlock>());
- scop->addScopStmt(I->getNodeAs<BasicBlock>(), SurroundingLoop);
+ scop->addScopStmt(I->getNodeAs<BasicBlock>(), SurroundingLoop,
+ Instructions);
}
}
cl::location(UseInstructionNames), cl::Hidden, cl::init(false),
cl::ZeroOrMore, cl::cat(PollyCategory));
+static cl::opt<bool> PollyPrintInstructions(
+ "polly-print-instructions", cl::desc("Output instructions per ScopStmt"),
+ cl::Hidden, cl::Optional, cl::init(false), cl::cat(PollyCategory));
+
//===----------------------------------------------------------------------===//
// Create a sequence of two schedules. Either argument may be null and is
"Stmt", R.getNameStr(), parent.getNextStmtIdx(), "", UseInstructionNames);
}
-ScopStmt::ScopStmt(Scop &parent, BasicBlock &bb, Loop *SurroundingLoop)
+ScopStmt::ScopStmt(Scop &parent, BasicBlock &bb, Loop *SurroundingLoop,
+ std::vector<Instruction *> Instructions)
: Parent(parent), InvalidDomain(nullptr), Domain(nullptr), BB(&bb),
- R(nullptr), Build(nullptr), SurroundingLoop(SurroundingLoop) {
+ R(nullptr), Build(nullptr), SurroundingLoop(SurroundingLoop),
+ Instructions(Instructions) {
BaseName = getIslCompatibleName("Stmt", &bb, parent.getNextStmtIdx(), "",
UseInstructionNames);
isl_set_free(InvalidDomain);
}
+void ScopStmt::printInstructions(raw_ostream &OS) const {
+ OS << "Instructions {\n";
+
+ for (Instruction *Inst : Instructions)
+ OS.indent(16) << *Inst << "\n";
+
+ OS.indent(16) << "}\n";
+}
+
void ScopStmt::print(raw_ostream &OS) const {
OS << "\t" << getBaseName() << "\n";
OS.indent(12) << "Domain :=\n";
for (MemoryAccess *Access : MemAccs)
Access->print(OS);
+
+ if (PollyPrintInstructions)
+ printInstructions(OS.indent(12));
}
void ScopStmt::dump() const { print(dbgs()); }
return isl::multi_union_pw_aff(isl::union_pw_multi_aff(Result));
}
-void Scop::addScopStmt(BasicBlock *BB, Loop *SurroundingLoop) {
+void Scop::addScopStmt(BasicBlock *BB, Loop *SurroundingLoop,
+ std::vector<Instruction *> Instructions) {
assert(BB && "Unexpected nullptr!");
- Stmts.emplace_back(*this, *BB, SurroundingLoop);
+ Stmts.emplace_back(*this, *BB, SurroundingLoop, Instructions);
auto *Stmt = &Stmts.back();
StmtMap[BB] = Stmt;
}
--- /dev/null
+; RUN: opt %loadPolly -polly-scops -analyze -polly-print-instructions < %s | FileCheck %s
+
+; void func(int *A, int *B){
+; for (int i = 0; i < 1024; i+=1) {
+; Stmt:
+; A[i] = i;
+; B[i] = i;
+; }
+; }
+
+; CHECK: Instructions {
+; CHECK-NEXT: %idxprom = sext i32 %i.0 to i64
+; CHECK-NEXT: %arrayidx = getelementptr inbounds i32, i32* %A, i64 %idxprom
+; CHECK-NEXT: store i32 %i.0, i32* %arrayidx, align 4
+; CHECK-NEXT: %idxprom1 = sext i32 %i.0 to i64
+; CHECK-NEXT: %arrayidx2 = getelementptr inbounds i32, i32* %B, i64 %idxprom1
+; CHECK-NEXT: store i32 %i.0, i32* %arrayidx2, align 4
+; CHECK-NEXT: br label %for.inc
+; CHECK-NEXT: }
+
+; Function Attrs: noinline nounwind uwtable
+define void @func(i32* %A, i32* %B) #0 {
+entry:
+ br label %for.cond
+
+for.cond: ; preds = %for.inc, %entry
+ %i.0 = phi i32 [ 0, %entry ], [ %add, %for.inc ]
+ %cmp = icmp slt i32 %i.0, 1024
+ br i1 %cmp, label %for.body, label %for.end
+
+for.body: ; preds = %for.cond
+ br label %Stmt
+
+Stmt: ; preds = %for.body
+ %idxprom = sext i32 %i.0 to i64
+ %arrayidx = getelementptr inbounds i32, i32* %A, i64 %idxprom
+ store i32 %i.0, i32* %arrayidx, align 4
+ %idxprom1 = sext i32 %i.0 to i64
+ %arrayidx2 = getelementptr inbounds i32, i32* %B, i64 %idxprom1
+ store i32 %i.0, i32* %arrayidx2, align 4
+ br label %for.inc
+
+for.inc: ; preds = %Stmt
+ %add = add nsw i32 %i.0, 1
+ br label %for.cond
+
+for.end: ; preds = %for.cond
+ ret void
+}