[polly] r246920 - BlockGenerator: Make GlobalMap a member variable
Tobias Grosser via llvm-commits
llvm-commits at lists.llvm.org
Sat Sep 5 02:56:57 PDT 2015
Author: grosser
Date: Sat Sep 5 04:56:54 2015
New Revision: 246920
URL: http://llvm.org/viewvc/llvm-project?rev=246920&view=rev
Log:
BlockGenerator: Make GlobalMap a member variable
The GlobalMap variable used in BlockGenerator should always reference the same
list througout the entire code generation, hence we can make it a member
variable to avoid passing it around through every function call.
History: Before we switched to the SCEV based code generation the GlobalMap
also contained a mapping form old to new induction variables, hence it was
different for each ScopStmt, which is why we passed it as function argument
to copyStmt. The new SCEV based code generation now uses a separate mapping
called LTS -> LoopToSCEV that maps each original loop to a new loop iteration
variable provided as a SCEVExpr. The GlobalMap is currently mostly used for
OpenMP code generation, where references to parameters in the original function
need to be rewritten to the locations of these variables after they have been
passed to the subfunction.
Suggested-by: Johannes Doerfert <doerfert at cs.uni-saarland.de>
Modified:
polly/trunk/include/polly/CodeGen/BlockGenerators.h
polly/trunk/include/polly/CodeGen/IslNodeBuilder.h
polly/trunk/lib/CodeGen/BlockGenerators.cpp
polly/trunk/lib/CodeGen/IslNodeBuilder.cpp
Modified: polly/trunk/include/polly/CodeGen/BlockGenerators.h
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/include/polly/CodeGen/BlockGenerators.h?rev=246920&r1=246919&r2=246920&view=diff
==============================================================================
--- polly/trunk/include/polly/CodeGen/BlockGenerators.h (original)
+++ polly/trunk/include/polly/CodeGen/BlockGenerators.h Sat Sep 5 04:56:54 2015
@@ -92,10 +92,15 @@ public:
/// @param ScalarMap Map from scalars to their demoted location.
/// @param PHIOpMap Map from PHIs to their demoted operand location.
/// @param EscapeMap Map from scalars to their escape users and locations.
+ /// @param GlobalMap A mapping from llvm::Values used in the original scop
+ /// region to a new set of llvm::Values. Each reference to
+ /// an original value appearing in this mapping is replaced
+ /// with the new value it is mapped to.
/// @param ExprBuilder An expression builder to generate new access functions.
BlockGenerator(PollyIRBuilder &Builder, LoopInfo &LI, ScalarEvolution &SE,
DominatorTree &DT, ScalarAllocaMapTy &ScalarMap,
ScalarAllocaMapTy &PHIOpMap, EscapeUsersAllocaMapTy &EscapeMap,
+ ValueToValueMap &GlobalMap,
IslExprBuilder *ExprBuilder = nullptr);
/// @brief Copy the basic block.
@@ -104,15 +109,12 @@ public:
/// with references to new values, as defined by GlobalMap.
///
/// @param Stmt The block statement to code generate.
- /// @param GlobalMap A mapping from old values to their new values
- /// (for values recalculated in the new ScoP, but not
- /// within this basic block).
/// @param LTS A map from old loops to new induction variables as
/// SCEVs.
/// @param NewAccesses A map from memory access ids to new ast expressions,
/// which may contain new access expressions for certain
/// memory accesses.
- void copyStmt(ScopStmt &Stmt, ValueMapT &GlobalMap, LoopToScevMapT <S,
+ void copyStmt(ScopStmt &Stmt, LoopToScevMapT <S,
isl_id_to_ast_expr *NewAccesses);
/// @brief Return the scalar alloca for @p ScalarBase
@@ -127,35 +129,27 @@ public:
///
/// @returns The alloca for @p ScalarBase or a replacement value taken from
/// GlobalMap.
- Value *getOrCreateScalarAlloca(Value *ScalarBase, ValueMapT *GlobalMap);
+ Value *getOrCreateScalarAlloca(Value *ScalarBase);
/// @brief Return the PHi-node alloca for @p ScalarBase
///
/// If no alloca was mapped to @p ScalarBase a new one is created.
///
/// @param ScalarBase The demoted scalar value.
- /// @param GlobalMap A mapping from Allocas to other memory locations that
- /// can be used to replace the original alloca locations
- /// with new memory locations, e.g. when passing values to
- /// subfunctions while offloading parallel sections.
///
/// @returns The alloca for @p ScalarBase or a replacement value taken from
/// GlobalMap.
- Value *getOrCreatePHIAlloca(Value *ScalarBase, ValueMapT *GlobalMap);
+ Value *getOrCreatePHIAlloca(Value *ScalarBase);
/// @brief Return the alloca for @p Access
///
/// If no alloca was mapped for @p Access a new one is created.
///
/// @param Access The memory access for which to generate the alloca
- /// @param GlobalMap A mapping from Allocas to other memory locations that
- /// can be used to replace the original alloca locations with
- /// new memory locations, e.g. when passing values to
- /// subfunctions while offloading parallel sections.
///
/// @returns The alloca for @p Access or a replacement value taken from
/// GlobalMap.
- Value *getOrCreateAlloca(MemoryAccess &Access, ValueMapT *GlobalMap);
+ Value *getOrCreateAlloca(MemoryAccess &Access);
/// @brief Finalize the code generation for the SCoP @p S.
///
@@ -313,6 +307,11 @@ protected:
/// @brief Map from instructions to their escape users as well as the alloca.
EscapeUsersAllocaMapTy &EscapeMap;
+ /// @brief A map from llvm::Values referenced in the old code to a new set of
+ /// llvm::Values, which is used to replace these old values during
+ /// code generation.
+ ValueToValueMap &GlobalMap;
+
/// @brief Split @p BB to create a new one we can use to clone @p BB in.
BasicBlock *splitBB(BasicBlock *BB);
@@ -322,9 +321,6 @@ protected:
/// @param BB The basic block to code generate.
/// @param BBMap A mapping from old values to their new values in this
/// block.
- /// @param GlobalMap A mapping from old values to their new values
- /// (for values recalculated in the new ScoP, but not
- /// within this basic block).
/// @param LTS A map from old loops to new induction variables as
/// SCEVs.
/// @param NewAccesses A map from memory access ids to new ast expressions,
@@ -333,8 +329,7 @@ protected:
///
/// @returns The copy of the basic block.
BasicBlock *copyBB(ScopStmt &Stmt, BasicBlock *BB, ValueMapT &BBMap,
- ValueMapT &GlobalMap, LoopToScevMapT <S,
- isl_id_to_ast_expr *NewAccesses);
+ LoopToScevMapT <S, isl_id_to_ast_expr *NewAccesses);
/// @brief Copy the given basic block.
///
@@ -343,16 +338,13 @@ protected:
/// @param BBCopy The new basic block to generate code in.
/// @param BBMap A mapping from old values to their new values in this
/// block.
- /// @param GlobalMap A mapping from old values to their new values
- /// (for values recalculated in the new ScoP, but not
- /// within this basic block).
/// @param LTS A map from old loops to new induction variables as
/// SCEVs.
/// @param NewAccesses A map from memory access ids to new ast expressions,
/// which may contain new access expressions for certain
/// memory accesses.
void copyBB(ScopStmt &Stmt, BasicBlock *BB, BasicBlock *BBCopy,
- ValueMapT &BBMap, ValueMapT &GlobalMap, LoopToScevMapT <S,
+ ValueMapT &BBMap, LoopToScevMapT <S,
isl_id_to_ast_expr *NewAccesses);
/// @brief Return the alloca for @p ScalarBase in @p Map.
@@ -363,15 +355,10 @@ protected:
/// @param ScalarBase The demoted scalar value.
/// @param Map The map we should look for a mapped alloca value.
/// @param NameExt The suffix we add to the name of a new created alloca.
- /// @param GlobalMap A mapping from Allocas to other memory locations that
- /// can be used to replace the original alloca locations
- /// with new memory locations, e.g. when passing values to
- /// subfunctions while offloading parallel sections.
///
- /// @returns The alloca for @p ScalarBase or a replacement value taken from
- /// GlobalMap.
+ /// @returns The alloca for @p ScalarBase.
Value *getOrCreateAlloca(Value *ScalarBase, ScalarAllocaMapTy &Map,
- ValueMapT *GlobalMap, const char *NameExt);
+ const char *NameExt);
/// @brief Generate reload of scalars demoted to memory and needed by @p Inst.
///
@@ -379,7 +366,7 @@ protected:
/// @param Inst The instruction that might need reloaded values.
/// @param BBMap A mapping from old values to their new values in this block.
virtual void generateScalarLoads(ScopStmt &Stmt, const Instruction *Inst,
- ValueMapT &BBMap, ValueMapT &GlobalMap);
+ ValueMapT &BBMap);
/// @brief Generate the scalar stores for the given statement.
///
@@ -390,21 +377,16 @@ protected:
/// @param Stmt The statement we generate code for.
/// @param BB The basic block we generate code for.
/// @param BBMap A mapping from old values to their new values in this block.
- /// @param GlobalMap A mapping for globally replaced values.
virtual void generateScalarStores(ScopStmt &Stmt, BasicBlock *BB,
- ValueMapT &BBMAp, ValueMapT &GlobalMap);
+ ValueMapT &BBMAp);
/// @brief Handle users of @p Inst outside the SCoP.
///
/// @param R The current SCoP region.
- /// @param GlobalMap A mapping from old values to their new values
- /// (for values recalculated in the new ScoP, but not
- /// within this basic block).
/// @param Inst The current instruction we check.
/// @param InstCopy The copy of the instruction @p Inst in the optimized
/// SCoP.
- void handleOutsideUsers(const Region &R, ValueMapT &GlobalMap,
- Instruction *Inst, Value *InstCopy);
+ void handleOutsideUsers(const Region &R, Instruction *Inst, Value *InstCopy);
/// @brief Initialize the memory of demoted scalars.
///
@@ -431,9 +413,6 @@ protected:
/// @param Old The old Value.
/// @param BBMap A mapping from old values to their new values
/// (for values recalculated within this basic block).
- /// @param GlobalMap A mapping from old values to their new values
- /// (for values recalculated in the new ScoP, but not
- /// within this basic block).
/// @param LTS A mapping from loops virtual canonical induction
/// variable to their new values
/// (for values recalculated in the new ScoP, but not
@@ -446,10 +425,10 @@ protected:
/// o The new value, if available.
/// o NULL, if no value is found.
Value *getNewValue(ScopStmt &Stmt, const Value *Old, ValueMapT &BBMap,
- ValueMapT &GlobalMap, LoopToScevMapT <S, Loop *L) const;
+ LoopToScevMapT <S, Loop *L) const;
void copyInstScalar(ScopStmt &Stmt, const Instruction *Inst, ValueMapT &BBMap,
- ValueMapT &GlobalMap, LoopToScevMapT <S);
+ LoopToScevMapT <S);
/// @brief Get the innermost loop that surrounds an instruction.
///
@@ -463,26 +442,21 @@ protected:
/// memory accesses.
Value *generateLocationAccessed(ScopStmt &Stmt, const Instruction *Inst,
const Value *Pointer, ValueMapT &BBMap,
- ValueMapT &GlobalMap, LoopToScevMapT <S,
+ LoopToScevMapT <S,
isl_id_to_ast_expr *NewAccesses);
/// @param NewAccesses A map from memory access ids to new ast expressions,
/// which may contain new access expressions for certain
/// memory accesses.
Value *generateScalarLoad(ScopStmt &Stmt, const LoadInst *load,
- ValueMapT &BBMap, ValueMapT &GlobalMap,
- LoopToScevMapT <S,
+ ValueMapT &BBMap, LoopToScevMapT <S,
isl_id_to_ast_expr *NewAccesses);
- /// @param GlobalMap A mapping from old values to their new values
- /// (for values recalculated in the new ScoP, but not
- /// within this basic block).
/// @param NewAccesses A map from memory access ids to new ast expressions,
/// which may contain new access expressions for certain
/// memory accesses.
void generateScalarStore(ScopStmt &Stmt, const StoreInst *store,
- ValueMapT &BBMap, ValueMapT &GlobalMap,
- LoopToScevMapT <S,
+ ValueMapT &BBMap, LoopToScevMapT <S,
isl_id_to_ast_expr *NewAccesses);
/// @brief Copy a single PHI instruction.
@@ -492,7 +466,7 @@ protected:
///
/// @returns The nullptr as the BlockGenerator does not copy PHIs.
virtual Value *copyPHIInstruction(ScopStmt &, const PHINode *, ValueMapT &,
- ValueMapT &, LoopToScevMapT &) {
+ LoopToScevMapT &) {
return nullptr;
}
@@ -516,8 +490,8 @@ protected:
/// which may contain new access expressions for certain
/// memory accesses.
void copyInstruction(ScopStmt &Stmt, const Instruction *Inst,
- ValueMapT &BBMap, ValueMapT &GlobalMap,
- LoopToScevMapT <S, isl_id_to_ast_expr *NewAccesses);
+ ValueMapT &BBMap, LoopToScevMapT <S,
+ isl_id_to_ast_expr *NewAccesses);
/// @brief Helper to get the newest version of @p ScalarValue.
///
@@ -525,13 +499,10 @@ protected:
/// @param R The current SCoP region.
/// @param BBMap A mapping from old values to their new values
/// (for values recalculated within this basic block).
- /// @param GlobalMap A mapping from old values to their new values
- /// (for values recalculated in the new ScoP, but not
- /// within this basic block).
///
/// @returns The newest version (e.g., reloaded) of the scalar value.
Value *getNewScalarValue(Value *ScalarValue, const Region &R,
- ValueMapT &BBMap, ValueMapT &GlobalMap);
+ ValueMapT &BBMap);
};
/// @brief Generate a new vector basic block for a polyhedral statement.
@@ -549,12 +520,6 @@ public:
///
/// @param BlockGen A block generator object used as parent.
/// @param Stmt The statement to code generate.
- /// @param GlobalMaps A vector of maps that define for certain Values
- /// referenced from the original code new Values they
- /// should be replaced with. Each map in the vector of maps
- /// is used for one vector lane. The number of elements in
- /// the vector defines the width of the generated vector
- /// instructions.
/// @param VLTS A mapping from loops virtual canonical induction
/// variable to their new values
/// (for values recalculated in the new ScoP, but not
@@ -566,22 +531,14 @@ public:
/// which may contain new access expressions for certain
/// memory accesses.
static void generate(BlockGenerator &BlockGen, ScopStmt &Stmt,
- VectorValueMapT &GlobalMaps,
std::vector<LoopToScevMapT> &VLTS,
__isl_keep isl_map *Schedule,
__isl_keep isl_id_to_ast_expr *NewAccesses) {
- VectorBlockGenerator Generator(BlockGen, GlobalMaps, VLTS, Schedule);
+ VectorBlockGenerator Generator(BlockGen, VLTS, Schedule);
Generator.copyStmt(Stmt, NewAccesses);
}
private:
- // This is a vector of global value maps. The first map is used for the first
- // vector lane, ...
- // Each map, contains information about Instructions in the old ScoP, which
- // are recalculated in the new SCoP. When copying the basic block, we replace
- // all referenes to the old instructions with their recalculated values.
- VectorValueMapT &GlobalMaps;
-
// This is a vector of loop->scev maps. The first map is used for the first
// vector lane, ...
// Each map, contains information about Instructions in the old ScoP, which
@@ -604,7 +561,7 @@ private:
// dimension of the innermost loop containing the statemenet.
isl_map *Schedule;
- VectorBlockGenerator(BlockGenerator &BlockGen, VectorValueMapT &GlobalMaps,
+ VectorBlockGenerator(BlockGenerator &BlockGen,
std::vector<LoopToScevMapT> &VLTS,
__isl_keep isl_map *Schedule);
@@ -733,11 +690,8 @@ public:
/// GlobalMap.
///
/// @param Stmt The statement to code generate.
- /// @param GlobalMap A mapping from old values to their new values
- /// (for values recalculated in the new ScoP, but not
- /// within this basic block).
/// @param LTS A map from old loops to new induction variables as SCEVs.
- void copyStmt(ScopStmt &Stmt, ValueMapT &GlobalMap, LoopToScevMapT <S,
+ void copyStmt(ScopStmt &Stmt, LoopToScevMapT <S,
__isl_keep isl_id_to_ast_expr *IdToAstExp);
/// @brief An empty destructor
@@ -765,14 +719,10 @@ private:
/// @param PHI The original PHI we copy.
/// @param PHICopy The copy of @p PHI.
/// @param IncomingBB An incoming block of @p PHI.
- /// @param GlobalMap A mapping from old values to their new values
- /// (for values recalculated in the new ScoP, but not
- /// within this basic block).
/// @param LTS A map from old loops to new induction variables as
/// SCEVs.
void addOperandToPHI(ScopStmt &Stmt, const PHINode *PHI, PHINode *PHICopy,
- BasicBlock *IncomingBB, ValueMapT &GlobalMap,
- LoopToScevMapT <S);
+ BasicBlock *IncomingBB, LoopToScevMapT <S);
/// @brief Generate reload of scalars demoted to memory and needed by @p Inst.
///
@@ -780,8 +730,7 @@ private:
/// @param Inst The instruction that might need reloaded values.
/// @param BBMap A mapping from old values to their new values in this block.
virtual void generateScalarLoads(ScopStmt &Stmt, const Instruction *Inst,
- ValueMapT &BBMap,
- ValueMapT &GlobalMap) override;
+ ValueMapT &BBMap) override;
/// @brief Generate the scalar stores for the given statement.
///
@@ -792,12 +741,8 @@ private:
/// @param Stmt The statement we generate code for.
/// @param BB The basic block we generate code for.
/// @param BBMap A mapping from old values to their new values in this block.
- /// @param GlobalMap A mapping from old values to their new values
- /// (for values recalculated in the new ScoP, but not
- /// within this basic block).
virtual void generateScalarStores(ScopStmt &Stmt, BasicBlock *BB,
- ValueMapT &BBMAp,
- ValueMapT &GlobalMap) override;
+ ValueMapT &BBMAp) override;
/// @brief Copy a single PHI instruction.
///
@@ -808,14 +753,11 @@ private:
/// @param PHI The PHI instruction to copy.
/// @param BBMap A mapping from old values to their new values
/// (for values recalculated within this basic block).
- /// @param GlobalMap A mapping from old values to their new values
- /// (for values recalculated in the new ScoP, but not
- /// within this basic block).
/// @param LTS A map from old loops to new induction variables as SCEVs.
///
/// @returns The copied instruction or nullptr if no copy was made.
virtual Value *copyPHIInstruction(ScopStmt &Stmt, const PHINode *Inst,
- ValueMapT &BBMap, ValueMapT &GlobalMap,
+ ValueMapT &BBMap,
LoopToScevMapT <S) override;
};
}
Modified: polly/trunk/include/polly/CodeGen/IslNodeBuilder.h
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/include/polly/CodeGen/IslNodeBuilder.h?rev=246920&r1=246919&r2=246920&view=diff
==============================================================================
--- polly/trunk/include/polly/CodeGen/IslNodeBuilder.h (original)
+++ polly/trunk/include/polly/CodeGen/IslNodeBuilder.h Sat Sep 5 04:56:54 2015
@@ -32,7 +32,7 @@ public:
DominatorTree &DT, Scop &S)
: S(S), Builder(Builder), Annotator(Annotator),
ExprBuilder(S, Builder, IDToValue, DL, SE, DT, LI),
- BlockGen(Builder, LI, SE, DT, ScalarMap, PHIOpMap, EscapeMap,
+ BlockGen(Builder, LI, SE, DT, ScalarMap, PHIOpMap, EscapeMap, ValueMap,
&ExprBuilder),
RegionGen(BlockGen), P(P), DL(DL), LI(LI), SE(SE), DT(DT) {}
@@ -74,6 +74,8 @@ protected:
BlockGenerator::EscapeUsersAllocaMapTy EscapeMap;
///@}
+ ///
+ ValueToValueMap GlobalMap;
/// @brief The generator used to copy a basic block.
BlockGenerator BlockGen;
@@ -239,12 +241,6 @@ protected:
///
/// @param Expr The call expression that represents the statement.
/// @param Stmt The statement that is called.
- /// @param VMap The value map into which the mapping from the old induction
- /// variable to the new one is inserted. This mapping is used
- /// for the classical code generation (not scev-based) and
- /// gives an explicit mapping from an original, materialized
- /// induction variable. It consequently can only be expressed
- /// if there was an explicit induction variable.
/// @param LTS The loop to SCEV map in which the mapping from the original
/// loop to a SCEV representing the new loop iv is added. This
/// mapping does not require an explicit induction variable.
@@ -253,9 +249,8 @@ protected:
/// original loop this count, expressed in function of the new
/// induction variables, is added to the LTS map.
void createSubstitutions(__isl_take isl_ast_expr *Expr, ScopStmt *Stmt,
- ValueMapT &VMap, LoopToScevMapT <S);
+ LoopToScevMapT <S);
void createSubstitutionsVector(__isl_take isl_ast_expr *Expr, ScopStmt *Stmt,
- VectorValueMapT &VMap,
std::vector<LoopToScevMapT> &VLTS,
std::vector<Value *> &IVS,
__isl_take isl_id *IteratorID);
Modified: polly/trunk/lib/CodeGen/BlockGenerators.cpp
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/lib/CodeGen/BlockGenerators.cpp?rev=246920&r1=246919&r2=246920&view=diff
==============================================================================
--- polly/trunk/lib/CodeGen/BlockGenerators.cpp (original)
+++ polly/trunk/lib/CodeGen/BlockGenerators.cpp Sat Sep 5 04:56:54 2015
@@ -86,14 +86,15 @@ BlockGenerator::BlockGenerator(PollyIRBu
ScalarAllocaMapTy &ScalarMap,
ScalarAllocaMapTy &PHIOpMap,
EscapeUsersAllocaMapTy &EscapeMap,
+ ValueToValueMap &GlobalMap,
IslExprBuilder *ExprBuilder)
: Builder(B), LI(LI), SE(SE), ExprBuilder(ExprBuilder), DT(DT),
EntryBB(nullptr), PHIOpMap(PHIOpMap), ScalarMap(ScalarMap),
- EscapeMap(EscapeMap) {}
+ EscapeMap(EscapeMap), GlobalMap(GlobalMap) {}
Value *BlockGenerator::getNewValue(ScopStmt &Stmt, const Value *Old,
- ValueMapT &BBMap, ValueMapT &GlobalMap,
- LoopToScevMapT <S, Loop *L) const {
+ ValueMapT &BBMap, LoopToScevMapT <S,
+ Loop *L) const {
// We assume constants never change.
// This avoids map lookups for many calls to this function.
if (isa<Constant>(Old))
@@ -149,8 +150,7 @@ Value *BlockGenerator::getNewValue(ScopS
}
void BlockGenerator::copyInstScalar(ScopStmt &Stmt, const Instruction *Inst,
- ValueMapT &BBMap, ValueMapT &GlobalMap,
- LoopToScevMapT <S) {
+ ValueMapT &BBMap, LoopToScevMapT <S) {
// We do not generate debug intrinsics as we did not investigate how to
// copy them correctly. At the current state, they just crash the code
// generation as the meta-data operands are not correctly copied.
@@ -161,8 +161,8 @@ void BlockGenerator::copyInstScalar(Scop
// Replace old operands with the new ones.
for (Value *OldOperand : Inst->operands()) {
- Value *NewOperand = getNewValue(Stmt, OldOperand, BBMap, GlobalMap, LTS,
- getLoopForInst(Inst));
+ Value *NewOperand =
+ getNewValue(Stmt, OldOperand, BBMap, LTS, getLoopForInst(Inst));
if (!NewOperand) {
assert(!isa<StoreInst>(NewInst) &&
@@ -183,8 +183,7 @@ void BlockGenerator::copyInstScalar(Scop
Value *BlockGenerator::generateLocationAccessed(
ScopStmt &Stmt, const Instruction *Inst, const Value *Pointer,
- ValueMapT &BBMap, ValueMapT &GlobalMap, LoopToScevMapT <S,
- isl_id_to_ast_expr *NewAccesses) {
+ ValueMapT &BBMap, LoopToScevMapT <S, isl_id_to_ast_expr *NewAccesses) {
const MemoryAccess &MA = Stmt.getAccessFor(Inst);
isl_ast_expr *AccessExpr = isl_id_to_ast_expr_get(NewAccesses, MA.getId());
@@ -194,8 +193,7 @@ Value *BlockGenerator::generateLocationA
return ExprBuilder->create(AccessExpr);
}
- return getNewValue(Stmt, Pointer, BBMap, GlobalMap, LTS,
- getLoopForInst(Inst));
+ return getNewValue(Stmt, Pointer, BBMap, LTS, getLoopForInst(Inst));
}
Loop *BlockGenerator::getLoopForInst(const llvm::Instruction *Inst) {
@@ -203,38 +201,34 @@ Loop *BlockGenerator::getLoopForInst(con
}
Value *BlockGenerator::generateScalarLoad(ScopStmt &Stmt, const LoadInst *Load,
- ValueMapT &BBMap,
- ValueMapT &GlobalMap,
- LoopToScevMapT <S,
+ ValueMapT &BBMap, LoopToScevMapT <S,
isl_id_to_ast_expr *NewAccesses) {
const Value *Pointer = Load->getPointerOperand();
- Value *NewPointer = generateLocationAccessed(Stmt, Load, Pointer, BBMap,
- GlobalMap, LTS, NewAccesses);
+ Value *NewPointer =
+ generateLocationAccessed(Stmt, Load, Pointer, BBMap, LTS, NewAccesses);
Value *ScalarLoad = Builder.CreateAlignedLoad(
NewPointer, Load->getAlignment(), Load->getName() + "_p_scalar_");
return ScalarLoad;
}
void BlockGenerator::generateScalarStore(ScopStmt &Stmt, const StoreInst *Store,
- ValueMapT &BBMap, ValueMapT &GlobalMap,
- LoopToScevMapT <S,
+ ValueMapT &BBMap, LoopToScevMapT <S,
isl_id_to_ast_expr *NewAccesses) {
const Value *Pointer = Store->getPointerOperand();
- Value *NewPointer = generateLocationAccessed(Stmt, Store, Pointer, BBMap,
- GlobalMap, LTS, NewAccesses);
- Value *ValueOperand = getNewValue(Stmt, Store->getValueOperand(), BBMap,
- GlobalMap, LTS, getLoopForInst(Store));
+ Value *NewPointer =
+ generateLocationAccessed(Stmt, Store, Pointer, BBMap, LTS, NewAccesses);
+ Value *ValueOperand = getNewValue(Stmt, Store->getValueOperand(), BBMap, LTS,
+ getLoopForInst(Store));
Builder.CreateAlignedStore(ValueOperand, NewPointer, Store->getAlignment());
}
void BlockGenerator::copyInstruction(ScopStmt &Stmt, const Instruction *Inst,
- ValueMapT &BBMap, ValueMapT &GlobalMap,
- LoopToScevMapT <S,
+ ValueMapT &BBMap, LoopToScevMapT <S,
isl_id_to_ast_expr *NewAccesses) {
// First check for possible scalar dependences for this instruction.
- generateScalarLoads(Stmt, Inst, BBMap, GlobalMap);
+ generateScalarLoads(Stmt, Inst, BBMap);
// Terminator instructions control the control flow. They are explicitly
// expressed in the clast and do not need to be copied.
@@ -244,14 +238,13 @@ void BlockGenerator::copyInstruction(Sco
Loop *L = getLoopForInst(Inst);
if ((Stmt.isBlockStmt() || !Stmt.getRegion()->contains(L)) &&
canSynthesize(Inst, &LI, &SE, &Stmt.getParent()->getRegion())) {
- Value *NewValue = getNewValue(Stmt, Inst, BBMap, GlobalMap, LTS, L);
+ Value *NewValue = getNewValue(Stmt, Inst, BBMap, LTS, L);
BBMap[Inst] = NewValue;
return;
}
if (const LoadInst *Load = dyn_cast<LoadInst>(Inst)) {
- Value *NewLoad =
- generateScalarLoad(Stmt, Load, BBMap, GlobalMap, LTS, NewAccesses);
+ Value *NewLoad = generateScalarLoad(Stmt, Load, BBMap, LTS, NewAccesses);
// Compute NewLoad before its insertion in BBMap to make the insertion
// deterministic.
BBMap[Load] = NewLoad;
@@ -259,12 +252,12 @@ void BlockGenerator::copyInstruction(Sco
}
if (const StoreInst *Store = dyn_cast<StoreInst>(Inst)) {
- generateScalarStore(Stmt, Store, BBMap, GlobalMap, LTS, NewAccesses);
+ generateScalarStore(Stmt, Store, BBMap, LTS, NewAccesses);
return;
}
if (const PHINode *PHI = dyn_cast<PHINode>(Inst)) {
- copyPHIInstruction(Stmt, PHI, BBMap, GlobalMap, LTS);
+ copyPHIInstruction(Stmt, PHI, BBMap, LTS);
return;
}
@@ -273,11 +266,10 @@ void BlockGenerator::copyInstruction(Sco
if (isIgnoredIntrinsic(Inst))
return;
- copyInstScalar(Stmt, Inst, BBMap, GlobalMap, LTS);
+ copyInstScalar(Stmt, Inst, BBMap, LTS);
}
-void BlockGenerator::copyStmt(ScopStmt &Stmt, ValueMapT &GlobalMap,
- LoopToScevMapT <S,
+void BlockGenerator::copyStmt(ScopStmt &Stmt, LoopToScevMapT <S,
isl_id_to_ast_expr *NewAccesses) {
assert(Stmt.isBlockStmt() &&
"Only block statements can be copied by the block generator");
@@ -285,7 +277,7 @@ void BlockGenerator::copyStmt(ScopStmt &
ValueMapT BBMap;
BasicBlock *BB = Stmt.getBasicBlock();
- copyBB(Stmt, BB, BBMap, GlobalMap, LTS, NewAccesses);
+ copyBB(Stmt, BB, BBMap, LTS, NewAccesses);
}
BasicBlock *BlockGenerator::splitBB(BasicBlock *BB) {
@@ -296,37 +288,34 @@ BasicBlock *BlockGenerator::splitBB(Basi
}
BasicBlock *BlockGenerator::copyBB(ScopStmt &Stmt, BasicBlock *BB,
- ValueMapT &BBMap, ValueMapT &GlobalMap,
- LoopToScevMapT <S,
+ ValueMapT &BBMap, LoopToScevMapT <S,
isl_id_to_ast_expr *NewAccesses) {
BasicBlock *CopyBB = splitBB(BB);
- copyBB(Stmt, BB, CopyBB, BBMap, GlobalMap, LTS, NewAccesses);
+ copyBB(Stmt, BB, CopyBB, BBMap, LTS, NewAccesses);
return CopyBB;
}
void BlockGenerator::copyBB(ScopStmt &Stmt, BasicBlock *BB, BasicBlock *CopyBB,
- ValueMapT &BBMap, ValueMapT &GlobalMap,
- LoopToScevMapT <S,
+ ValueMapT &BBMap, LoopToScevMapT <S,
isl_id_to_ast_expr *NewAccesses) {
Builder.SetInsertPoint(CopyBB->begin());
EntryBB = &CopyBB->getParent()->getEntryBlock();
for (Instruction &Inst : *BB)
- copyInstruction(Stmt, &Inst, BBMap, GlobalMap, LTS, NewAccesses);
+ copyInstruction(Stmt, &Inst, BBMap, LTS, NewAccesses);
// After a basic block was copied store all scalars that escape this block
// in their alloca. First the scalars that have dependences inside the SCoP,
// then the ones that might escape the SCoP.
- generateScalarStores(Stmt, BB, BBMap, GlobalMap);
+ generateScalarStores(Stmt, BB, BBMap);
const Region &R = Stmt.getParent()->getRegion();
for (Instruction &Inst : *BB)
- handleOutsideUsers(R, GlobalMap, &Inst, BBMap[&Inst]);
+ handleOutsideUsers(R, &Inst, BBMap[&Inst]);
}
Value *BlockGenerator::getOrCreateAlloca(Value *ScalarBase,
ScalarAllocaMapTy &Map,
- ValueMapT *GlobalMap,
const char *NameExt) {
// Check if an alloca was cached for the base instruction.
AllocaInst *&Addr = Map[ScalarBase];
@@ -339,32 +328,29 @@ Value *BlockGenerator::getOrCreateAlloca
Addr->insertBefore(EntryBB->getFirstInsertionPt());
}
- if (GlobalMap && GlobalMap->count(Addr))
- return (*GlobalMap)[Addr];
+ if (GlobalMap.count(Addr))
+ return GlobalMap[Addr];
return Addr;
}
-Value *BlockGenerator::getOrCreateAlloca(MemoryAccess &Access,
- ValueMapT *GlobalMap) {
+Value *BlockGenerator::getOrCreateAlloca(MemoryAccess &Access) {
if (Access.getScopArrayInfo()->isPHI())
- return getOrCreatePHIAlloca(Access.getBaseAddr(), GlobalMap);
+ return getOrCreatePHIAlloca(Access.getBaseAddr());
else
- return getOrCreateScalarAlloca(Access.getBaseAddr(), GlobalMap);
+ return getOrCreateScalarAlloca(Access.getBaseAddr());
}
-Value *BlockGenerator::getOrCreateScalarAlloca(Value *ScalarBase,
- ValueMapT *GlobalMap) {
- return getOrCreateAlloca(ScalarBase, ScalarMap, GlobalMap, ".s2a");
+Value *BlockGenerator::getOrCreateScalarAlloca(Value *ScalarBase) {
+ return getOrCreateAlloca(ScalarBase, ScalarMap, ".s2a");
}
-Value *BlockGenerator::getOrCreatePHIAlloca(Value *ScalarBase,
- ValueMapT *GlobalMap) {
- return getOrCreateAlloca(ScalarBase, PHIOpMap, GlobalMap, ".phiops");
+Value *BlockGenerator::getOrCreatePHIAlloca(Value *ScalarBase) {
+ return getOrCreateAlloca(ScalarBase, PHIOpMap, ".phiops");
}
-void BlockGenerator::handleOutsideUsers(const Region &R, ValueMapT &GlobalMap,
- Instruction *Inst, Value *InstCopy) {
+void BlockGenerator::handleOutsideUsers(const Region &R, Instruction *Inst,
+ Value *InstCopy) {
// If there are escape users we get the alloca for this instruction and put it
// in the EscapeMap for later finalization. Lastly, if the instruction was
// copied multiple times we already did this and can exit.
@@ -390,8 +376,7 @@ void BlockGenerator::handleOutsideUsers(
return;
// Get or create an escape alloca for this instruction.
- auto *ScalarAddr =
- cast<AllocaInst>(getOrCreateScalarAlloca(Inst, &GlobalMap));
+ auto *ScalarAddr = cast<AllocaInst>(getOrCreateScalarAlloca(Inst));
// Remember that this instruction has escape uses and the escape alloca.
EscapeMap[Inst] = std::make_pair(ScalarAddr, std::move(EscapeUsers));
@@ -399,8 +384,7 @@ void BlockGenerator::handleOutsideUsers(
void BlockGenerator::generateScalarLoads(ScopStmt &Stmt,
const Instruction *Inst,
- ValueMapT &BBMap,
- ValueMapT &GlobalMap) {
+ ValueMapT &BBMap) {
auto *MAL = Stmt.lookupAccessesFor(Inst);
if (!MAL)
@@ -410,15 +394,14 @@ void BlockGenerator::generateScalarLoads
if (!MA.isScalar() || !MA.isRead())
continue;
- auto *Address = getOrCreateAlloca(MA, &GlobalMap);
+ auto *Address = getOrCreateAlloca(MA);
BBMap[MA.getBaseAddr()] =
Builder.CreateLoad(Address, Address->getName() + ".reload");
}
}
Value *BlockGenerator::getNewScalarValue(Value *ScalarValue, const Region &R,
- ValueMapT &BBMap,
- ValueMapT &GlobalMap) {
+ ValueMapT &BBMap) {
// If the value we want to store is an instruction we might have demoted it
// in order to make it accessible here. In such a case a reload is
// necessary. If it is no instruction it will always be a value that
@@ -447,15 +430,14 @@ Value *BlockGenerator::getNewScalarValue
return /* Case (3a) */ ScalarValueCopy;
// Case (3b)
- Value *Address = getOrCreateScalarAlloca(ScalarValueInst, &GlobalMap);
+ Value *Address = getOrCreateScalarAlloca(ScalarValueInst);
ScalarValue = Builder.CreateLoad(Address, Address->getName() + ".reload");
return ScalarValue;
}
void BlockGenerator::generateScalarStores(ScopStmt &Stmt, BasicBlock *BB,
- ValueMapT &BBMap,
- ValueMapT &GlobalMap) {
+ ValueMapT &BBMap) {
const Region &R = Stmt.getParent()->getRegion();
assert(Stmt.isBlockStmt() && BB == Stmt.getBasicBlock() &&
@@ -467,9 +449,9 @@ void BlockGenerator::generateScalarStore
continue;
Value *Val = MA->getAccessValue();
- auto *Address = getOrCreateAlloca(*MA, &GlobalMap);
+ auto *Address = getOrCreateAlloca(*MA);
- Val = getNewScalarValue(Val, R, BBMap, GlobalMap);
+ Val = getNewScalarValue(Val, R, BBMap);
Builder.CreateStore(Val, Address);
}
}
@@ -510,7 +492,7 @@ void BlockGenerator::createScalarInitial
Value *ScalarValue = PHI->getIncomingValue(Idx);
- Builder.CreateStore(ScalarValue, getOrCreatePHIAlloca(PHI, nullptr));
+ Builder.CreateStore(ScalarValue, getOrCreatePHIAlloca(PHI));
continue;
}
@@ -521,7 +503,7 @@ void BlockGenerator::createScalarInitial
ValueMapT EmptyMap;
Builder.CreateStore(Array->getBasePtr(),
- getOrCreateScalarAlloca(Array->getBasePtr(), nullptr));
+ getOrCreateScalarAlloca(Array->getBasePtr()));
}
}
@@ -575,12 +557,9 @@ void BlockGenerator::finalizeSCoP(Scop &
}
VectorBlockGenerator::VectorBlockGenerator(BlockGenerator &BlockGen,
- VectorValueMapT &GlobalMaps,
std::vector<LoopToScevMapT> &VLTS,
isl_map *Schedule)
- : BlockGenerator(BlockGen), GlobalMaps(GlobalMaps), VLTS(VLTS),
- Schedule(Schedule) {
- assert(GlobalMaps.size() > 1 && "Only one vector lane found");
+ : BlockGenerator(BlockGen), VLTS(VLTS), Schedule(Schedule) {
assert(Schedule && "No statement domain provided");
}
@@ -597,8 +576,7 @@ Value *VectorBlockGenerator::getVectorVa
for (int Lane = 0; Lane < Width; Lane++)
Vector = Builder.CreateInsertElement(
- Vector, getNewValue(Stmt, Old, ScalarMaps[Lane], GlobalMaps[Lane],
- VLTS[Lane], L),
+ Vector, getNewValue(Stmt, Old, ScalarMaps[Lane], VLTS[Lane], L),
Builder.getInt32(Lane));
VectorMap[Old] = Vector;
@@ -625,9 +603,8 @@ Value *VectorBlockGenerator::generateStr
unsigned Offset = NegativeStride ? VectorWidth - 1 : 0;
Value *NewPointer = nullptr;
- NewPointer =
- generateLocationAccessed(Stmt, Load, Pointer, ScalarMaps[Offset],
- GlobalMaps[Offset], VLTS[Offset], NewAccesses);
+ NewPointer = generateLocationAccessed(Stmt, Load, Pointer, ScalarMaps[Offset],
+ VLTS[Offset], NewAccesses);
Value *VectorPtr =
Builder.CreateBitCast(NewPointer, VectorPtrType, "vector_ptr");
LoadInst *VecLoad =
@@ -653,8 +630,8 @@ Value *VectorBlockGenerator::generateStr
__isl_keep isl_id_to_ast_expr *NewAccesses) {
const Value *Pointer = Load->getPointerOperand();
Type *VectorPtrType = getVectorPtrTy(Pointer, 1);
- Value *NewPointer = generateLocationAccessed(
- Stmt, Load, Pointer, BBMap, GlobalMaps[0], VLTS[0], NewAccesses);
+ Value *NewPointer = generateLocationAccessed(Stmt, Load, Pointer, BBMap,
+ VLTS[0], NewAccesses);
Value *VectorPtr = Builder.CreateBitCast(NewPointer, VectorPtrType,
Load->getName() + "_p_vec_p");
LoadInst *ScalarLoad =
@@ -684,9 +661,8 @@ Value *VectorBlockGenerator::generateUnk
Value *Vector = UndefValue::get(VectorType);
for (int i = 0; i < VectorWidth; i++) {
- Value *NewPointer =
- generateLocationAccessed(Stmt, Load, Pointer, ScalarMaps[i],
- GlobalMaps[i], VLTS[i], NewAccesses);
+ Value *NewPointer = generateLocationAccessed(
+ Stmt, Load, Pointer, ScalarMaps[i], VLTS[i], NewAccesses);
Value *ScalarLoad =
Builder.CreateLoad(NewPointer, Load->getName() + "_p_scalar_");
Vector = Builder.CreateInsertElement(
@@ -701,8 +677,8 @@ void VectorBlockGenerator::generateLoad(
VectorValueMapT &ScalarMaps, __isl_keep isl_id_to_ast_expr *NewAccesses) {
if (!VectorType::isValidElementType(Load->getType())) {
for (int i = 0; i < getVectorWidth(); i++)
- ScalarMaps[i][Load] = generateScalarLoad(
- Stmt, Load, ScalarMaps[i], GlobalMaps[i], VLTS[i], NewAccesses);
+ ScalarMaps[i][Load] =
+ generateScalarLoad(Stmt, Load, ScalarMaps[i], VLTS[i], NewAccesses);
return;
}
@@ -772,9 +748,8 @@ void VectorBlockGenerator::copyStore(
if (Access.isStrideOne(isl_map_copy(Schedule))) {
Type *VectorPtrType = getVectorPtrTy(Pointer, getVectorWidth());
- Value *NewPointer =
- generateLocationAccessed(Stmt, Store, Pointer, ScalarMaps[0],
- GlobalMaps[0], VLTS[0], NewAccesses);
+ Value *NewPointer = generateLocationAccessed(
+ Stmt, Store, Pointer, ScalarMaps[0], VLTS[0], NewAccesses);
Value *VectorPtr =
Builder.CreateBitCast(NewPointer, VectorPtrType, "vector_ptr");
@@ -785,9 +760,8 @@ void VectorBlockGenerator::copyStore(
} else {
for (unsigned i = 0; i < ScalarMaps.size(); i++) {
Value *Scalar = Builder.CreateExtractElement(Vector, Builder.getInt32(i));
- Value *NewPointer =
- generateLocationAccessed(Stmt, Store, Pointer, ScalarMaps[i],
- GlobalMaps[i], VLTS[i], NewAccesses);
+ Value *NewPointer = generateLocationAccessed(
+ Stmt, Store, Pointer, ScalarMaps[i], VLTS[i], NewAccesses);
Builder.CreateStore(Scalar, NewPointer);
}
}
@@ -843,8 +817,7 @@ void VectorBlockGenerator::copyInstScala
for (int VectorLane = 0; VectorLane < getVectorWidth(); VectorLane++)
BlockGenerator::copyInstruction(Stmt, Inst, ScalarMaps[VectorLane],
- GlobalMaps[VectorLane], VLTS[VectorLane],
- NewAccesses);
+ VLTS[VectorLane], NewAccesses);
if (!VectorType::isValidElementType(Inst->getType()) || !HasVectorOperand)
return;
@@ -860,7 +833,7 @@ void VectorBlockGenerator::copyInstScala
VectorMap[Inst] = Vector;
}
-int VectorBlockGenerator::getVectorWidth() { return GlobalMaps.size(); }
+int VectorBlockGenerator::getVectorWidth() { return VLTS.size(); }
void VectorBlockGenerator::copyInstruction(
ScopStmt &Stmt, const Instruction *Inst, ValueMapT &VectorMap,
@@ -945,8 +918,7 @@ BasicBlock *RegionGenerator::repairDomin
return BBCopyIDom;
}
-void RegionGenerator::copyStmt(ScopStmt &Stmt, ValueMapT &GlobalMap,
- LoopToScevMapT <S,
+void RegionGenerator::copyStmt(ScopStmt &Stmt, LoopToScevMapT <S,
isl_id_to_ast_expr *IdToAstExp) {
assert(Stmt.isRegionStmt() &&
"Only region statements can be copied by the region generator");
@@ -994,15 +966,14 @@ void RegionGenerator::copyStmt(ScopStmt
RegionMap = RegionMaps[BBCopyIDom];
// Copy the block with the BlockGenerator.
- copyBB(Stmt, BB, BBCopy, RegionMap, GlobalMap, LTS, IdToAstExp);
+ copyBB(Stmt, BB, BBCopy, RegionMap, LTS, IdToAstExp);
// In order to remap PHI nodes we store also basic block mappings.
BlockMap[BB] = BBCopy;
// Add values to incomplete PHI nodes waiting for this block to be copied.
for (const PHINodePairTy &PHINodePair : IncompletePHINodeMap[BB])
- addOperandToPHI(Stmt, PHINodePair.first, PHINodePair.second, BB,
- GlobalMap, LTS);
+ addOperandToPHI(Stmt, PHINodePair.first, PHINodePair.second, BB, LTS);
IncompletePHINodeMap[BB].clear();
// And continue with new successors inside the region.
@@ -1032,7 +1003,7 @@ void RegionGenerator::copyStmt(ScopStmt
RegionMap.insert(BlockMap.begin(), BlockMap.end());
Builder.SetInsertPoint(BICopy);
- copyInstScalar(Stmt, BI, RegionMap, GlobalMap, LTS);
+ copyInstScalar(Stmt, BI, RegionMap, LTS);
BICopy->eraseFromParent();
}
@@ -1079,8 +1050,7 @@ void RegionGenerator::copyStmt(ScopStmt
void RegionGenerator::generateScalarLoads(ScopStmt &Stmt,
const Instruction *Inst,
- ValueMapT &BBMap,
- ValueMapT &GlobalMap) {
+ ValueMapT &BBMap) {
// Inside a non-affine region PHI nodes are copied not demoted. Once the
// phi is copied it will reload all inputs from outside the region, hence
@@ -1089,12 +1059,11 @@ void RegionGenerator::generateScalarLoad
if (isa<PHINode>(Inst))
return;
- return BlockGenerator::generateScalarLoads(Stmt, Inst, BBMap, GlobalMap);
+ return BlockGenerator::generateScalarLoads(Stmt, Inst, BBMap);
}
void RegionGenerator::generateScalarStores(ScopStmt &Stmt, BasicBlock *BB,
- ValueMapT &BBMap,
- ValueMapT &GlobalMap) {
+ ValueMapT &BBMap) {
const Region &R = Stmt.getParent()->getRegion();
assert(Stmt.getRegion() &&
@@ -1114,16 +1083,15 @@ void RegionGenerator::generateScalarStor
Value *Val = MA->getAccessValue();
- auto Address = getOrCreateAlloca(*MA, &GlobalMap);
+ auto Address = getOrCreateAlloca(*MA);
- Val = getNewScalarValue(Val, R, BBMap, GlobalMap);
+ Val = getNewScalarValue(Val, R, BBMap);
Builder.CreateStore(Val, Address);
}
}
void RegionGenerator::addOperandToPHI(ScopStmt &Stmt, const PHINode *PHI,
PHINode *PHICopy, BasicBlock *IncomingBB,
- ValueMapT &GlobalMap,
LoopToScevMapT <S) {
Region *StmtR = Stmt.getRegion();
@@ -1144,15 +1112,13 @@ void RegionGenerator::addOperandToPHI(Sc
ValueMapT &BBCopyMap = RegionMaps[BBCopy];
Value *Op = PHI->getIncomingValueForBlock(IncomingBB);
- OpCopy =
- getNewValue(Stmt, Op, BBCopyMap, GlobalMap, LTS, getLoopForInst(PHI));
+ OpCopy = getNewValue(Stmt, Op, BBCopyMap, LTS, getLoopForInst(PHI));
} else {
if (PHICopy->getBasicBlockIndex(BBCopy) >= 0)
return;
- Value *PHIOpAddr =
- getOrCreatePHIAlloca(const_cast<PHINode *>(PHI), &GlobalMap);
+ Value *PHIOpAddr = getOrCreatePHIAlloca(const_cast<PHINode *>(PHI));
OpCopy = new LoadInst(PHIOpAddr, PHIOpAddr->getName() + ".reload",
BlockMap[IncomingBB]->getTerminator());
}
@@ -1164,7 +1130,6 @@ void RegionGenerator::addOperandToPHI(Sc
Value *RegionGenerator::copyPHIInstruction(ScopStmt &Stmt, const PHINode *PHI,
ValueMapT &BBMap,
- ValueMapT &GlobalMap,
LoopToScevMapT <S) {
unsigned NumIncoming = PHI->getNumIncomingValues();
PHINode *PHICopy =
@@ -1173,7 +1138,6 @@ Value *RegionGenerator::copyPHIInstructi
BBMap[PHI] = PHICopy;
for (unsigned u = 0; u < NumIncoming; u++)
- addOperandToPHI(Stmt, PHI, PHICopy, PHI->getIncomingBlock(u), GlobalMap,
- LTS);
+ addOperandToPHI(Stmt, PHI, PHICopy, PHI->getIncomingBlock(u), LTS);
return PHICopy;
}
Modified: polly/trunk/lib/CodeGen/IslNodeBuilder.cpp
URL: http://llvm.org/viewvc/llvm-project/polly/trunk/lib/CodeGen/IslNodeBuilder.cpp?rev=246920&r1=246919&r2=246920&view=diff
==============================================================================
--- polly/trunk/lib/CodeGen/IslNodeBuilder.cpp (original)
+++ polly/trunk/lib/CodeGen/IslNodeBuilder.cpp Sat Sep 5 04:56:54 2015
@@ -224,7 +224,7 @@ static isl_stat findValuesInStmt(isl_set
continue;
}
- User.Values.insert(User.BlockGen.getOrCreateAlloca(*Access, nullptr));
+ User.Values.insert(User.BlockGen.getOrCreateAlloca(*Access));
}
isl_id_free(Id);
@@ -292,7 +292,6 @@ void IslNodeBuilder::createUserVector(__
isl_id *Id = isl_ast_expr_get_id(StmtExpr);
isl_ast_expr_free(StmtExpr);
ScopStmt *Stmt = (ScopStmt *)isl_id_get_user(Id);
- VectorValueMapT VectorMap(IVS.size());
std::vector<LoopToScevMapT> VLTS(IVS.size());
isl_union_set *Domain = isl_union_set_from_set(Stmt->getDomain());
@@ -300,9 +299,8 @@ void IslNodeBuilder::createUserVector(__
isl_map *S = isl_map_from_union_map(Schedule);
auto *NewAccesses = createNewAccesses(Stmt, IslAstInfo::getBuild(User));
- createSubstitutionsVector(Expr, Stmt, VectorMap, VLTS, IVS, IteratorID);
- VectorBlockGenerator::generate(BlockGen, *Stmt, VectorMap, VLTS, S,
- NewAccesses);
+ createSubstitutionsVector(Expr, Stmt, VLTS, IVS, IteratorID);
+ VectorBlockGenerator::generate(BlockGen, *Stmt, VLTS, S, NewAccesses);
isl_id_to_ast_expr_free(NewAccesses);
isl_map_free(S);
isl_id_free(Id);
@@ -667,7 +665,7 @@ IslNodeBuilder::createNewAccesses(ScopSt
}
void IslNodeBuilder::createSubstitutions(isl_ast_expr *Expr, ScopStmt *Stmt,
- ValueMapT &VMap, LoopToScevMapT <S) {
+ LoopToScevMapT <S) {
assert(isl_ast_expr_get_type(Expr) == isl_ast_expr_op &&
"Expression of type 'op' expected");
assert(isl_ast_expr_get_op_type(Expr) == isl_ast_op_call &&
@@ -682,17 +680,11 @@ void IslNodeBuilder::createSubstitutions
LTS[Stmt->getLoopForDimension(i)] = SE->getUnknown(V);
}
- // Add the current ValueMap to our per-statement value map.
- //
- // This is needed e.g. to rewrite array base addresses when moving code
- // into a parallely executed subfunction.
- VMap.insert(ValueMap.begin(), ValueMap.end());
-
isl_ast_expr_free(Expr);
}
void IslNodeBuilder::createSubstitutionsVector(
- __isl_take isl_ast_expr *Expr, ScopStmt *Stmt, VectorValueMapT &VMap,
+ __isl_take isl_ast_expr *Expr, ScopStmt *Stmt,
std::vector<LoopToScevMapT> &VLTS, std::vector<Value *> &IVS,
__isl_take isl_id *IteratorID) {
int i = 0;
@@ -700,7 +692,7 @@ void IslNodeBuilder::createSubstitutions
Value *OldValue = IDToValue[IteratorID];
for (Value *IV : IVS) {
IDToValue[IteratorID] = IV;
- createSubstitutions(isl_ast_expr_copy(Expr), Stmt, VMap[i], VLTS[i]);
+ createSubstitutions(isl_ast_expr_copy(Expr), Stmt, VLTS[i]);
i++;
}
@@ -710,7 +702,6 @@ void IslNodeBuilder::createSubstitutions
}
void IslNodeBuilder::createUser(__isl_take isl_ast_node *User) {
- ValueMapT VMap;
LoopToScevMapT LTS;
isl_id *Id;
ScopStmt *Stmt;
@@ -724,12 +715,12 @@ void IslNodeBuilder::createUser(__isl_ta
Stmt = (ScopStmt *)isl_id_get_user(Id);
auto *NewAccesses = createNewAccesses(Stmt, IslAstInfo::getBuild(User));
- createSubstitutions(Expr, Stmt, VMap, LTS);
+ createSubstitutions(Expr, Stmt, LTS);
if (Stmt->isBlockStmt())
- BlockGen.copyStmt(*Stmt, VMap, LTS, NewAccesses);
+ BlockGen.copyStmt(*Stmt, LTS, NewAccesses);
else
- RegionGen.copyStmt(*Stmt, VMap, LTS, NewAccesses);
+ RegionGen.copyStmt(*Stmt, LTS, NewAccesses);
isl_id_to_ast_expr_free(NewAccesses);
isl_ast_node_free(User);
More information about the llvm-commits
mailing list