namespace {
class IslGenerator {
public:
- IslGenerator(IRBuilder<> &Builder, std::vector<Value *> &IVS) :
- Builder(Builder), IVS(IVS) {}
+ IslGenerator(IRBuilder<> &Builder, std::vector<Value *> &IVS)
+ : Builder(Builder), IVS(IVS) {}
Value *generateIslInt(__isl_take isl_int Int);
Value *generateIslAff(__isl_take isl_aff *Aff);
Value *generateIslPwAff(__isl_take isl_pw_aff *PwAff);
unsigned int NbInputDims = isl_aff_dim(Aff, isl_dim_in);
- assert((IVS.size() == NbInputDims) && "The Dimension of Induction Variables"
- "must match the dimension of the affine space.");
+ assert((IVS.size() == NbInputDims) &&
+ "The Dimension of Induction Variables must match the dimension of the "
+ "affine space.");
isl_int CoefficientIsl;
isl_int_init(CoefficientIsl);
__isl_take isl_aff *Aff, void *User) {
IslGenInfo *GenInfo = (IslGenInfo *)User;
- assert((GenInfo->Result == NULL) && "Result is already set."
- "Currently only single isl_aff is supported");
- assert(isl_set_plain_is_universe(Set)
- && "Code generation failed because the set is not universe");
+ assert((GenInfo->Result == NULL) &&
+ "Result is already set. Currently only single isl_aff is supported");
+ assert(isl_set_plain_is_universe(Set) &&
+ "Code generation failed because the set is not universe");
GenInfo->Result = GenInfo->Generator->generateIslAff(Aff);
return User.Result;
}
-
-BlockGenerator::BlockGenerator(IRBuilder<> &B, ScopStmt &Stmt, Pass *P):
- Builder(B), Statement(Stmt), P(P), SE(P->getAnalysis<ScalarEvolution>()) {}
+BlockGenerator::BlockGenerator(IRBuilder<> &B, ScopStmt &Stmt, Pass *P)
+ : Builder(B), Statement(Stmt), P(P), SE(P->getAnalysis<ScalarEvolution>()) {
+}
bool BlockGenerator::isSCEVIgnore(const Instruction *Inst) {
if (SCEVCodegen && SE.isSCEVable(Inst->getType()))
Value *BlockGenerator::getNewAccessOperand(
__isl_keep isl_map *NewAccessRelation, Value *BaseAddress, ValueMapT &BBMap,
ValueMapT &GlobalMap, LoopToScevMapT <S) {
- std::vector<Value *> IndexArray =
- getMemoryAccessIndex(NewAccessRelation, BaseAddress, BBMap, GlobalMap,
- LTS);
+ std::vector<Value *> IndexArray = getMemoryAccessIndex(
+ NewAccessRelation, BaseAddress, BBMap, GlobalMap, LTS);
Value *NewOperand =
Builder.CreateGEP(BaseAddress, IndexArray, "p_newarrayidx_");
return NewOperand;
NewPointer = getNewValue(Pointer, BBMap, GlobalMap, LTS);
} else {
Value *BaseAddress = const_cast<Value *>(Access.getBaseAddr());
- NewPointer =
- getNewAccessOperand(NewAccessRelation, BaseAddress, BBMap, GlobalMap,
- LTS);
+ NewPointer = getNewAccessOperand(NewAccessRelation, BaseAddress, BBMap,
+ GlobalMap, LTS);
}
isl_map_free(CurrentAccessRelation);
return NewPointer;
}
-Value *BlockGenerator::generateScalarLoad(
- const LoadInst *Load, ValueMapT &BBMap, ValueMapT &GlobalMap,
- LoopToScevMapT <S) {
+Value *
+BlockGenerator::generateScalarLoad(const LoadInst *Load, ValueMapT &BBMap,
+ ValueMapT &GlobalMap, LoopToScevMapT <S) {
const Value *Pointer = Load->getPointerOperand();
const Instruction *Inst = dyn_cast<Instruction>(Load);
- Value *NewPointer = generateLocationAccessed(Inst, Pointer, BBMap, GlobalMap,
- LTS);
+ Value *NewPointer =
+ generateLocationAccessed(Inst, Pointer, BBMap, GlobalMap, LTS);
Value *ScalarLoad =
Builder.CreateLoad(NewPointer, Load->getName() + "_p_scalar_");
return ScalarLoad;
}
-Value *BlockGenerator::generateScalarStore(
- const StoreInst *Store, ValueMapT &BBMap, ValueMapT &GlobalMap,
- LoopToScevMapT <S) {
+Value *
+BlockGenerator::generateScalarStore(const StoreInst *Store, ValueMapT &BBMap,
+ ValueMapT &GlobalMap, LoopToScevMapT <S) {
const Value *Pointer = Store->getPointerOperand();
Value *NewPointer =
generateLocationAccessed(Store, Pointer, BBMap, GlobalMap, LTS);
- Value *ValueOperand = getNewValue(Store->getValueOperand(), BBMap, GlobalMap,
- LTS);
+ Value *ValueOperand =
+ getNewValue(Store->getValueOperand(), BBMap, GlobalMap, LTS);
return Builder.CreateStore(ValueOperand, NewPointer);
}
}
VectorBlockGenerator::VectorBlockGenerator(
- IRBuilder<> &B, VectorValueMapT &GlobalMaps, std::vector<LoopToScevMapT> &VLTS,
- ScopStmt &Stmt, __isl_keep isl_map *Schedule, Pass *P)
+ IRBuilder<> &B, VectorValueMapT &GlobalMaps,
+ std::vector<LoopToScevMapT> &VLTS, ScopStmt &Stmt,
+ __isl_keep isl_map *Schedule, Pass *P)
: BlockGenerator(B, Stmt, P), GlobalMaps(GlobalMaps), VLTS(VLTS),
Schedule(Schedule) {
assert(GlobalMaps.size() > 1 && "Only one vector lane found");
for (int Lane = 0; Lane < Width; Lane++)
Vector = Builder.CreateInsertElement(
- Vector, getNewValue(Old, ScalarMaps[Lane], GlobalMaps[Lane],
- VLTS[Lane]), Builder.getInt32(Lane));
+ Vector,
+ getNewValue(Old, ScalarMaps[Lane], GlobalMaps[Lane], VLTS[Lane]),
+ Builder.getInt32(Lane));
VectorMap[Old] = Vector;
Value *Vector = UndefValue::get(VectorType);
for (int i = 0; i < VectorWidth; i++) {
- Value *NewPointer = getNewValue(Pointer, ScalarMaps[i], GlobalMaps[i],
- VLTS[i]);
+ Value *NewPointer =
+ getNewValue(Pointer, ScalarMaps[i], GlobalMaps[i], VLTS[i]);
Value *ScalarLoad =
Builder.CreateLoad(NewPointer, Load->getName() + "_p_scalar_");
Vector = Builder.CreateInsertElement(
if (Access.isStrideOne(isl_map_copy(Schedule))) {
Type *VectorPtrType = getVectorPtrTy(Pointer, VectorWidth);
- Value *NewPointer = getNewValue(Pointer, ScalarMaps[0], GlobalMaps[0],
- VLTS[0]);
+ Value *NewPointer =
+ getNewValue(Pointer, ScalarMaps[0], GlobalMaps[0], VLTS[0]);
Value *VectorPtr =
Builder.CreateBitCast(NewPointer, VectorPtrType, "vector_ptr");
} else {
for (unsigned i = 0; i < ScalarMaps.size(); i++) {
Value *Scalar = Builder.CreateExtractElement(Vector, Builder.getInt32(i));
- Value *NewPointer = getNewValue(Pointer, ScalarMaps[i], GlobalMaps[i],
- VLTS[i]);
+ Value *NewPointer =
+ getNewValue(Pointer, ScalarMaps[i], GlobalMaps[i], VLTS[i]);
Builder.CreateStore(Scalar, NewPointer);
}
}
char CodeGeneration::ID = 1;
-INITIALIZE_PASS_BEGIN(CodeGeneration, "polly-codegen",
- "Polly - Create LLVM-IR from SCoPs", false, false)
-INITIALIZE_PASS_DEPENDENCY(CloogInfo)
-INITIALIZE_PASS_DEPENDENCY(Dependences)
-INITIALIZE_PASS_DEPENDENCY(DominatorTree)
-INITIALIZE_PASS_DEPENDENCY(RegionInfo)
-INITIALIZE_PASS_DEPENDENCY(ScalarEvolution)
-INITIALIZE_PASS_DEPENDENCY(ScopDetection)
-INITIALIZE_PASS_DEPENDENCY(DataLayout)
-INITIALIZE_PASS_END(CodeGeneration, "polly-codegen",
- "Polly - Create LLVM-IR from SCoPs", false, false)
-
Pass *polly::createCodeGenerationPass() {
return new CodeGeneration();
}
+INITIALIZE_PASS_BEGIN(CodeGeneration, "polly-codegen",
+ "Polly - Create LLVM-IR from SCoPs", false, false);
+INITIALIZE_PASS_DEPENDENCY(CloogInfo);
+INITIALIZE_PASS_DEPENDENCY(Dependences);
+INITIALIZE_PASS_DEPENDENCY(DominatorTree);
+INITIALIZE_PASS_DEPENDENCY(RegionInfo);
+INITIALIZE_PASS_DEPENDENCY(ScalarEvolution);
+INITIALIZE_PASS_DEPENDENCY(ScopDetection);
+INITIALIZE_PASS_DEPENDENCY(DataLayout);
+INITIALIZE_PASS_END(CodeGeneration, "polly-codegen",
+ "Polly - Create LLVM-IR from SCoPs", false, false)
+
#endif // CLOOG_FOUND
/// @brief Calculate the Value of a certain isl_ast_expr
class IslExprBuilder {
public:
- IslExprBuilder(IRBuilder<> &Builder,
- std::map<isl_id *, Value*> &IDToValue, Pass *P)
- : Builder(Builder), IDToValue(IDToValue) { }
+ IslExprBuilder(IRBuilder<> &Builder, std::map<isl_id *, Value *> &IDToValue,
+ Pass *P)
+ : Builder(Builder), IDToValue(IDToValue) {}
Value *create(__isl_take isl_ast_expr *Expr);
Type *getWidestType(Type *T1, Type *T2);
class IslNodeBuilder {
public:
- IslNodeBuilder(IRBuilder<> &Builder, Pass *P):
- Builder(Builder), ExprBuilder(Builder, IDToValue, P), P(P) {}
+ IslNodeBuilder(IRBuilder<> &Builder, Pass *P)
+ : Builder(Builder), ExprBuilder(Builder, IDToValue, P), P(P) {}
void addParameters(__isl_take isl_set *Context);
void create(__isl_take isl_ast_node *Node);
isl_ast_node_free(If);
}
-void IslNodeBuilder::createSubstitutions(__isl_take isl_pw_multi_aff *PMA,
- __isl_take isl_ast_build *Context,
- ScopStmt *Stmt, ValueMapT &VMap,
- LoopToScevMapT <S) {
+void IslNodeBuilder::createSubstitutions(
+ __isl_take isl_pw_multi_aff *PMA, __isl_take isl_ast_build *Context,
+ ScopStmt *Stmt, ValueMapT &VMap, LoopToScevMapT <S) {
for (unsigned i = 0; i < isl_pw_multi_aff_dim(PMA, isl_dim_out); ++i) {
isl_pw_aff *Aff;
isl_ast_expr *Expr;
char IslCodeGeneration::ID = 1;
+Pass *polly::createIslCodeGenerationPass() { return new IslCodeGeneration(); }
+
INITIALIZE_PASS_BEGIN(IslCodeGeneration, "polly-codegen-isl",
- "Polly - Create LLVM-IR from SCoPs", false, false)
-INITIALIZE_PASS_DEPENDENCY(Dependences)
-INITIALIZE_PASS_DEPENDENCY(DominatorTree)
-INITIALIZE_PASS_DEPENDENCY(LoopInfo)
-INITIALIZE_PASS_DEPENDENCY(RegionInfo)
-INITIALIZE_PASS_DEPENDENCY(ScalarEvolution)
-INITIALIZE_PASS_DEPENDENCY(ScopDetection)
+ "Polly - Create LLVM-IR from SCoPs", false, false);
+INITIALIZE_PASS_DEPENDENCY(Dependences);
+INITIALIZE_PASS_DEPENDENCY(DominatorTree);
+INITIALIZE_PASS_DEPENDENCY(LoopInfo);
+INITIALIZE_PASS_DEPENDENCY(RegionInfo);
+INITIALIZE_PASS_DEPENDENCY(ScalarEvolution);
+INITIALIZE_PASS_DEPENDENCY(ScopDetection);
INITIALIZE_PASS_END(IslCodeGeneration, "polly-codegen-isl",
- "Polly - Create LLVM-IR from SCoPs", false, false)
+ "Polly - Create LLVM-IR from SCoPs", false, false)
-Pass *polly::createIslCodeGenerationPass() {
- return new IslCodeGeneration();
-}