[isl] Typesafe user pointers

[philip.pfaffe]

Summary

With the new llvm::any, we can finally make the user pointers in
isl_id's typesafe! The change makes isl-noexceptions.h depend on llvm, I went
this way for a nicer API.

[philip.pfaffe]

Missed a couple of c-api uses

[bollu]

Looks good, I haven't looked too much into how Any works, which I will.

lib/Analysis/ScopInfo.cpp

1210

I believe this assert can be removed?

2082

const auto *Param?

lib/CodeGen/IslNodeBuilder.cpp

295

const auto *?

1051

const auto *?

lib/External/isl/include/isl/isl-noexceptions.h

6986

I don't know if I like an assert here. I wish there was someway to enforce this? Is the cost way to high to actually have an if + report_fatal_error?

[bollu]

Looks good, I haven't looked too much into how Any works, which I will.

lib/CodeGen/IslAst.cpp

293

This assert can be removed?

[philip.pfaffe]

Fail harder if the wrong type is given.

I don't like spelling out constness on auto when the full type is on the right
hand side.

[bollu]

lib/Analysis/ScopInfo.cpp

1210

Ditto here. The assert was not removed. We don't need it anymore since get_user should check this?

lib/CodeGen/IslAst.cpp

293

I am confused, this assert still exists?

[philip.pfaffe]

Handle nullptr users correctly

[philip.pfaffe]

Address @bollu's comments

[philip.pfaffe]

Fixery to appease the regression tests:

• Back out of cool new api in PPCGCodeGeneration.
• Don't delete Any through void*
• Fix a get_user<const>

[grosser]

Hi Philip.

we discussed this in private already. I think in general this is a good idea, but it would be nice to upstream this to the isl bindings generator:
I pushed a first patch that implements isl:🆔:alloc using std::any:

https://github.com/tobig/isl/commit/8ee4b80e920897b61daba0c290bbd142fa2a9d8e

It's a proof-of-concept, but shows how to add extensions to the C++ bindings generator.
Not super-cleaned up, but might be a start in case you want to hack on it.
One problem is that isl idscurrently do not compare equal if std::any is used:
$cat test.cpp
#include "isl/cpp.h"
#include "isl/id.h"
#include "assert.h"

