[Polly] [NFC] [IslNodeBuilder, GPUNodeBuilder] Unify mechanism for looking up replacement Values.

[bollu]

Summary

We populate IslNodeBuilder::ValueMap which contains replacements for
llvm::Values. There was no simple method to pick up a replacement if
it exists, otherwise fall back to the original.

Create a method IslNodeBuilder::getLatestValue which provides this
functionality.

This will be used in the next patch to fix bugs in PPCGCodeGeneration
where the latest value is not being used.

[bollu]

@grosser | @Meinersbur | @singam-sanjay : review please.

include/polly/CodeGen/IslNodeBuilder.h

271

@grosser, @Meinersbur, @singam-sanjay - I wanted some thought on the name.

[grosser]

LGTM

lib/CodeGen/IslNodeBuilder.cpp

296

Unrelated?

include/polly/CodeGen/IslNodeBuilder.h

protected:
   /// new values. This function allows to (partially) update the set of values
   /// used. A typical use case for this function is the case when we continue
   /// code generation in a subfunction/kernel function and need to explicitly
   /// pass down certain values.
   ///
   /// @param NewValues A map that maps certain llvm::Values to new llvm::Values.
   void updateValues(ValueMapT &NewValues);
 
+  /// Return the most up-to-date version of the llvm::Value for code generation.
+  /// @param Original The Value to check for an up to date version.
+  /// @returns A remapped `Value` from ValueMap, or `Original` if no mapping
+  ///          exists.
+  /// @see IslNodeBuilder::updateValues
+  /// @see IslNodeBuilder::ValueMap
+  Value *getLatestValue(Value *Original) const;
+
   /// Generate code for a marker now.
   ///
   /// For mark nodes with an unknown name, we just forward the code generation
   /// to its child. This is currently the only behavior implemented, as there is
   /// currently not special handling for marker nodes implemented.
   ///
   /// @param Mark The node we generate code for.
   virtual void createMark(__isl_take isl_ast_node *Marker);

lib/CodeGen/IslNodeBuilder.cpp

 
 void IslNodeBuilder::getReferencesInSubtree(__isl_keep isl_ast_node *For,
                                             SetVector<Value *> &Values,
                                             SetVector<const Loop *> &Loops) {
 
   SetVector<const SCEV *> SCEVs;
   struct SubtreeReferences References = {
       LI, SE, S, ValueMap, Values, SCEVs, getBlockGenerator()};
-
   for (const auto &I : IDToValue)
     Values.insert(I.second);
 
   for (const auto &I : OutsideLoopIterations)
     Values.insert(cast<SCEVUnknown>(I.second)->getValue());
 
   isl_union_set *Schedule = isl_union_map_domain(getScheduleForAstNode(For));
   addReferencesFromStmtUnionSet(Schedule, References);
void IslNodeBuilder::getReferencesInSubtree(__isl_keep isl_ast_node *For,
   // Contains Values that may need to be replaced with other values
   // due to replacements from the ValueMap. We should make sure
   // that we return correctly remapped values.
   // NOTE: this code path is tested by:
   //     1.  test/Isl/CodeGen/OpenMP/single_loop_with_loop_invariant_baseptr.ll
   //     2.  test/Isl/CodeGen/OpenMP/loop-body-references-outer-values-3.ll
   SetVector<Value *> ReplacedValues;
   for (Value *V : Values) {
-    auto It = ValueMap.find(V);
-    if (It == ValueMap.end())
-      ReplacedValues.insert(V);
-    else
-      ReplacedValues.insert(It->second);
+    ReplacedValues.insert(getLatestValue(V));
   }
   Values = ReplacedValues;
 }
 
 void IslNodeBuilder::updateValues(ValueMapT &NewValues) {
   SmallPtrSet<Value *, 5> Inserted;
 
   for (const auto &I : IDToValue) {
     IDToValue[I.first] = NewValues[I.second];
     Inserted.insert(I.second);
   }
 
   for (const auto &I : NewValues) {
     if (Inserted.count(I.first))
       continue;
 
     ValueMap[I.first] = I.second;
   }
 }
 
+Value *IslNodeBuilder::getLatestValue(Value *Original) const {
+  auto It = ValueMap.find(Original);
+  if (It == ValueMap.end())
+    return Original;
+  return It->second;
+}
+
 void IslNodeBuilder::createUserVector(__isl_take isl_ast_node *User,
                                       std::vector<Value *> &IVS,
                                       __isl_take isl_id *IteratorID,
                                       __isl_take isl_union_map *Schedule) {
   isl_ast_expr *Expr = isl_ast_node_user_get_expr(User);
   isl_ast_expr *StmtExpr = isl_ast_expr_get_op_arg(Expr, 0);
   isl_id *Id = isl_ast_expr_get_id(StmtExpr);
   isl_ast_expr_free(StmtExpr);

lib/CodeGen/PPCGCodeGeneration.cpp

GPUNodeBuilder::getReferencesInKernel(ppcg_kernel *Kernel) {
   SetVector<Value *> ValidSubtreeValues(ValidSubtreeValuesIt.begin(),
                                         ValidSubtreeValuesIt.end());
   SetVector<Function *> ValidSubtreeFunctions(
       getFunctionsFromRawSubtreeValues(SubtreeValues));
 
   // @see IslNodeBuilder::getReferencesInSubtree
   SetVector<Value *> ReplacedValues;
   for (Value *V : ValidSubtreeValues) {
-    auto It = ValueMap.find(V);
-    if (It == ValueMap.end())
-      ReplacedValues.insert(V);
-    else
-      ReplacedValues.insert(It->second);
+    ReplacedValues.insert(getLatestValue(V));
   }
   return std::make_pair(ReplacedValues, ValidSubtreeFunctions);
 }
 
 void GPUNodeBuilder::clearDominators(Function *F) {
   DomTreeNode *N = DT.getNode(&F->getEntryBlock());
   std::vector<BasicBlock *> Nodes;
   for (po_iterator<DomTreeNode *> I = po_begin(N), E = po_end(N); I != E; ++I)
for (long i = 0; i < NumHostIters; i++) {
     insertStoreParameter(Parameters, Param, Index);
     Index++;
   }
 
   int NumVars = isl_space_dim(Kernel->space, isl_dim_param);
 
   for (long i = 0; i < NumVars; i++) {
     isl_id *Id = isl_space_get_dim_id(Kernel->space, isl_dim_param, i);
-    Value *Val = IDToValue[Id];
-    if (ValueMap.count(Val))
-      Val = ValueMap[Val];
+    Value *Val = getLatestValue(IDToValue[Id]);
     isl_id_free(Id);
 
     ArgSizes[Index] = computeSizeInBytes(Val->getType());
 
     Instruction *Param =
         new AllocaInst(Val->getType(), AddressSpace,
                        Launch + "_param_" + std::to_string(Index),
                        EntryBlock->getTerminator());