reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

Declarations

 2642   inline set &operator=(set obj);

References

 2620   void setDomain(BasicBlock *BB, isl::set &Domain) { DomainMap[BB] = Domain; }

  193     Zero = Zero.fix_si(isl::dim::set, i, 0);
  671     Zero = Zero.fix_si(isl::dim::set, i, 0);

  217       BoundedParts = BoundedParts.unite(isl::set(BSet));
  228     S = S.lower_bound_si(isl::dim::set, u, 0);
  235   OnlyDimS = OnlyDimS.project_out(isl::dim::set, Dim + 1, NumDimsS - Dim - 1);
  239   OnlyDimS = OnlyDimS.insert_dims(isl::dim::param, 0, Dim);
  246     OnlyDimS = OnlyDimS.add_constraint(C);
  253   BoundedParts =
  257   BoundedParts = BoundedParts.remove_dims(isl::dim::param, 0, Dim);
  313     Dom = Dom.project_out(isl::dim::set, NewDepth, 1);
  314     Dom = Dom.add_dims(isl::dim::set, 1);
  321     Dom = Dom.add_dims(isl::dim::set, 1);
  327     Dom = Dom.project_out(isl::dim::set, NumDim - Diff, Diff);
  348   InvalidDomainMap[BB] = InvalidDomainMap[BB].unite(PWAC.second);
  613     Domain = Domain.intersect(PredDom).coalesce();
  614     Domain = Domain.align_params(scop->getParamSpace());
  661   ExitDomain = ExitDomain ? AdjustedDomain.unite(ExitDomain) : AdjustedDomain;
  664   InvalidDomainMap[ExitBB] = ExitDomain.empty(ExitDomain.get_space());
  716     PredBBDom = adjustDomainDimensions(PredBBDom, PredBBLoop, BBLoop);
  717     PredDom = PredDom.unite(PredBBDom);
  754       BackedgeCondition = LatchBBDom;
  765       BackedgeCondition = isl::manage(ConditionSets[idx]);
  770     BackedgeCondition = BackedgeCondition.project_out(
  772     UnionBackedgeCondition = UnionBackedgeCondition.unite(BackedgeCondition);
  781   UnionBackedgeConditionComplement =
  784   UnionBackedgeConditionComplement =
  786   HeaderBBDom = HeaderBBDom.subtract(UnionBackedgeConditionComplement);
  787   HeaderBBDom = HeaderBBDom.apply(NextIterationMap);
  790   HeaderBBDom = Parts.second;
  834   InvalidDomainMap[EntryBB] = isl::manage(isl_set_empty(isl_set_get_space(S)));
  961       CondSet = adjustDomainDimensions(CondSet, BBLoop, SuccBBLoop);
  969         SuccDomain = SuccDomain.unite(CondSet).coalesce();
  972         InvalidDomainMap[SuccBB] = CondSet.empty(CondSet.get_space());
  973         SuccDomain = CondSet;
  976       SuccDomain = SuccDomain.detect_equalities();
 1018       InvalidDomain = InvalidDomain.intersect(Domain);
 1020       InvalidDomain = Domain;
 1025       Domain = isl::set::empty(Domain.get_space());
 1029       InvalidDomainMap[BB] = InvalidDomain;
 1054       SuccInvalidDomain = SuccInvalidDomain.unite(AdjustedInvalidDomain);
 1055       SuccInvalidDomain = SuccInvalidDomain.coalesce();
 1057       InvalidDomainMap[SuccBB] = SuccInvalidDomain;
 1069     InvalidDomainMap[BB] = InvalidDomain;
 2370       DimOnly = DimOnly.project_out(isl::dim::set, 1, Dims - i - 1);
 2371       DimOnly = DimOnly.lower_bound_si(isl::dim::set, 0, 0);
 2627   Stmt.Domain = scop->getDomainConditions(&Stmt);
 2628   Stmt.Domain = Stmt.Domain.set_tuple_id(Id);
 2847     UserContext = UserContext.set_dim_id(isl::dim::param, i,
 2894     SafeToLoad = isl::set::universe(AccessRelation.get_space().range());
 2900     SafeToLoad = AccessRelation.range();
 2913   WrittenCtx = WrittenCtx.remove_divs();
 2979   DomainCtx = DomainCtx.subtract(StmtInvalidCtx);
 3006             DomainCtx = DomainCtx.eliminate(isl::dim::param, Dim, 1);
 3031       MACtx = isl::set::universe(DomainCtx.get_space());
 3033       MACtx = DomainCtx;
 3034       MACtx = MACtx.subtract(MAInvalidCtx.unite(NHCtx));
 3035       MACtx = MACtx.gist_params(scop->getContext());
 3068         IAClassDomainCtx = IAClassDomainCtx.unite(MACtx).coalesce();
 3070         IAClassDomainCtx = MACtx;
 3071       IAClass.ExecutionContext = IAClassDomainCtx;
 3078     MACtx = MACtx.coalesce();
 3235   Set = Set.remove_divs();
 3239     Set = Set.simple_hull();
 3319   Domain = Domain.project_out(isl::dim::set, 0, Domain.n_dim());
 3518         AGDomain = AGDomain.unite(MADomain);

  175   S = S.lower_bound_val(type, dim, V);
  177   S = S.upper_bound_val(type, dim, V);
  194     S = SLB.unite(SUB);
  679     DimOutside = DimOutside.unite(SizeE.le_set(Var));
  681     Outside = Outside.unite(DimOutside);
  684   Outside = Outside.apply(getAccessRelation().reverse());
  685   Outside = Outside.intersect(Statement->getDomain());
  686   Outside = Outside.params();
  692   Outside = Outside.remove_divs();
  693   Outside = Outside.complement();
  698     Outside = Outside.gist_params(Statement->getDomain().params());
  767   AccessRange = addRangeBoundsToSet(AccessRange, ConstantRange(Min, Max), 0,
  845   InvalidDomain = isl::set::empty(StmtInvalidDomain.get_space());
  926   InvalidDomain = InvalidDomain.gist_params(Ctx);
  981   StmtDom = StmtDom.reset_tuple_id();
  983   InvalidDomain = InvalidDomain.unite(NewInvalidDom);
 1040   Stride = getStride(Schedule);
 1041   StrideX = isl::set::universe(Stride.get_space());
 1043     StrideX = StrideX.fix_si(isl::dim::set, i, 0);
 1044   StrideX = StrideX.fix_si(isl::dim::set, StrideX.dim(isl::dim::set) - 1,
 1078     StmtDomain =
 1141   Domain = NewDomain;
 1184   InvalidDomain = InvalidDomain.gist_params(Ctx);
 1185   Domain = Domain.gist_params(Ctx);
 1209   Domain = Domain.set_tuple_id(Id);
 1234 void ScopStmt::setInvalidDomain(isl::set ID) { InvalidDomain = ID; }
 1381   Context = NewContext.align_params(Context.get_space());
 1550   Context = isl::set::universe(Space);
 1551   InvalidContext = isl::set::empty(Space);
 1552   AssumedContext = isl::set::universe(Space);
 1559     Context = addRangeBoundsToSet(Context, SRange, PDim++, isl::dim::param);
 1592     Context = Context.lower_bound_si(isl::dim::param, dim, 0);
 1606   Context = Context.align_params(Space);
 1609   Context = boundFortranArrayParams(Context, arrays());
 1630     AssumptionContext = AssumptionContext.gist_params(DomainParameters);
 1633   AssumptionContext = AssumptionContext.gist_params(S.getContext());
 1666   AssumedContext = simplifyAssumptionContext(AssumedContext, *this);
 1667   InvalidContext = InvalidContext.align_params(getParamSpace());
 1963   PositiveContext = addNonEmptyDomainConstraints(PositiveContext);
 2051       Univ = isl::set::universe(Set.get_space());
 2108   Set = Set.gist_params(getContext());
 2114     AssumedContext = AssumedContext.intersect(Set).coalesce();
 2116     InvalidContext = InvalidContext.unite(Set).coalesce();

  890     AccDomain = AccDomain.intersect_params(Context);
 1355     ExecutionCtx = ExecutionCtx.intersect(BaseExecutionCtx);
 1372         ExecutionCtx = ExecutionCtx.intersect(BaseExecutionCtx);

  246     NewContext = NewContext.set_dim_id(isl::dim::param, i, Id);

  266   Set = isl::manage(isl_set_compute_divs(Set.copy()));
  267   Set = Set.detect_equalities();
  268   Set = Set.coalesce();
  759     Expanded = Expanded.unite(BSet);

   71   PWAC0.second = PWAC0.second.unite(PWAC1.second);
  101   PWAC.second =
  140   PWAC.second = PWAC.second.unite(NotEqualSet).coalesce();
  144     NotEqualSet = NotEqualSet.params();
  145   NotEqualSet = NotEqualSet.coalesce();
  284   OpPWAC.second = OpPWAC.second.unite(isl::manage_copy(OutOfBoundsDom));

   30   Set = Set.project_out(isl::dim::param, 0, ParamDims);
   31   Set = Set.project_out(isl::dim::set, 0, dim);
   33   Set = Set.project_out(isl::dim::set, 1, SetDims - 1);
   42   Set = Set.project_out(isl::dim::set, 0, dim);
   44   Set = Set.project_out(isl::dim::set, 1, SetDims - 1);
  241     ScatterSet = ScatterSet.subtract(ScatterFirst);
  269   SubExtent = SubExtent.project_out(isl::dim::param, 0, SubExtentDims);
  270   SubExtent = SubExtent.project_out(isl::dim::set, 1, SubDims - 1);

  121   Set = Set.project_out(isl::dim::param, 0, ParamDims);
  122   Set = Set.project_out(isl::dim::set, 0, dim);
  124   Set = Set.project_out(isl::dim::set, 1, SetDims - 1);

  317   IsolateOption = IsolateOption.set_tuple_id(Id);
  331   DimOption = DimOption.set_tuple_id(Id);
  363   Set = Set.add_constraint(ExtConstr);
  376   BadPrefixes = BadPrefixes.project_out(isl::dim::set, Dims - 1, 1);
  377   LoopPrefixes = LoopPrefixes.project_out(isl::dim::set, Dims - 1, 1);
 1204   Prefix = Prefix.project_out(isl::dim::set, Dims - 1, 1);
 1205   Prefix = getPartialTilePrefixes(Prefix, MicroKernelParams.Nr);
 1206   Prefix = getPartialTilePrefixes(Prefix, MicroKernelParams.Mr);

  239           Result = isl::set::universe(
  281           ValSet = makeValueSet(StoredVal);
  406           Result = isl::set::universe(
  413       Domain = Domain.intersect_params(S->getContext());

  384 	second = __p.second;
  397 	second = std::forward<second_type>(__p.second);