int main() {

isl::ctx ctx = isl_ctx_alloc();
{

int I = 12;
isl::id id(ctx, "test", I);

I = *id.get_user<int>();

isl::id id_1(ctx, "test", &I);
isl::id id_2(ctx, "test", &I);

isl_id_dump(id_1.get());
isl_id_dump(id_2.get());
assert(id_1.get() == id_2.get());
printf("%d\n", I);
}
isl_ctx_free(ctx.get());
return 0;
$./a.out
test@0x56188ecb4220
test@0x56188ecb42a0
a.out: test.cpp:20: int main(): Assertion `id_1.get() == id_2.get()' failed.
Aborted (core dumped)
The C interface ensures that two id's that are generated with the same values become the same object.

The following discussion is also relevant:

https://github.com/PollyLabs/isl/issues/8

Best,
Tobias

[philip.pfaffe]

As we discussed offline, std::any doesn't really help polly, because it's a c++17 feature. Instead, what about making the generator itself extensible? Allow users to hook into the generation process and modify whatever happens. Then we can just emit llvm::Any privately. Additionally, this can settle the exceptions/no-exceptions debate.

Regarding the reference identity of IDs: Do we care? Is it important to reflect this behavior in the c++ API? As in, do we ever rely on this?

[grosser]

I used the std::any variant as an easy way to showcase how the bindings generator could be modified to do what we want (and also to show how an ideal interface could look like). I feel we should bring this up on the isl mailing list first to see what would be a good way to add this feature. We potentially could replace std::any with a simpler C++11 compatible solution:

http://brotherst-code.blogspot.com/2015/10/how-to-get-typeindex-without-rtti.all

Not sure if this is worth making the generator "pluggable". I feel this feature might trigger broader interest.

[philip.pfaffe]

The link is 404, but I assume it boils down to the same thing as either std::any or llvm::Any. It's not hard to reroll the implementation in isl, but then we have three.

I think making the generator customizable is orthogonal to adding std::any. But it opens to door to adding std::any into isl proper, and _replacing_ it with llvm::Any on the polly end. I feel this makes for a cleaner integration between the two.

[grosser]

http://brotherst-code.blogspot.com/2015/10/how-to-get-typeindex-without-rtti.html

lib/Analysis/ScopInfo.cpp

 const ScopArrayInfo *
 ScopArrayInfo::getFromAccessFunction(isl::pw_multi_aff PMA) {
   isl::id Id = PMA.get_tuple_id(isl::dim::out);
   assert(!Id.is_null() && "Output dimension didn't have an ID");
   return getFromId(Id);
 }
 
 const ScopArrayInfo *ScopArrayInfo::getFromId(isl::id Id) {
-  void *User = Id.get_user();
-  const ScopArrayInfo *SAI = static_cast<ScopArrayInfo *>(User);
-  return SAI;
+  return Id.get_user<const ScopArrayInfo*>();
 }
 
 void MemoryAccess::wrapConstantDimensions() {
   auto *SAI = getScopArrayInfo();
   isl::space ArraySpace = SAI->getSpace();
   isl::ctx Ctx = ArraySpace.get_ctx();
   unsigned DimsArray = SAI->getNumberOfDimensions();
 
MemoryAccess::getReductionOperatorStr(MemoryAccess::ReductionType RT) {
   case MemoryAccess::RT_BAND:
     return "&";
   }
   llvm_unreachable("Unknown reduction type");
 }
 
 const ScopArrayInfo *MemoryAccess::getOriginalScopArrayInfo() const {
   isl::id ArrayId = getArrayId();
-  void *User = ArrayId.get_user();
-  const ScopArrayInfo *SAI = static_cast<ScopArrayInfo *>(User);
-  return SAI;
+  return ScopArrayInfo::getFromId(ArrayId);
 }
 
 const ScopArrayInfo *MemoryAccess::getLatestScopArrayInfo() const {
   isl::id ArrayId = getLatestArrayId();
-  void *User = ArrayId.get_user();
-  const ScopArrayInfo *SAI = static_cast<ScopArrayInfo *>(User);
-  return SAI;
+  return ScopArrayInfo::getFromId(ArrayId);
 }
 
 isl::id MemoryAccess::getOriginalArrayId() const {
   return AccessRelation.get_tuple_id(isl::dim::out);
 }
 
 isl::id MemoryAccess::getLatestArrayId() const {
   if (!hasNewAccessRelation())
if (isRead()) {
     assert(StmtDomain.is_subset(NewDomain) &&
            "Partial READ accesses not supported");
   }
 
   isl::space NewAccessSpace = NewAccess.get_space();
   assert(NewAccessSpace.has_tuple_id(isl::dim::set) &&
          "Must specify the array that is accessed");
   isl::id NewArrayId = NewAccessSpace.get_tuple_id(isl::dim::set);
-  auto *SAI = static_cast<ScopArrayInfo *>(NewArrayId.get_user());
+  auto *SAI = NewArrayId.get_user<ScopArrayInfo *>();
   assert(SAI && "Must set a ScopArrayInfo");
 
   if (SAI->isArrayKind() && SAI->getBasePtrOriginSAI()) {
     InvariantEquivClassTy *EqClass =
         getStatement()->getParent()->lookupInvariantEquivClass(
             SAI->getBasePtr());
     assert(EqClass &&
            "Access functions to indirect arrays must have an invariant and "
            "hoisted base pointer");
if (Call && isConstCall(Call)) {
               LI->getPointerOperand()->stripInBoundsOffsets()->getName();
         }
       }
     }
 
     ParameterName = getIslCompatibleName("", ParameterName, "");
   }
 
-  isl::id Id = isl::id::alloc(getIslCtx(), ParameterName,
-                              const_cast<void *>((const void *)Parameter));
+  isl::id Id = isl::id::alloc(getIslCtx(), ParameterName, Parameter);
   ParameterIds[Parameter] = Id;
 }
 
 void Scop::addParams(const ParameterSetTy &NewParameters) {
   for (const SCEV *Parameter : NewParameters) {
     // Normalize the SCEV to get the representing element for an invariant load.
     Parameter = extractConstantFactor(Parameter, *SE).second;
     Parameter = getRepresentingInvariantLoadSCEV(Parameter);
if (InScop) {
       AssumptionCtx = isl_set_complement(ConditionSets[1]);
       AssumptionCtx = isl_set_intersect(AssumptionCtx, ConditionSets[0]);
     }
 
     // Project out newly introduced parameters as they are not otherwise useful.
     if (!NewParams.empty()) {
       for (unsigned u = 0; u < isl_set_n_param(AssumptionCtx); u++) {
         auto *Id = isl_set_get_dim_id(AssumptionCtx, isl_dim_param, u);
-        auto *Param = static_cast<const SCEV *>(isl_id_get_user(Id));
-        isl_id_free(Id);
+        auto *Param = isl::manage(Id).get_user<const SCEV *>();
 
         if (!NewParams.count(Param))
           continue;
 
         AssumptionCtx =
             isl_set_project_out(AssumptionCtx, isl_dim_param, u--, 1);
       }
     }

lib/CodeGen/IslAst.cpp

 //
 // In this function we also run the following analyses:
 //
 // - Detection of openmp parallel loops
 //
 static __isl_give isl_id *astBuildBeforeFor(__isl_keep isl_ast_build *Build,
                                             void *User) {
   AstBuildUserInfo *BuildInfo = (AstBuildUserInfo *)User;
-  IslAstUserPayload *Payload = new IslAstUserPayload();
-  isl_id *Id = isl_id_alloc(isl_ast_build_get_ctx(Build), "", Payload);
-  Id = isl_id_set_free_user(Id, freeIslAstUserPayload);
-  BuildInfo->LastForNodeId = Id;
+  auto Id = isl::id::alloc(isl::ctx(isl_ast_build_get_ctx(Build)), "",
+                           IslAstUserPayload());
+  auto &Payload = Id.get_user<IslAstUserPayload>();
+  BuildInfo->LastForNodeId = Id.get();
 
   // Test for parallelism only if we are not already inside a parallel loop
   if (!BuildInfo->InParallelFor)
-    BuildInfo->InParallelFor = Payload->IsOutermostParallel =
-        astScheduleDimIsParallel(Build, BuildInfo->Deps, Payload);
+    BuildInfo->InParallelFor = Payload.IsOutermostParallel =
+        astScheduleDimIsParallel(Build, BuildInfo->Deps, &Payload);
 
-  return Id;
+  return Id.release();
 }
 
 // This method is executed after the construction of a for node.
 //
 // It performs the following actions:
 //
 // - Reset the 'InParallelFor' flag, as soon as we leave a for node,
 //   that is marked as openmp parallel.
 //
 static __isl_give isl_ast_node *
 astBuildAfterFor(__isl_take isl_ast_node *Node, __isl_keep isl_ast_build *Build,
                  void *User) {
   isl_id *Id = isl_ast_node_get_annotation(Node);
   assert(Id && "Post order visit assumes annotated for nodes");
-  IslAstUserPayload *Payload = (IslAstUserPayload *)isl_id_get_user(Id);
+  IslAstUserPayload *Payload =
+      isl::manage_copy(Id).get_user<IslAstUserPayload *>();
   assert(Payload && "Post order visit assumes annotated for nodes");
 
   AstBuildUserInfo *BuildInfo = (AstBuildUserInfo *)User;
   assert(!Payload->Build && "Build environment already set");
   Payload->Build = isl_ast_build_copy(Build);
   Payload->IsInnermost = (Id == BuildInfo->LastForNodeId);
 
   // Innermost loops that are surrounded by parallel loops have not yet been
   // tested for parallelism. Test them here to ensure we check all innermost
astBuildAfterMark(__isl_take isl_ast_node *Node,
   return Node;
 }
 
 static __isl_give isl_ast_node *AtEachDomain(__isl_take isl_ast_node *Node,
                                              __isl_keep isl_ast_build *Build,
                                              void *User) {
   assert(!isl_ast_node_get_annotation(Node) && "Node already annotated");
 
-  IslAstUserPayload *Payload = new IslAstUserPayload();
-  isl_id *Id = isl_id_alloc(isl_ast_build_get_ctx(Build), "", Payload);
-  Id = isl_id_set_free_user(Id, freeIslAstUserPayload);
+  auto Id = isl::id::alloc(isl::ctx(isl_ast_build_get_ctx(Build)), "",
+                           IslAstUserPayload());
+  auto &Payload = Id.get_user<IslAstUserPayload>();
 
-  Payload->Build = isl_ast_build_copy(Build);
+  Payload.Build = isl_ast_build_copy(Build);
 
-  return isl_ast_node_set_annotation(Node, Id);
+  return isl_ast_node_set_annotation(Node, Id.release());
 }
 
 // Build alias check condition given a pair of minimal/maximal access.
 static isl::ast_expr buildCondition(Scop &S, isl::ast_build Build,
                                     const Scop::MinMaxAccessTy *It0,
                                     const Scop::MinMaxAccessTy *It1) {
 
   isl::pw_multi_aff AFirst = It0->first;

 __isl_give isl_ast_expr *IslAstInfo::getRunCondition() {
   return Ast.getRunCondition();
 }
 
 IslAstUserPayload *IslAstInfo::getNodePayload(__isl_keep isl_ast_node *Node) {
   isl_id *Id = isl_ast_node_get_annotation(Node);
   if (!Id)
     return nullptr;
-  IslAstUserPayload *Payload = (IslAstUserPayload *)isl_id_get_user(Id);
-  isl_id_free(Id);
+  IslAstUserPayload *Payload = isl::manage(Id).get_user<IslAstUserPayload *>();
   return Payload;
 }
 
 bool IslAstInfo::isInnermost(__isl_keep isl_ast_node *Node) {
   IslAstUserPayload *Payload = getNodePayload(Node);
   return Payload && Payload->IsInnermost;
 }
 

 static __isl_give isl_printer *cbPrintUser(__isl_take isl_printer *P,
                                            __isl_take isl_ast_print_options *O,
                                            __isl_keep isl_ast_node *Node,
                                            void *User) {
   isl::ast_node AstNode = isl::manage_copy(Node);
   isl::ast_expr NodeExpr = AstNode.user_get_expr();
   isl::ast_expr CallExpr = NodeExpr.get_op_arg(0);
   isl::id CallExprId = CallExpr.get_id();
-  ScopStmt *AccessStmt = (ScopStmt *)CallExprId.get_user();
+  ScopStmt *AccessStmt = CallExprId.get_user<ScopStmt *>();
 
   P = isl_printer_start_line(P);
   P = isl_printer_print_str(P, AccessStmt->getBaseName());
   P = isl_printer_print_str(P, "(");
   P = isl_printer_end_line(P);
   P = isl_printer_indent(P, 2);
 
   for (MemoryAccess *MemAcc : *AccessStmt) {

lib/CodeGen/IslNodeBuilder.cpp

 /// these locations in the set of out-of-scop values as well.
 ///
 /// @param Set     A set which references the ScopStmt we are interested in.
 /// @param UserPtr A void pointer that can be casted to a SubtreeReferences
 ///                structure.
 static void addReferencesFromStmtSet(isl::set Set,
                                      struct SubtreeReferences *UserPtr) {
   isl::id Id = Set.get_tuple_id();
-  auto *Stmt = static_cast<const ScopStmt *>(Id.get_user());
+  auto *Stmt = Id.get_user<const ScopStmt *>();
   return addReferencesFromStmt(Stmt, UserPtr);
 }
 
 /// Extract the out-of-scop values and SCEVs referenced from a union set
 /// referencing multiple ScopStmts.
 ///
 /// This includes the SCEVUnknowns referenced by the SCEVs used in the
 /// statement and the base pointers of the memory accesses. For scalar

 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);
-  ScopStmt *Stmt = (ScopStmt *)isl_id_get_user(Id);
+  ScopStmt *Stmt = isl::manage_copy(Id).get_user<ScopStmt *>();
   std::vector<LoopToScevMapT> VLTS(IVS.size());
 
   isl_union_set *Domain = isl_union_set_from_set(Stmt->getDomain().release());
   Schedule = isl_union_map_intersect_domain(Schedule, Domain);
   isl_map *S = isl_map_from_union_map(Schedule);
 
   auto *NewAccesses = createNewAccesses(Stmt, User);
   createSubstitutionsVector(Expr, Stmt, VLTS, IVS, IteratorID);
if (strcmp(isl_id_get_name(Id), "SIMD") == 0 &&
     if (Vector && 1 < VectorWidth && VectorWidth <= 16)
       createForVector(Child, VectorWidth);
     else
       createForSequential(Child, true);
     isl_id_free(Id);
     return;
   }
   if (strcmp(isl_id_get_name(Id), "Inter iteration alias-free") == 0) {
-    auto *BasePtr = static_cast<Value *>(isl_id_get_user(Id));
+    auto *BasePtr = isl::manage_copy(Id).get_user<Value *>();
     Annotator.addInterIterationAliasFreeBasePtr(BasePtr);
   }
   create(Child);
   isl_id_free(Id);
 }
 
 void IslNodeBuilder::createForVector(__isl_take isl_ast_node *For,
                                      int VectorWidth) {
return isl_ast_node_foreach_descendant_top_down(
                if (isl_ast_node_get_type(Node) != isl_ast_node_user)
                  return isl_bool_true;
 
                isl::ast_expr Expr =
                    isl::manage(isl_ast_node_user_get_expr(Node));
                isl::ast_expr StmtExpr = Expr.get_op_arg(0);
                isl::id Id = StmtExpr.get_id();
 
-               ScopStmt *Stmt =
-                   static_cast<ScopStmt *>(isl_id_get_user(Id.get()));
+               ScopStmt *Stmt = Id.get_user<ScopStmt *>();
                isl::set StmtDom = Stmt->getDomain();
                for (auto *MA : *Stmt) {
                  if (MA->isLatestPartialAccess())
                    return isl_bool_error;
                }
                return isl_bool_true;
              },
              nullptr) == isl_stat_error;
void IslNodeBuilder::createUser(__isl_take isl_ast_node *User) {
 
   isl_ast_expr *Expr = isl_ast_node_user_get_expr(User);
   isl_ast_expr *StmtExpr = isl_ast_expr_get_op_arg(Expr, 0);
   Id = isl_ast_expr_get_id(StmtExpr);
   isl_ast_expr_free(StmtExpr);
 
   LTS.insert(OutsideLoopIterations.begin(), OutsideLoopIterations.end());
 
-  Stmt = (ScopStmt *)isl_id_get_user(Id);
+  Stmt = isl::manage_copy(Id).get_user<ScopStmt *>();
   auto *NewAccesses = createNewAccesses(Stmt, User);
   if (Stmt->isCopyStmt()) {
     generateCopyStmt(Stmt, NewAccesses);
     isl_ast_expr_free(Expr);
   } else {
     createSubstitutions(Expr, Stmt, LTS);
 
     if (Stmt->isBlockStmt())
void IslNodeBuilder::create(__isl_take isl_ast_node *Node) {
   }
 
   llvm_unreachable("Unknown isl_ast_node type");
 }
 
 bool IslNodeBuilder::materializeValue(isl_id *Id) {
   // If the Id is already mapped, skip it.
   if (!IDToValue.count(Id)) {
-    auto *ParamSCEV = (const SCEV *)isl_id_get_user(Id);
+    auto *ParamSCEV = isl::manage_copy(Id).get_user<const SCEV *>();
     Value *V = nullptr;
 
     // Parameters could refer to invariant loads that need to be
     // preloaded before we can generate code for the parameter. Thus,
     // check if any value referred to in ParamSCEV is an invariant load
     // and if so make sure its equivalence class is preloaded.
     SetVector<Value *> Values;
     findValues(ParamSCEV, SE, Values);

lib/CodeGen/PPCGCodeGeneration.cpp

 }
 
 void GPUNodeBuilder::createDataTransfer(__isl_take isl_ast_node *TransferStmt,
                                         enum DataDirection Direction) {
   assert(!PollyManagedMemory && "Managed memory needs no data transfers");
   isl_ast_expr *Expr = isl_ast_node_user_get_expr(TransferStmt);
   isl_ast_expr *Arg = isl_ast_expr_get_op_arg(Expr, 0);
   isl_id *Id = isl_ast_expr_get_id(Arg);
-  auto Array = (gpu_array_info *)isl_id_get_user(Id);
+  auto Array = isl::manage_copy(Id).get_user<gpu_array_info *>();
   auto ScopArray = (ScopArrayInfo *)(Array->user);
 
   Value *Size = getArraySize(Array);
   Value *Offset = getArrayOffset(Array);
   Value *DevPtr = DeviceAllocations[ScopArray];
 
   Value *HostPtr;
 
if (!PollyManagedMemory) {
       isl_ast_node_free(UserStmt);
     }
     isl_ast_expr_free(Expr);
     return;
   }
 
   isl_id *Anno = isl_ast_node_get_annotation(UserStmt);
   struct ppcg_kernel_stmt *KernelStmt =
-      (struct ppcg_kernel_stmt *)isl_id_get_user(Anno);
+      isl::manage_copy(Anno).get_user<struct ppcg_kernel_stmt *>();
   isl_id_free(Anno);
 
   switch (KernelStmt->type) {
   case ppcg_kernel_domain:
     createScopStmt(Expr, KernelStmt);
     isl_ast_node_free(UserStmt);
     return;
   case ppcg_kernel_copy:
isl_bool collectReferencesInGPUStmt(__isl_keep isl_ast_node *Node, void *User) {
   isl_id_free(Id);
   isl_ast_expr_free(StmtExpr);
   isl_ast_expr_free(Expr);
 
   if (!isPrefix(Str, "Stmt"))
     return isl_bool_true;
 
   Id = isl_ast_node_get_annotation(Node);
-  auto *KernelStmt = (ppcg_kernel_stmt *)isl_id_get_user(Id);
+  auto *KernelStmt = isl::manage_copy(Id).get_user<ppcg_kernel_stmt *>();
   auto Stmt = (ScopStmt *)KernelStmt->u.d.stmt->stmt;
   isl_id_free(Id);
 
   addReferencesFromStmt(Stmt, User, false /* CreateScalarRefs */);
 
   return isl_bool_true;
 }
 
for (auto Fn : SubtreeFunctions) {
     assert(Clone && "Expected cloned function to be initialized.");
     assert(ValueMap.find(Fn) == ValueMap.end() &&
            "Fn already present in ValueMap");
     ValueMap[Fn] = Clone;
   }
 }
 void GPUNodeBuilder::createKernel(__isl_take isl_ast_node *KernelStmt) {
   isl_id *Id = isl_ast_node_get_annotation(KernelStmt);
-  ppcg_kernel *Kernel = (ppcg_kernel *)isl_id_get_user(Id);
+  ppcg_kernel *Kernel = isl::manage_copy(Id).get_user<ppcg_kernel *>();
   isl_id_free(Id);
   isl_ast_node_free(KernelStmt);
 
   if (Kernel->n_grid > 1)
     DeepestParallel =
         std::max(DeepestParallel, isl_space_dim(Kernel->space, isl_dim_set));
   else
     DeepestSequential =
if (Id) {
         P = isl_printer_start_line(P);
         P = isl_printer_print_ast_node(P, Node);
         P = isl_printer_end_line(P);
         isl_id_free(Id);
         isl_ast_print_options_free(Options);
         return P;
       }
 
-      auto Kernel = (struct ppcg_kernel *)isl_id_get_user(Id);
+      auto Kernel = isl::manage_copy(Id).get_user<struct ppcg_kernel *>();
       isl_id_free(Id);
       Data->Kernels.push_back(Kernel);
     }
 
     return print_host_user(P, Options, Node, User);
   }
 
   /// Print C code corresponding to the control flow in @p Kernel.

lib/External/isl/include/isl/isl-noexceptions.h

 #include <isl/union_map.h>
 #include <isl/flow.h>
 #include <isl/schedule.h>
 #include <isl/schedule_node.h>
 #include <isl/ast_build.h>
 #include <isl/constraint.h>
 #include <isl/polynomial.h>
 #include <isl/mat.h>
+#include <llvm/ADT/Any.h>
 
 #include <functional>
 #include <string>
 
 namespace isl {
 inline namespace noexceptions {
 
 #define ISLPP_STRINGIZE_(X) #X
public:
   inline __isl_keep isl_id *get() const;
   inline __isl_give isl_id *release();
   inline bool is_null() const;
   inline explicit operator bool() const;
   inline isl::ctx get_ctx() const;
   inline std::string to_str() const;
   inline void dump() const;
 
-  static inline isl::id alloc(isl::ctx ctx, const std::string &name, void * user);
+  template <typename T>
+  static inline isl::id alloc(isl::ctx ctx, const std::string &name, T &&user);
   inline uint32_t get_hash() const;
   inline std::string get_name() const;
-  inline void * get_user() const;
+  template <typename T> inline T &get_user() const;
 };
 
 // declarations for isl::id_list
 inline isl::id_list manage(__isl_take isl_id_list *ptr);
 inline isl::id_list manage_copy(__isl_keep isl_id_list *ptr);
 
 class id_list {
   friend inline isl::id_list manage(__isl_take isl_id_list *ptr);

 }
 
 
 void id::dump() const {
   isl_id_dump(get());
 }
 
 
-isl::id id::alloc(isl::ctx ctx, const std::string &name, void * user)
+template <typename T>
+isl::id id::alloc(isl::ctx ctx, const std::string &name, T &&user)
 {
-  auto res = isl_id_alloc(ctx.release(), name.c_str(), user);
+  auto res = isl_id_alloc(ctx.release(), name.c_str(),
+                          new llvm::Any(std::forward<T>(user)));
+  res = isl_id_set_free_user(res, [](void *user) { delete user; });
   return manage(res);
 }
 
 uint32_t id::get_hash() const
 {
   auto res = isl_id_get_hash(get());
   return res;
 }
 
 std::string id::get_name() const
 {
   auto res = isl_id_get_name(get());
   std::string tmp(res);
   return tmp;
 }
 
-void * id::get_user() const
-{
-  auto res = isl_id_get_user(get());
-  return res;
+template <typename T> T &id::get_user() const {
+  auto Any = static_cast<llvm::Any*>(isl_id_get_user(get()));
+  T *User = llvm::any_cast<T>(Any);
+  assert(User && "Tried to fetch wrong user type from isl_id");
+  return *User;
 }
 
 // implementations for isl::id_list
 isl::id_list manage(__isl_take isl_id_list *ptr) {
   return id_list(ptr);
 }
 isl::id_list manage_copy(__isl_keep isl_id_list *ptr) {
   ptr = isl_id_list_copy(ptr);

lib/Transform/ForwardOpTree.cpp

isl::map singleLocation(isl::union_map MustKnown, isl::set Domain) {
 
     // MemoryAccesses can read only elements from a single array
     // (i.e. not: { Dom[0] -> A[0]; Dom[1] -> B[1] }).
     // Look through all spaces until we find one that contains at least the
     // wanted statement instance.s
     for (isl::map Map : MustKnown.get_map_list()) {
       // Get the array this is accessing.
       isl::id ArrayId = Map.get_tuple_id(isl::dim::out);
-      ScopArrayInfo *SAI = static_cast<ScopArrayInfo *>(ArrayId.get_user());
+      ScopArrayInfo *SAI = ArrayId.get_user<ScopArrayInfo *>();
 
       // No support for generation of indirect array accesses.
       if (SAI->getBasePtrOriginSAI())
         continue;
 
       // Determine whether this map contains all wanted values.
       isl::set MapDom = Map.domain();
       if (!Domain.is_subset(MapDom).is_true())
public:
   /// @param LI             The instruction that does the access.
   /// @param AccessRelation The array element that each statement instance
   ///                       accesses.
   ///
   /// @param The newly created access.
   MemoryAccess *makeReadArrayAccess(ScopStmt *Stmt, LoadInst *LI,
                                     isl::map AccessRelation) {
     isl::id ArrayId = AccessRelation.get_tuple_id(isl::dim::out);
-    ScopArrayInfo *SAI = reinterpret_cast<ScopArrayInfo *>(ArrayId.get_user());
+    ScopArrayInfo *SAI = ArrayId.get_user<ScopArrayInfo *>();
 
     // Create a dummy SCEV access, to be replaced anyway.
     SmallVector<const SCEV *, 4> Sizes;
     Sizes.reserve(SAI->getNumberOfDimensions());
     SmallVector<const SCEV *, 4> Subscripts;
     Subscripts.reserve(SAI->getNumberOfDimensions());
     for (unsigned i = 0; i < SAI->getNumberOfDimensions(); i += 1) {
       Sizes.push_back(SAI->getDimensionSize(i));

lib/Transform/MaximalStaticExpansion.cpp

for (isl::map Map : Dependences.get_map_list()) {
     // Filter out Statement to Statement dependences.
     if (!Map.can_curry())
       continue;
 
     // Intersect with the relevant SAI.
     auto TmpMapDomainId =
         Map.get_space().domain().unwrap().range().get_tuple_id(isl::dim::set);
 
-    ScopArrayInfo *UserSAI =
-        static_cast<ScopArrayInfo *>(TmpMapDomainId.get_user());
+    ScopArrayInfo *UserSAI = TmpMapDomainId.get_user<ScopArrayInfo *>();
 
     if (SAI != UserSAI)
       continue;
 
     // Get the correct S1[] -> S2[] dependence.
     auto NewMap = Map.factor_domain();
     auto NewMapDomainId = NewMap.domain().get_tuple_id();
 

lib/Transform/ScheduleOptimizer.cpp

 /// @param  PartialSchedule The partial schedule of the SCoP statement.
 /// @param  MMI             Parameters of the matrix multiplication operands.
 /// @return                 True in case the corresponding SCoP statement
 ///                         represents matrix multiplication and false,
 ///                         otherwise.
 static bool containsOnlyMatrMultAcc(isl::map PartialSchedule,
                                     MatMulInfoTy &MMI) {
   auto InputDimId = PartialSchedule.get_tuple_id(isl::dim::in);
-  auto *Stmt = static_cast<ScopStmt *>(InputDimId.get_user());
+  auto *Stmt = InputDimId.get_user<ScopStmt *>();
   unsigned OutDimNum = PartialSchedule.dim(isl::dim::out);
   assert(OutDimNum > 2 && "In case of the matrix multiplication the loop nest "
                           "and, consequently, the corresponding scheduling "
                           "functions have at least three dimensions.");
   auto MapI =
       permuteDimensions(PartialSchedule, isl::dim::out, MMI.i, OutDimNum - 1);
   auto MapJ =
       permuteDimensions(PartialSchedule, isl::dim::out, MMI.j, OutDimNum - 1);

 ///
 /// @param PartialSchedule The PartialSchedule that contains a SCoP statement
 ///        to check.
 /// @D     The SCoP dependencies.
 /// @MMI   Parameters of the matrix multiplication operands.
 static bool containsMatrMult(isl::map PartialSchedule, const Dependences *D,
                              MatMulInfoTy &MMI) {
   auto InputDimsId = PartialSchedule.get_tuple_id(isl::dim::in);
-  auto *Stmt = static_cast<ScopStmt *>(InputDimsId.get_user());
+  auto *Stmt = InputDimsId.get_user<ScopStmt *>();
   if (Stmt->size() <= 1)
     return false;
 
   auto Accesses = getAccessesInOrder(*Stmt);
   for (auto *MemA = Accesses.end() - 1; MemA != Accesses.begin(); MemA--) {
     auto *MemAccessPtr = *MemA;
     if (!MemAccessPtr->isLatestArrayKind())
       continue;

 /// @param MMI Parameters of the matrix multiplication operands.
 /// @return The optimized schedule node.
 static isl::schedule_node
 optimizeDataLayoutMatrMulPattern(isl::schedule_node Node, isl::map MapOldIndVar,
                                  MicroKernelParamsTy MicroParams,
                                  MacroKernelParamsTy MacroParams,
                                  MatMulInfoTy &MMI) {
   auto InputDimsId = MapOldIndVar.get_tuple_id(isl::dim::in);
-  auto *Stmt = static_cast<ScopStmt *>(InputDimsId.get_user());
+  auto *Stmt = InputDimsId.get_user<ScopStmt *>();
 
   // Create a copy statement that corresponds to the memory access to the
   // matrix B, the second operand of the matrix multiplication.
   Node = Node.parent().parent().parent().parent().parent().parent();
   Node = isl::manage(isl_schedule_node_band_split(Node.release(), 2)).child(0);
   auto AccRel = getMatMulAccRel(MapOldIndVar, 3, 7);
   unsigned FirstDimSize = MacroParams.Nc / MicroParams.Nr;
   unsigned SecondDimSize = MacroParams.Kc;

lib/Transform/Simplify.cpp

for (auto &Stmt : *S) {
 
           // Lookup future write that fulfills these conditions.
           // { [[Domain[] -> Element[]] -> Value[]] -> MemoryAccess[] }
           isl::union_map Filtered =
               FutureWrites.uncurry().intersect_domain(Filter.wrap());
 
           // Iterate through the candidates.
           for (isl::map Map : Filtered.get_map_list()) {
-            MemoryAccess *OtherMA = (MemoryAccess *)Map.get_space()
+            MemoryAccess *OtherMA = Map.get_space()
                                         .get_tuple_id(isl::dim::out)
-                                        .get_user();
+                                        .get_user<MemoryAccess *>();
 
             isl::map OtherAccRel =
                 OtherMA->getLatestAccessRelation().intersect_domain(Domain);
 
             // The filter only guaranteed that some of OtherMA's accessed
             // elements are allowed. Verify that it only accesses allowed
             // elements. Otherwise, continue with the next candidate.
             if (!OtherAccRel.is_subset(AllowedAccesses).is_true())
for (auto &Stmt : *S) {
         // Two writes cannot be coalesced if there is another access (to some of
         // the written elements) between them. Remove all visited write accesses
         // from the list of eligible writes. Don't just remove the accessed
         // elements, but any MemoryAccess that touches any of the invalidated
         // elements.
         SmallPtrSet<MemoryAccess *, 2> TouchedAccesses;
         for (isl::map Map :
              FutureWrites.intersect_domain(AccRelWrapped).get_map_list()) {
-          MemoryAccess *MA = (MemoryAccess *)Map.get_space()
+          MemoryAccess *MA = Map.get_space()
                                  .range()
                                  .unwrap()
                                  .get_tuple_id(isl::dim::out)
-                                 .get_user();
+                                 .get_user<MemoryAccess *>();
           TouchedAccesses.insert(MA);
         }
         isl::union_map NewFutureWrites =
             isl::union_map::empty(FutureWrites.get_space());
         for (isl::map FutureWrite : FutureWrites.get_map_list()) {
-          MemoryAccess *MA = (MemoryAccess *)FutureWrite.get_space()
+          MemoryAccess *MA = FutureWrite.get_space()
                                  .range()
                                  .unwrap()
                                  .get_tuple_id(isl::dim::out)
-                                 .get_user();
+                                 .get_user<MemoryAccess *>();
           if (!TouchedAccesses.count(MA))
             NewFutureWrites = NewFutureWrites.add_map(FutureWrite);
         }
         FutureWrites = NewFutureWrites;
 
         if (MA->isMustWrite() && !ValSet.is_null()) {
           // { MemoryAccess[] }
           auto AccSet =

lib/Transform/ZoneAlgo.cpp

isl::map ZoneAlgorithm::getScalarReachingDefinition(ScopStmt *Stmt) {
   Result = computeScalarReachingDefinition(Schedule, Domain, false, true);
   simplify(Result);
 
   return Result;
 }
 
 isl::map ZoneAlgorithm::getScalarReachingDefinition(isl::set DomainDef) {
   auto DomId = DomainDef.get_tuple_id();
-  auto *Stmt = static_cast<ScopStmt *>(isl_id_get_user(DomId.get()));
+  auto *Stmt = DomId.get_user<ScopStmt *>();
 
   auto StmtResult = getScalarReachingDefinition(Stmt);
 
   return StmtResult.intersect_range(DomainDef);
 }
 
 isl::map ZoneAlgorithm::makeUnknownForDomain(ScopStmt *Stmt) const {
   return ::makeUnknownForDomain(getDomainFor(Stmt));
for (isl::map Map : Input.get_map_list()) {
 
     // Instructions within the SCoP are always wrapped. Non-wrapped tuples
     // are therefore invariant in the SCoP and don't need normalization.
     if (!RangeSpace.is_wrapping()) {
       Result = Result.add_map(Map);
       continue;
     }
 
-    auto *PHI = dyn_cast<PHINode>(static_cast<Value *>(
-        RangeSpace.unwrap().get_tuple_id(isl::dim::out).get_user()));
+    auto *PHI = dyn_cast<PHINode>(
+        RangeSpace.unwrap().get_tuple_id(isl::dim::out).get_user<Value *>());
 
     // If no normalization is necessary, then the ValInst stands for itself.
     if (!ComputedPHIs.count(PHI)) {
       Result = Result.add_map(Map);
       continue;
     }
 
     // Otherwise, apply the normalization.
isl::boolean ZoneAlgorithm::isNormalized(isl::map Map) {
   isl::boolean IsWrapping = RangeSpace.is_wrapping();
   if (!IsWrapping.is_true())
     return !IsWrapping;
   isl::space Unwrapped = RangeSpace.unwrap();
 
   isl::id OutTupleId = Unwrapped.get_tuple_id(isl::dim::out);
   if (OutTupleId.is_null())
     return isl::boolean();
-  auto *PHI = dyn_cast<PHINode>(static_cast<Value *>(OutTupleId.get_user()));
+  auto *PHI = dyn_cast<PHINode>(OutTupleId.get_user<Value *>());
   if (!PHI)
     return true;
 
   isl::id InTupleId = Unwrapped.get_tuple_id(isl::dim::in);
   if (OutTupleId.is_null())
     return isl::boolean();
-  auto *IncomingStmt = static_cast<ScopStmt *>(InTupleId.get_user());
+  auto *IncomingStmt = InTupleId.get_user<ScopStmt *>();
   MemoryAccess *PHIRead = IncomingStmt->lookupPHIReadOf(PHI);
   if (!isNormalizable(PHIRead))
     return true;
 
   return false;
 }
 
 isl::boolean ZoneAlgorithm::isNormalized(isl::union_map UMap) {