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

Declarations

  183 class map;

References

   40 struct DenseMapPair : public std::pair<KeyT, ValueT> {
   45   ValueT &getSecond() { return std::pair<KeyT, ValueT>::second; }
   46   const ValueT &getSecond() const { return std::pair<KeyT, ValueT>::second; }
   66   using mapped_type = ValueT;
   69   using iterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT>;
   71       DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT, true>;
  185   ValueT lookup(const_arg_type_t<KeyT> Val) const {
  195   std::pair<iterator, bool> insert(const std::pair<KeyT, ValueT> &KV) {
  202   std::pair<iterator, bool> insert(std::pair<KeyT, ValueT> &&KV) {
  249   std::pair<iterator, bool> insert_as(std::pair<KeyT, ValueT> &&KV,
  299   ValueT &operator[](const KeyT &Key) {
  311   ValueT &operator[](KeyT &&Key) {
  380         ::new (&DestBucket->getSecond()) ValueT(std::move(B->getSecond()));
  392       const DenseMapBase<OtherBaseT, KeyT, ValueT, KeyInfoT, BucketT> &other) {
  520     ::new (&TheBucket->getSecond()) ValueT(std::forward<ValueArgs>(Values)...);
  526                                       ValueT &&Value, LookupKeyT &Lookup) {
  684 class DenseMap : public DenseMapBase<DenseMap<KeyT, ValueT, KeyInfoT, BucketT>,
  685                                      KeyT, ValueT, KeyInfoT, BucketT> {
  690   using BaseT = DenseMapBase<DenseMap, KeyT, ValueT, KeyInfoT, BucketT>;
 1163   using ConstIterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, true>;
 1199       const DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, IsConstSrc> &I)

   68     : public std::iterator<IteratorCategoryT, T, DifferenceTypeT, PointerT,

   54   using StatementToIslMapTy = DenseMap<ScopStmt *, isl::map>;

  621   isl::map AccessRelation;
  624   isl::map NewAccessRelation;
  644   isl::map getOriginalAccessRelation() const;
  650   isl::map getNewAccessRelation() const;
  735   MemoryAccess(ScopStmt *Stmt, AccessType AccType, isl::map AccRel);
  799   isl::map getLatestAccessRelation() const {
  805   isl::map getAccessRelation() const { return getLatestAccessRelation(); }
  820   isl::map getAddressFunction() const;
  917   isl::set getStride(isl::map Schedule) const;
  926   bool isStrideX(isl::map Schedule, int StrideWidth) const;
  932   bool isStrideOne(isl::map Schedule) const;
  938   bool isStrideZero(isl::map Schedule) const;
 1056   void setAccessRelation(isl::map AccessRelation);
 1059   void setNewAccessRelation(isl::map NewAccessRelation);
 1179   ScopStmt(Scop &parent, isl::map SourceRel, isl::map TargetRel,
 1179   ScopStmt(Scop &parent, isl::map SourceRel, isl::map TargetRel,
 1310   isl::map getSchedule() const;
 2062   ScopStmt *addScopStmt(isl::map SourceRel, isl::map TargetRel,
 2062   ScopStmt *addScopStmt(isl::map SourceRel, isl::map TargetRel,

   30                                         list_element_type<ListT>> {
   30                                         list_element_type<ListT>> {
   32   using ElementT = list_element_type<ListT>;
   32   using ElementT = list_element_type<ListT>;
   83 isl::map beforeScatter(isl::map Map, bool Strict);
   83 isl::map beforeScatter(isl::map Map, bool Strict);
   97 isl::map afterScatter(isl::map Map, bool Strict);
   97 isl::map afterScatter(isl::map Map, bool Strict);
  128 isl::map betweenScatter(isl::map From, isl::map To, bool InclFrom, bool InclTo);
  128 isl::map betweenScatter(isl::map From, isl::map To, bool InclFrom, bool InclTo);
  128 isl::map betweenScatter(isl::map From, isl::map To, bool InclFrom, bool InclTo);
  143 isl::map singleton(isl::union_map UMap, isl::space ExpectedSpace);
  193 isl::map reverseDomain(isl::map Map);
  193 isl::map reverseDomain(isl::map Map);
  222 isl::map shiftDim(isl::map Map, isl::dim Dim, int Pos, int Amount);
  222 isl::map shiftDim(isl::map Map, isl::dim Dim, int Pos, int Amount);
  243 void simplify(isl::map &Map);
  425 isl::map convertZoneToTimepoints(isl::map Zone, isl::dim Dim, bool InclStart,
  425 isl::map convertZoneToTimepoints(isl::map Zone, isl::dim Dim, bool InclStart,
  433 isl::map distributeDomain(isl::map Map);
  433 isl::map distributeDomain(isl::map Map);
  464 isl::map intersectRange(isl::map Map, isl::union_set Range);
  464 isl::map intersectRange(isl::map Map, isl::union_set Range);
  479 isl::map subtractParams(isl::map Map, isl::set Params);
  479 isl::map subtractParams(isl::map Map, isl::set Params);
  538 void dumpPw(const isl::map &Map);
  584 void dumpExpanded(const isl::map &Map);

   60   llvm::DenseMap<ScopStmt *, isl::map> ScalarReachDefZone;
  157   llvm::DenseMap<std::pair<ScopStmt *, ScopStmt *>, isl::map> DefToTargetCache;
  193   isl::union_map getWrittenValue(MemoryAccess *MA, isl::map AccRel);
  204   isl::map computeUseToDefFlowDependency(ScopStmt *UseStmt, ScopStmt *DefStmt);
  228   isl::map getScatterFor(ScopStmt *Stmt) const;
  231   isl::map getScatterFor(MemoryAccess *MA) const;
  237   isl::map getScatterFor(isl::set Domain) const;
  248   isl::map getAccessRelationFor(MemoryAccess *MA) const;
  270   isl::map getDefToTarget(ScopStmt *DefStmt, ScopStmt *TargetStmt);
  280   isl::map getScalarReachingDefinition(ScopStmt *Stmt);
  288   isl::map getScalarReachingDefinition(isl::set DomainDef);
  295   isl::map makeUnknownForDomain(ScopStmt *Stmt) const;
  334   isl::map makeValInst(llvm::Value *Val, ScopStmt *UserStmt, llvm::Loop *Scope,
  372   isl::boolean isNormalized(isl::map Map);

  650     isl::map StmtScat;
  676   isl::map NonPositive = Deltas.lex_le_set(Zero);

  196 static isl::map createNextIterationMap(isl::space SetSpace, unsigned Dim) {
  198   isl::map NextIterationMap = isl::map::universe(MapSpace);
  198   isl::map NextIterationMap = isl::map::universe(MapSpace);
  732   isl::map NextIterationMap =
  775   isl::map ForwardMap = ForwardMap.lex_le(HeaderBBDom.get_space());
 2364     isl::map Transform = isl::map::universe(Array->getSpace().map_from_set());
 2364     isl::map Transform = isl::map::universe(Array->getSpace().map_from_set());
 2700     isl::map LoadAccs = CandidatePair.first->getAccessRelation();
 2701     isl::map StoreAccs = CandidatePair.second->getAccessRelation();
 2709     isl::map AllAccsRel = LoadAccs.unite(StoreAccs);
 2717       isl::map AccRel =
 2882   isl::map AccessRelation = Access->getAccessRelation();
 3167       isl::map Map = Access->getAccessRelation();

  458   isl::map Relation = AccessRelation;
  459   Relation = Relation.apply_range(isl::map::from_multi_aff(DivModAff));
  479   isl::map Map = isl::map::from_domain_and_range(
  479   isl::map Map = isl::map::from_domain_and_range(
  524     isl::map Map = isl::map::from_domain_and_range(
  524     isl::map Map = isl::map::from_domain_and_range(
  594 isl::map MemoryAccess::getAddressFunction() const {
  600   isl::map Schedule, ScheduledAccRel;
  605   Schedule = isl::map::from_union_map(USchedule);
  610 isl::map MemoryAccess::getOriginalAccessRelation() const {
  622 isl::map MemoryAccess::getNewAccessRelation() const {
  708   isl::map SubscriptMap = isl::map::from_pw_aff(SubscriptPWA);
  708   isl::map SubscriptMap = isl::map::from_pw_aff(SubscriptPWA);
  710   isl::map LengthMap;
  712     LengthMap = isl::map::universe(SubscriptMap.get_space());
  715     LengthMap = isl::map::from_pw_aff(LengthPWA);
  717     LengthMap = LengthMap.apply_range(isl::map::lex_gt(RangeSpace));
  765   isl::map Relation = AccessRelation;
  778   isl::map NewAccessRelation = AccessRelation;
  782     isl::map MapOne, MapTwo;
  794     MapOne = isl::map::universe(Space);
  799     MapTwo = isl::map::universe(Space);
  869   AccessRelation = isl::map::universe(Space);
  873     isl::map SubscriptMap = isl::map::from_pw_aff(Affine);
  873     isl::map SubscriptMap = isl::map::from_pw_aff(Affine);
  904 MemoryAccess::MemoryAccess(ScopStmt *Stmt, AccessType AccType, isl::map AccRel)
  999 static isl::map getEqualAndLarger(isl::space SetDomain) {
 1001   isl::map Map = isl::map::universe(Space);
 1001   isl::map Map = isl::map::universe(Space);
 1019 isl::set MemoryAccess::getStride(isl::map Schedule) const {
 1020   isl::map AccessRelation = getAccessRelation();
 1022   isl::map NextScatt = getEqualAndLarger(Space);
 1036 bool MemoryAccess::isStrideX(isl::map Schedule, int StrideWidth) const {
 1051 bool MemoryAccess::isStrideZero(isl::map Schedule) const {
 1055 bool MemoryAccess::isStrideOne(isl::map Schedule) const {
 1059 void MemoryAccess::setAccessRelation(isl::map NewAccess) {
 1063 void MemoryAccess::setNewAccessRelation(isl::map NewAccess) {
 1121 isl::map ScopStmt::getSchedule() const {
 1124     return isl::map::from_aff(isl::aff(isl::local_space(getDomainSpace())));
 1130     return isl::map::from_aff(isl::aff(isl::local_space(getDomainSpace())));
 1131   isl::map M = M.from_union_map(Schedule);
 1202 ScopStmt::ScopStmt(Scop &parent, isl::map SourceRel, isl::map TargetRel,
 1202 ScopStmt::ScopStmt(Scop &parent, isl::map SourceRel, isl::map TargetRel,
 2291       isl::map AccessDomain = MA->getAccessRelation();
 2406 ScopStmt *Scop::addScopStmt(isl::map SourceRel, isl::map TargetRel,
 2406 ScopStmt *Scop::addScopStmt(isl::map SourceRel, isl::map TargetRel,

  591   isl::map Schedule = isl::map::from_union_map(USchedule);
  591   isl::map Schedule = isl::map::from_union_map(USchedule);
  672   isl::map Schedule = isl::map::from_union_map(USchedule);
  672   isl::map Schedule = isl::map::from_union_map(USchedule);

  693   inline map lexmax() const;
  694   inline map lexmin() const;
  724   inline map unite(basic_map bmap2) const;
 1216 inline map manage(__isl_take isl_map *ptr);
 1217 inline map manage_copy(__isl_keep isl_map *ptr);
 1220   friend inline map manage(__isl_take isl_map *ptr);
 1221   friend inline map manage_copy(__isl_keep isl_map *ptr);
 1229   inline /* implicit */ map(const map &obj);
 1233   inline map &operator=(map obj);
 1233   inline map &operator=(map obj);
 1245   inline map add_constraint(constraint constraint) const;
 1246   inline map add_dims(isl::dim type, unsigned int n) const;
 1248   inline map align_params(space model) const;
 1249   inline map apply_domain(map map2) const;
 1249   inline map apply_domain(map map2) const;
 1250   inline map apply_range(map map2) const;
 1250   inline map apply_range(map map2) const;
 1255   inline map coalesce() const;
 1256   inline map complement() const;
 1258   inline map curry() const;
 1260   inline map deltas_map() const;
 1261   inline map detect_equalities() const;
 1266   inline map domain_factor_domain() const;
 1267   inline map domain_factor_range() const;
 1269   inline map domain_map() const;
 1270   inline map domain_product(map map2) const;
 1270   inline map domain_product(map map2) const;
 1271   inline map drop_constraints_involving_dims(isl::dim type, unsigned int first, unsigned int n) const;
 1272   inline map drop_constraints_not_involving_dims(isl::dim type, unsigned int first, unsigned int n) const;
 1273   inline map drop_unused_params() const;
 1274   inline map eliminate(isl::dim type, unsigned int first, unsigned int n) const;
 1275   static inline map empty(space space);
 1276   inline map equate(isl::dim type1, int pos1, isl::dim type2, int pos2) const;
 1277   inline map factor_domain() const;
 1278   inline map factor_range() const;
 1281   inline map fix_si(isl::dim type, unsigned int pos, int value) const;
 1282   inline map fix_val(isl::dim type, unsigned int pos, val v) const;
 1283   inline map fixed_power_val(val exp) const;
 1284   inline map flat_domain_product(map map2) const;
 1284   inline map flat_domain_product(map map2) const;
 1285   inline map flat_product(map map2) const;
 1285   inline map flat_product(map map2) const;
 1286   inline map flat_range_product(map map2) const;
 1286   inline map flat_range_product(map map2) const;
 1287   inline map flatten() const;
 1288   inline map flatten_domain() const;
 1289   inline map flatten_range() const;
 1290   inline map floordiv_val(val d) const;
 1292   static inline map from_aff(aff aff);
 1293   static inline map from_domain(set set);
 1294   static inline map from_domain_and_range(set domain, set range);
 1295   static inline map from_multi_aff(multi_aff maff);
 1296   static inline map from_multi_pw_aff(multi_pw_aff mpa);
 1297   static inline map from_pw_aff(pw_aff pwaff);
 1298   static inline map from_pw_multi_aff(pw_multi_aff pma);
 1299   static inline map from_range(set set);
 1300   static inline map from_union_map(union_map umap);
 1309   inline map gist(map context) const;
 1309   inline map gist(map context) const;
 1310   inline map gist_basic_map(basic_map context) const;
 1311   inline map gist_domain(set context) const;
 1312   inline map gist_params(set context) const;
 1313   inline map gist_range(set context) const;
 1316   inline boolean has_equal_space(const map &map2) const;
 1319   static inline map identity(space dim);
 1320   inline map insert_dims(isl::dim type, unsigned int pos, unsigned int n) const;
 1321   inline map intersect(map map2) const;
 1321   inline map intersect(map map2) const;
 1322   inline map intersect_domain(set set) const;
 1323   inline map intersect_domain_factor_range(map factor) const;
 1323   inline map intersect_domain_factor_range(map factor) const;
 1324   inline map intersect_params(set params) const;
 1325   inline map intersect_range(set set) const;
 1326   inline map intersect_range_factor_range(map factor) const;
 1326   inline map intersect_range_factor_range(map factor) const;
 1329   inline boolean is_disjoint(const map &map2) const;
 1331   inline boolean is_equal(const map &map2) const;
 1336   inline boolean is_strict_subset(const map &map2) const;
 1337   inline boolean is_subset(const map &map2) const;
 1339   static inline map lex_ge(space set_dim);
 1340   static inline map lex_ge_first(space dim, unsigned int n);
 1341   inline map lex_ge_map(map map2) const;
 1341   inline map lex_ge_map(map map2) const;
 1342   static inline map lex_gt(space set_dim);
 1343   static inline map lex_gt_first(space dim, unsigned int n);
 1344   inline map lex_gt_map(map map2) const;
 1344   inline map lex_gt_map(map map2) const;
 1345   static inline map lex_le(space set_dim);
 1346   static inline map lex_le_first(space dim, unsigned int n);
 1347   inline map lex_le_map(map map2) const;
 1347   inline map lex_le_map(map map2) const;
 1348   static inline map lex_lt(space set_dim);
 1349   static inline map lex_lt_first(space dim, unsigned int n);
 1350   inline map lex_lt_map(map map2) const;
 1350   inline map lex_lt_map(map map2) const;
 1351   inline map lexmax() const;
 1353   inline map lexmin() const;
 1355   inline map lower_bound_si(isl::dim type, unsigned int pos, int value) const;
 1356   inline map move_dims(isl::dim dst_type, unsigned int dst_pos, isl::dim src_type, unsigned int src_pos, unsigned int n) const;
 1358   static inline map nat_universe(space dim);
 1359   inline map neg() const;
 1360   inline map oppose(isl::dim type1, int pos1, isl::dim type2, int pos2) const;
 1361   inline map order_ge(isl::dim type1, int pos1, isl::dim type2, int pos2) const;
 1362   inline map order_gt(isl::dim type1, int pos1, isl::dim type2, int pos2) const;
 1363   inline map order_le(isl::dim type1, int pos1, isl::dim type2, int pos2) const;
 1364   inline map order_lt(isl::dim type1, int pos1, isl::dim type2, int pos2) const;
 1368   inline boolean plain_is_equal(const map &map2) const;
 1374   inline map preimage_domain_multi_aff(multi_aff ma) const;
 1375   inline map preimage_domain_multi_pw_aff(multi_pw_aff mpa) const;
 1376   inline map preimage_domain_pw_multi_aff(pw_multi_aff pma) const;
 1377   inline map preimage_range_multi_aff(multi_aff ma) const;
 1378   inline map preimage_range_pw_multi_aff(pw_multi_aff pma) const;
 1379   inline map product(map map2) const;
 1379   inline map product(map map2) const;
 1380   inline map project_out(isl::dim type, unsigned int first, unsigned int n) const;
 1382   inline map range_curry() const;
 1383   inline map range_factor_domain() const;
 1384   inline map range_factor_range() const;
 1386   inline map range_map() const;
 1387   inline map range_product(map map2) const;
 1387   inline map range_product(map map2) const;
 1388   inline map remove_dims(isl::dim type, unsigned int first, unsigned int n) const;
 1389   inline map remove_divs() const;
 1390   inline map remove_divs_involving_dims(isl::dim type, unsigned int first, unsigned int n) const;
 1391   inline map remove_redundancies() const;
 1392   inline map remove_unknown_divs() const;
 1393   inline map reset_tuple_id(isl::dim type) const;
 1394   inline map reset_user() const;
 1395   inline map reverse() const;
 1397   inline map set_dim_id(isl::dim type, unsigned int pos, id id) const;
 1398   inline map set_tuple_id(isl::dim type, id id) const;
 1399   inline map set_tuple_name(isl::dim type, const std::string &s) const;
 1401   inline map subtract(map map2) const;
 1401   inline map subtract(map map2) const;
 1402   inline map subtract_domain(set dom) const;
 1403   inline map subtract_range(set dom) const;
 1404   inline map sum(map map2) const;
 1404   inline map sum(map map2) const;
 1405   inline map uncurry() const;
 1406   inline map unite(map map2) const;
 1406   inline map unite(map map2) const;
 1407   static inline map universe(space space);
 1410   inline map upper_bound_si(isl::dim type, unsigned int pos, int value) const;
 1412   inline map zip() const;
 1442   inline map_list add(map el) const;
 1446   inline stat foreach(const std::function<stat(map)> &fn) const;
 1447   static inline map_list from_map(map el);
 1448   inline map get_at(int index) const;
 1449   inline map get_map(int index) const;
 1450   inline map_list insert(unsigned int pos, map el) const;
 1453   inline map_list set_map(int index, map el) const;
 1659   inline map eq_map(multi_pw_aff mpa2) const;
 1685   inline map lex_gt_map(multi_pw_aff mpa2) const;
 1686   inline map lex_lt_map(multi_pw_aff mpa2) const;
 1970   inline map eq_map(pw_aff pa2) const;
 1986   inline map gt_map(pw_aff pa2) const;
 1999   inline map lt_map(pw_aff pa2) const;
 2133   static inline pw_multi_aff from_map(map map);
 2658   inline set apply(map map) const;
 2687   inline map flatten_map() const;
 2711   inline map identity() const;
 2727   inline map lex_ge_set(set set2) const;
 2728   inline map lex_gt_set(set set2) const;
 2729   inline map lex_le_set(set set2) const;
 2730   inline map lex_lt_set(set set2) const;
 2757   inline map project_onto_map(isl::dim type, unsigned int first, unsigned int n) const;
 2782   inline map unwrap() const;
 2785   inline map wrapped_domain_map() const;
 3054   inline /* implicit */ union_map(map map);
 3068   inline union_map add_map(map map) const;
 3088   inline map extract_map(space dim) const;
 3095   inline stat foreach_map(const std::function<stat(map)> &fn) const;
 5841 map basic_map::lexmax() const
 5847 map basic_map::lexmin() const
 6027 map basic_map::unite(basic_map bmap2) const
 7948 map manage(__isl_take isl_map *ptr) {
 7951 map manage_copy(__isl_keep isl_map *ptr) {
 7959 map::map(const map &obj)
 7982 map &map::operator=(map obj) {
 7982 map &map::operator=(map obj) {
 8032 map map::add_constraint(constraint constraint) const
 8038 map map::add_dims(isl::dim type, unsigned int n) const
 8050 map map::align_params(space model) const
 8056 map map::apply_domain(map map2) const
 8056 map map::apply_domain(map map2) const
 8062 map map::apply_range(map map2) const
 8062 map map::apply_range(map map2) const
 8092 map map::coalesce() const
 8098 map map::complement() const
 8110 map map::curry() const
 8122 map map::deltas_map() const
 8128 map map::detect_equalities() const
 8158 map map::domain_factor_domain() const
 8164 map map::domain_factor_range() const
 8176 map map::domain_map() const
 8182 map map::domain_product(map map2) const
 8182 map map::domain_product(map map2) const
 8188 map map::drop_constraints_involving_dims(isl::dim type, unsigned int first, unsigned int n) const
 8194 map map::drop_constraints_not_involving_dims(isl::dim type, unsigned int first, unsigned int n) const
 8200 map map::drop_unused_params() const
 8206 map map::eliminate(isl::dim type, unsigned int first, unsigned int n) const
 8212 map map::empty(space space)
 8218 map map::equate(isl::dim type1, int pos1, isl::dim type2, int pos2) const
 8224 map map::factor_domain() const
 8230 map map::factor_range() const
 8248 map map::fix_si(isl::dim type, unsigned int pos, int value) const
 8254 map map::fix_val(isl::dim type, unsigned int pos, val v) const
 8260 map map::fixed_power_val(val exp) const
 8266 map map::flat_domain_product(map map2) const
 8266 map map::flat_domain_product(map map2) const
 8272 map map::flat_product(map map2) const
 8272 map map::flat_product(map map2) const
 8278 map map::flat_range_product(map map2) const
 8278 map map::flat_range_product(map map2) const
 8284 map map::flatten() const
 8290 map map::flatten_domain() const
 8296 map map::flatten_range() const
 8302 map map::floordiv_val(val d) const
 8322 map map::from_aff(aff aff)
 8328 map map::from_domain(set set)
 8334 map map::from_domain_and_range(set domain, set range)
 8340 map map::from_multi_aff(multi_aff maff)
 8346 map map::from_multi_pw_aff(multi_pw_aff mpa)
 8352 map map::from_pw_aff(pw_aff pwaff)
 8358 map map::from_pw_multi_aff(pw_multi_aff pma)
 8364 map map::from_range(set set)
 8370 map map::from_union_map(union_map umap)
 8426 map map::gist(map context) const
 8426 map map::gist(map context) const
 8432 map map::gist_basic_map(basic_map context) const
 8438 map map::gist_domain(set context) const
 8444 map map::gist_params(set context) const
 8450 map map::gist_range(set context) const
 8468 boolean map::has_equal_space(const map &map2) const
 8486 map map::identity(space dim)
 8492 map map::insert_dims(isl::dim type, unsigned int pos, unsigned int n) const
 8498 map map::intersect(map map2) const
 8498 map map::intersect(map map2) const
 8504 map map::intersect_domain(set set) const
 8510 map map::intersect_domain_factor_range(map factor) const
 8510 map map::intersect_domain_factor_range(map factor) const
 8516 map map::intersect_params(set params) const
 8522 map map::intersect_range(set set) const
 8528 map map::intersect_range_factor_range(map factor) const
 8528 map map::intersect_range_factor_range(map factor) const
 8546 boolean map::is_disjoint(const map &map2) const
 8558 boolean map::is_equal(const map &map2) const
 8588 boolean map::is_strict_subset(const map &map2) const
 8594 boolean map::is_subset(const map &map2) const
 8606 map map::lex_ge(space set_dim)
 8612 map map::lex_ge_first(space dim, unsigned int n)
 8618 map map::lex_ge_map(map map2) const
 8618 map map::lex_ge_map(map map2) const
 8624 map map::lex_gt(space set_dim)
 8630 map map::lex_gt_first(space dim, unsigned int n)
 8636 map map::lex_gt_map(map map2) const
 8636 map map::lex_gt_map(map map2) const
 8642 map map::lex_le(space set_dim)
 8648 map map::lex_le_first(space dim, unsigned int n)
 8654 map map::lex_le_map(map map2) const
 8654 map map::lex_le_map(map map2) const
 8660 map map::lex_lt(space set_dim)
 8666 map map::lex_lt_first(space dim, unsigned int n)
 8672 map map::lex_lt_map(map map2) const
 8672 map map::lex_lt_map(map map2) const
 8678 map map::lexmax() const
 8690 map map::lexmin() const
 8702 map map::lower_bound_si(isl::dim type, unsigned int pos, int value) const
 8708 map map::move_dims(isl::dim dst_type, unsigned int dst_pos, isl::dim src_type, unsigned int src_pos, unsigned int n) const
 8720 map map::nat_universe(space dim)
 8726 map map::neg() const
 8732 map map::oppose(isl::dim type1, int pos1, isl::dim type2, int pos2) const
 8738 map map::order_ge(isl::dim type1, int pos1, isl::dim type2, int pos2) const
 8744 map map::order_gt(isl::dim type1, int pos1, isl::dim type2, int pos2) const
 8750 map map::order_le(isl::dim type1, int pos1, isl::dim type2, int pos2) const
 8756 map map::order_lt(isl::dim type1, int pos1, isl::dim type2, int pos2) const
 8780 boolean map::plain_is_equal(const map &map2) const
 8816 map map::preimage_domain_multi_aff(multi_aff ma) const
 8822 map map::preimage_domain_multi_pw_aff(multi_pw_aff mpa) const
 8828 map map::preimage_domain_pw_multi_aff(pw_multi_aff pma) const
 8834 map map::preimage_range_multi_aff(multi_aff ma) const
 8840 map map::preimage_range_pw_multi_aff(pw_multi_aff pma) const
 8846 map map::product(map map2) const
 8846 map map::product(map map2) const
 8852 map map::project_out(isl::dim type, unsigned int first, unsigned int n) const
 8864 map map::range_curry() const
 8870 map map::range_factor_domain() const
 8876 map map::range_factor_range() const
 8888 map map::range_map() const
 8894 map map::range_product(map map2) const
 8894 map map::range_product(map map2) const
 8900 map map::remove_dims(isl::dim type, unsigned int first, unsigned int n) const
 8906 map map::remove_divs() const
 8912 map map::remove_divs_involving_dims(isl::dim type, unsigned int first, unsigned int n) const
 8918 map map::remove_redundancies() const
 8924 map map::remove_unknown_divs() const
 8930 map map::reset_tuple_id(isl::dim type) const
 8936 map map::reset_user() const
 8942 map map::reverse() const
 8954 map map::set_dim_id(isl::dim type, unsigned int pos, id id) const
 8960 map map::set_tuple_id(isl::dim type, id id) const
 8966 map map::set_tuple_name(isl::dim type, const std::string &s) const
 8978 map map::subtract(map map2) const
 8978 map map::subtract(map map2) const
 8984 map map::subtract_domain(set dom) const
 8990 map map::subtract_range(set dom) const
 8996 map map::sum(map map2) const
 8996 map map::sum(map map2) const
 9002 map map::uncurry() const
 9008 map map::unite(map map2) const
 9008 map map::unite(map map2) const
 9014 map map::universe(space space)
 9032 map map::upper_bound_si(isl::dim type, unsigned int pos, int value) const
 9044 map map::zip() const
 9116 map_list map_list::add(map el) const
 9140 stat map_list::foreach(const std::function<stat(map)> &fn) const
 9143     const std::function<stat(map)> *func;
 9154 map_list map_list::from_map(map el)
 9160 map map_list::get_at(int index) const
 9166 map map_list::get_map(int index) const
 9172 map_list map_list::insert(unsigned int pos, map el) const
 9190 map_list map_list::set_map(int index, map el) const
10103 map multi_pw_aff::eq_map(multi_pw_aff mpa2) const
10260 map multi_pw_aff::lex_gt_map(multi_pw_aff mpa2) const
10266 map multi_pw_aff::lex_lt_map(multi_pw_aff mpa2) const
11543 map pw_aff::eq_map(pw_aff pa2) const
11648 map pw_aff::gt_map(pw_aff pa2) const
11726 map pw_aff::lt_map(pw_aff pa2) const
12330 pw_multi_aff pw_multi_aff::from_map(map map)
14567 set set::apply(map map) const
14741 map set::flatten_map() const
14903 map set::identity() const
14999 map set::lex_ge_set(set set2) const
15005 map set::lex_gt_set(set set2) const
15011 map set::lex_le_set(set set2) const
15017 map set::lex_lt_set(set set2) const
15179 map set::project_onto_map(isl::dim type, unsigned int first, unsigned int n) const
15329 map set::unwrap() const
15347 map set::wrapped_domain_map() const
16357 union_map::union_map(map map)
16418 union_map union_map::add_map(map map) const
16538 map union_map::extract_map(space dim) const
16580 stat union_map::foreach_map(const std::function<stat(map)> &fn) const
16583     const std::function<stat(map)> *func;

   78 isl::map makeTupleSwapMap(isl::space FromSpace1, isl::space FromSpace2) {
   84 isl::map polly::beforeScatter(isl::map Map, bool Strict) {
   84 isl::map polly::beforeScatter(isl::map Map, bool Strict) {
   86   isl::map ScatterRel =
   87       Strict ? isl::map::lex_gt(RangeSpace) : isl::map::lex_ge(RangeSpace);
   87       Strict ? isl::map::lex_gt(RangeSpace) : isl::map::lex_ge(RangeSpace);
   94   for (isl::map Map : UMap.get_map_list()) {
   95     isl::map After = beforeScatter(Map, Strict);
  102 isl::map polly::afterScatter(isl::map Map, bool Strict) {
  102 isl::map polly::afterScatter(isl::map Map, bool Strict) {
  104   isl::map ScatterRel =
  105       Strict ? isl::map::lex_lt(RangeSpace) : isl::map::lex_le(RangeSpace);
  105       Strict ? isl::map::lex_lt(RangeSpace) : isl::map::lex_le(RangeSpace);
  111   for (isl::map Map : UMap.get_map_list()) {
  112     isl::map After = afterScatter(Map, Strict);
  118 isl::map polly::betweenScatter(isl::map From, isl::map To, bool InclFrom,
  118 isl::map polly::betweenScatter(isl::map From, isl::map To, bool InclFrom,
  118 isl::map polly::betweenScatter(isl::map From, isl::map To, bool InclFrom,
  120   isl::map AfterFrom = afterScatter(From, !InclFrom);
  121   isl::map BeforeTo = beforeScatter(To, !InclTo);
  134 isl::map polly::singleton(isl::union_map UMap, isl::space ExpectedSpace) {
  139     return isl::map::empty(ExpectedSpace);
  141   isl::map Result = isl::map::from_union_map(UMap);
  141   isl::map Result = isl::map::from_union_map(UMap);
  162   for (isl::map Map : Schedule.get_map_list())
  179     isl::map IdentityMap = isl::map::identity(Set.get_space().map_from_set());
  179     isl::map IdentityMap = isl::map::identity(Set.get_space().map_from_set());
  187 isl::map polly::reverseDomain(isl::map Map) {
  187 isl::map polly::reverseDomain(isl::map Map) {
  191   isl::map Swap = makeTupleSwapMap(Space1, Space2);
  197   for (isl::map Map : UMap.get_map_list()) {
  198     auto Reversed = reverseDomain(std::move(Map));
  212   isl::map TranslatorMap = isl::map::from_multi_aff(Translator);
  212   isl::map TranslatorMap = isl::map::from_multi_aff(Translator);
  225 isl::map polly::shiftDim(isl::map Map, isl::dim Dim, int Pos, int Amount) {
  225 isl::map polly::shiftDim(isl::map Map, isl::dim Dim, int Pos, int Amount) {
  243   isl::map TranslatorMap = isl::map::from_multi_aff(Translator);
  243   isl::map TranslatorMap = isl::map::from_multi_aff(Translator);
  258   for (isl::map Map : UMap.get_map_list()) {
  259     isl::map Shifted = shiftDim(Map, Dim, Pos, Amount);
  277 void polly::simplify(isl::map &Map) {
  297   isl::map Relation;
  299     Relation = InclPrevDef ? isl::map::lex_lt(ScatterSpace)
  300                            : isl::map::lex_le(ScatterSpace);
  302     Relation = InclNextDef ? isl::map::lex_gt(ScatterSpace)
  303                            : isl::map::lex_ge(ScatterSpace);
  306   isl::map RelationMap = Relation.range_map().reverse();
  416 isl::map polly::convertZoneToTimepoints(isl::map Zone, isl::dim Dim,
  416 isl::map polly::convertZoneToTimepoints(isl::map Zone, isl::dim Dim,
  421   auto ShiftedZone = shiftDim(Zone, Dim, -1, -1);
  431 isl::map polly::distributeDomain(isl::map Map) {
  431 isl::map polly::distributeDomain(isl::map Map) {
  472   for (isl::map Map : UMap.get_map_list()) {
  473     auto Distributed = distributeDomain(Map);
  505 isl::map polly::intersectRange(isl::map Map, isl::union_set Range) {
  505 isl::map polly::intersectRange(isl::map Map, isl::union_set Range) {
  510 isl::map polly::subtractParams(isl::map Map, isl::set Params) {
  510 isl::map polly::subtractParams(isl::map Map, isl::set Params) {
  512   auto ParamsMap = isl::map::universe(MapSpace).intersect_params(Params);
  512   auto ParamsMap = isl::map::universe(MapSpace).intersect_params(Params);
  811 LLVM_DUMP_METHOD void polly::dumpPw(const isl::map &Map) {
  843 LLVM_DUMP_METHOD void polly::dumpExpanded(const isl::map &Map) {

  120 isl::map computeScalarReachingOverwrite(isl::union_map Schedule,
  613   std::tuple<isl::union_map, isl::map>
  634     auto WriteScatter = getScatterFor(Writes);
  637     auto ReachDef = getScalarReachingDefinition(DefMA->getStatement());
  644     auto UseScatter =
  649     auto Lifetime = betweenScatter(WriteScatter, UseScatter, false, true);
  664   bool tryMapValue(const ScopArrayInfo *SAI, isl::map TargetElt) {
  678     auto DefSched = getScatterFor(DefMA);
  682     auto DefTarget = TargetElt.apply_domain(DefSched.reverse());
  696     isl::map Lifetime;
  711     isl::map ValInst;
  719     auto EltKnownTranslator = DefTarget.range_product(Lifetime);
  722     auto EltKnown = ValInst.apply_domain(EltKnownTranslator);
  726     auto WrittenTranslator = DefTarget.range_product(DefSched);
  729     auto DefEltSched = ValInst.apply_domain(WrittenTranslator);
  764   void mapValue(const ScopArrayInfo *SAI, isl::map DefTarget,
  765                 isl::union_map UseTarget, isl::map Lifetime,
  777       MA->setNewAccessRelation(isl::map::from_union_map(NewAccRel));
  788   isl::map makeValInst(Value *Val, ScopStmt *UserStmt, Loop *Scope,
  842   bool tryMapPHI(const ScopArrayInfo *SAI, isl::map TargetElt) {
  852     auto PHISched = getScatterFor(PHIRead);
  855     auto PHITarget = PHISched.apply_range(TargetElt);
  904     isl::map PerPHIWriteScatter =
  908     auto Lifetime = betweenScatter(PerPHIWriteScatter, PHISched, false, true);
  962   void mapPHI(const ScopArrayInfo *SAI, isl::map ReadTarget,
  963               isl::union_map WriteTarget, isl::map Lifetime,
  979       isl::map NewAccRelMap = singleton(NewAccRel, NewAccRelSpace);
 1012     auto TargetAccRel = getAccessRelationFor(TargetStoreMA);
 1016     auto Target =
 1021     auto EltTarget = Target.apply_range(TargetAccRel);
 1158     auto Map = getAccessRelationFor(MA);

   55 bool isVariableDim(const isl::map &Map) {
   65   for (isl::map Map : UMap.get_map_list())
  120   for (isl::map Map : UMap.get_map_list()) {
  121     auto Outprojected = Map.project_out(isl::dim::out, first, n);
  134   for (isl::map Map : Schedule.get_map_list())
  142   for (isl::map Map : UMap.get_map_list()) {
  144     isl::map SingleMap = Map.project_out(isl::dim::out, 0, pos);
  218     auto FirstSubScatterMap = isl::map::from_range(FirstSubScatter);
  218     auto FirstSubScatterMap = isl::map::from_range(FirstSubScatter);

   33   for (isl::map Map : Schedule.get_map_list())

  236   isl::map singleLocation(isl::union_map MustKnown, isl::set Domain) {
  238     isl::map Result;
  244     for (isl::map Map : MustKnown.get_map_list()) {
  347                                     isl::map AccessRelation) {
  440     isl::map ExpectedVal = makeValInst(Inst, UseStmt, UseLoop);
  445     isl::map UseToTarget = getDefToTarget(UseStmt, TargetStmt);
  448     isl::map TargetExpectedVal = ExpectedVal.apply_domain(UseToTarget);
  455     isl::map SameVal = singleLocation(Candidates, getDomainFor(TargetStmt));
  491         isl::map ValInsts = ExpectedVal.range().unwrap();
  500         isl::map ValToVal =
  501             isl::map::identity(ValSpace.map_from_domain_and_range(ValSpace));
  504         isl::map DefToTarget = getDefToTarget(DefStmt, TargetStmt);
  507         isl::map LocalTranslator = DefToTarget.reverse().product(ValToVal);
  569     isl::map UseToTarget = getDefToTarget(UseStmt, TargetStmt);
  579     isl::map SameVal = singleLocation(Candidates, getDomainFor(TargetStmt));
  696     isl::map DefToTarget;
  803     isl::map TargetToUse;
  807           isl::map::identity(DomSpace.map_from_domain_and_range(DomSpace));

  140   for (isl::map Map : Dependences.get_map_list()) {
  156     auto NewMap = Map.factor_domain();
  190       for (isl::map Map : MapDeps.get_map_list())
  320     auto CurrentAccessMap = MA->getAccessRelation();
  336     auto NewAccessMap = isl::map::from_union_map(MapDependences);
  336     auto NewAccessMap = isl::map::from_union_map(MapDependences);
  350   auto CurrentAccessMap = MA->getAccessRelation();
  358   auto NewAccessMap = isl::map::from_domain(Domain);
  358   auto NewAccessMap = isl::map::from_domain(Domain);

  312   isl::map IsolateRelation = isl::map::from_domain(IsolateDomain);
  312   isl::map IsolateRelation = isl::map::from_domain(IsolateDomain);
  342   isl::map UnrollIsolatedSetOption = isl::map::universe(Space);
  342   isl::map UnrollIsolatedSetOption = isl::map::universe(Space);
  387   isl::map ScheduleRelation = isl::map::from_union_map(SchedRelUMap);
  387   isl::map ScheduleRelation = isl::map::from_union_map(SchedRelUMap);
  557 isl::map permuteDimensions(isl::map Map, isl::dim DimType, unsigned DstPos,
  557 isl::map permuteDimensions(isl::map Map, isl::dim DimType, unsigned DstPos,
  594 static bool isMatMulOperandAcc(isl::set Domain, isl::map AccMap, int &FirstPos,
  597   isl::map Universe = isl::map::universe(Space);
  597   isl::map Universe = isl::map::universe(Space);
  612     auto PossibleMatMul =
  653   auto AccMap = MemAccess->getLatestAccessRelation();
  683 static bool containsOnlyMatrMultAcc(isl::map PartialSchedule,
  691   auto MapI =
  693   auto MapJ =
  695   auto MapK =
  724 static bool containsOnlyMatMulDep(isl::map Schedule, const Dependences *D,
  768 static bool containsMatrMult(isl::map PartialSchedule, const Dependences *D,
  782     auto AccMap = MemAccessPtr->getLatestAccessRelation();
 1043 isl::map getMatMulAccRel(isl::map MapOldIndVar, unsigned FirstDim,
 1043 isl::map getMatMulAccRel(isl::map MapOldIndVar, unsigned FirstDim,
 1046   auto AccessRel = isl::map::universe(AccessRelSpace);
 1046   auto AccessRel = isl::map::universe(AccessRelSpace);
 1054                                        isl::map ExtensionMap) {
 1093 optimizeDataLayoutMatrMulPattern(isl::schedule_node Node, isl::map MapOldIndVar,
 1104   auto AccRel = getMatMulAccRel(MapOldIndVar, 3, 7);
 1112   auto OldAcc = MMI.B->getLatestAccessRelation();
 1114   auto ExtMap = MapOldIndVar.project_out(isl::dim::out, 2,
 1170 isl::map
 1176   auto MapOldIndVar = isl::map::from_union_map(UnMapOldIndVar);
 1176   auto MapOldIndVar = isl::map::from_union_map(UnMapOldIndVar);
 1202   isl::set Prefix = isl::map::from_union_map(UnMapOldIndVar).range();
 1299   auto MapOldIndVar = getInductionVariablesSubstitution(Node, MicroKernelParams,
 1322   auto NewPartialSchedule = isl::map::from_union_map(PartialSchedule);
 1322   auto NewPartialSchedule = isl::map::from_union_map(PartialSchedule);

  353     for (isl::map Ext : NewChildExtensions.get_map_list()) {
  358       isl::map BandSched =
  364         isl::map OuterSched =

   86                                               isl::map Map) {
   90   isl::map PrevMap = UMap.extract_map(Map.get_space());
   98   isl::map Result = isl::map::empty(PrevMap.get_space());
   98   isl::map Result = isl::map::empty(PrevMap.get_space());
  111       UMap.subtract(isl::map::universe(PrevMap.get_space()));
  178         auto AccRel = MA->getAccessRelation();
  186           isl::map AccRelUniv = isl::map::universe(AccRel.get_space());
  186           isl::map AccRelUniv = isl::map::universe(AccRel.get_space());
  259         isl::map AccRel =
  294           isl::map UndefAnything =
  295               isl::map::from_domain_and_range(UndefDomain, ElementUniverse);
  299           isl::map AllowedAccesses = AccRel.unite(UndefAnything);
  303           isl::map Filter =
  304               isl::map::from_domain_and_range(AllowedAccesses.wrap(), ValSet);
  312           for (isl::map Map : Filtered.get_map_list()) {
  317             isl::map OtherAccRel =
  328             isl::map NewAccRel = AccRel.unite(OtherAccRel);
  352         for (isl::map Map :
  363         for (isl::map FutureWrite : FutureWrites.get_map_list()) {
  381           isl::map ValAccSet = isl::map::from_domain_and_range(ValSet, AccSet);
  381           isl::map ValAccSet = isl::map::from_domain_and_range(ValSet, AccSet);
  384           isl::map AccRelValAcc =
  385               isl::map::from_domain_and_range(AccRelWrapped, ValAccSet.wrap());
  431         isl::map AccRel = MA->getAccessRelation();
  447             isl::map AccRelStoredVal = isl::map::from_domain_and_range(
  447             isl::map AccRelStoredVal = isl::map::from_domain_and_range(
  468             isl::map AccRelVal = isl::map::from_domain_and_range(
  468             isl::map AccRelVal = isl::map::from_domain_and_range(
  509         isl::map AccRel = MA->getAccessRelation();

  214 static isl::map computeScalarReachingDefinition(isl::union_map Schedule,
  239 static isl::map makeUnknownForDomain(isl::set Domain) {
  240   return isl::map::from_domain(Domain);
  246 static bool isMapToUnknown(const isl::map &Map) {
  254   for (isl::map Map : UMap.get_map_list()) {
  333     isl::map AccRelMap = getAccessRelationFor(MA);
  396   auto AccRel = intersectRange(getAccessRelationFor(MA), CompatibleElts);
  401     isl::map LoadValInst = makeValInst(
  405     isl::map IncludeElement = AccRel.domain_map().curry();
  408     isl::map EltLoadValInst = LoadValInst.apply_domain(IncludeElement);
  415                                               isl::map AccRel) {
  452   isl::map AccRel = intersectRange(getAccessRelationFor(MA), CompatibleElts);
  466   isl::map IncludeElement = AccRel.domain_map().curry();
  482 isl::map ZoneAlgorithm::computeUseToDefFlowDependency(ScopStmt *UseStmt,
  485   isl::map UseScatter = getScatterFor(UseStmt);
  488   isl::map ReachDefZone = getScalarReachingDefinition(DefStmt);
  491   isl::map ReachDefTimepoints =
  551     isl::map Scatter = getScatterFor(MA);
  556   isl::map PHIReadScatter = getScatterFor(S->getPHIRead(SAI));
  559   isl::map BeforeRead = beforeScatter(PHIReadScatter, true);
  565   isl::map PHIWriteTimes = BeforeRead.intersect_range(WriteTimes);
  571   isl::map LastPerPHIWrites = PHIWriteTimes.lexmax();
  608 isl::map ZoneAlgorithm::getScatterFor(ScopStmt *Stmt) const {
  614 isl::map ZoneAlgorithm::getScatterFor(MemoryAccess *MA) const {
  622 isl::map ZoneAlgorithm::getScatterFor(isl::set Domain) const {
  626   auto Result = singleton(std::move(UResult), std::move(ResultSpace));
  639 isl::map ZoneAlgorithm::getAccessRelationFor(MemoryAccess *MA) const {
  641   auto AccRel = MA->getLatestAccessRelation();
  645 isl::map ZoneAlgorithm::getDefToTarget(ScopStmt *DefStmt,
  649     return isl::map::identity(
  652   isl::map &Result = DefToTargetCache[std::make_pair(TargetStmt, DefStmt)];
  684     Result = isl::map::from_domain_and_range(DefDomain, TargetDomain);
  699 isl::map ZoneAlgorithm::getScalarReachingDefinition(ScopStmt *Stmt) {
  700   auto &Result = ScalarReachDefZone[Stmt];
  711 isl::map ZoneAlgorithm::getScalarReachingDefinition(isl::set DomainDef) {
  715   auto StmtResult = getScalarReachingDefinition(Stmt);
  720 isl::map ZoneAlgorithm::makeUnknownForDomain(ScopStmt *Stmt) const {
  747 isl::map ZoneAlgorithm::makeValInst(Value *Val, ScopStmt *UserStmt, Loop *Scope,
  764     return isl::map::from_domain_and_range(DomainUse, ValSet);
  781     auto ValInst =
  782         isl::map::identity(UseDomainSpace.map_from_domain_and_range(ScevSpace));
  794     auto ValInstSet = isl::map::from_domain_and_range(DomainUse, ValSet);
  794     auto ValInstSet = isl::map::from_domain_and_range(DomainUse, ValSet);
  797     auto Result = ValInstSet.domain_map().reverse();
  815     auto UsedInstance = getDefToTarget(ValStmt, UserStmt).reverse();
  821     auto ValInstSet = isl::map::from_domain_and_range(DomainUse, ValSet);
  821     auto ValInstSet = isl::map::from_domain_and_range(DomainUse, ValSet);
  824     auto Result = UsedInstance.range_product(ValInstSet);
  844   for (isl::map Map : Input.get_map_list()) {
  876   isl::map ValInst = makeValInst(Val, UserStmt, Scope, IsCertain);
  919 isl::boolean ZoneAlgorithm::isNormalized(isl::map Map) {
  948   for (isl::map Map : UMap.get_map_list()) {
 1029       isl::map PHIValInst = makeValInst(PHI, &Stmt, Stmt.getSurroundingLoop());
 1045         isl::map IncomingValInst = makeValInst(

   53     for (isl::map Map : OccupiedAndKnown.get_map_list()) {

   62 static bool operator==(const isl::map &LHS, const isl::map &RHS) {
   62 static bool operator==(const isl::map &LHS, const isl::map &RHS) {
  395   isl::map TestMap = TestBMap;

   25     isl::map Schedule(
   37     isl::map Schedule(
   49     isl::map Schedule(

  474 	construct(allocator_type& __a, _Up* __p, _Args&&... __args)

   72     constexpr _Tp&&
   73     forward(typename std::remove_reference<_Tp>::type& __t) noexcept
   83     constexpr _Tp&&
   84     forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
   98     move(_Tp&& __t) noexcept

   62     : std::unary_function<_T1, _Res> { };
  299       _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
  302 	    std::forward<_ArgTypes>(__args)...);
  390     : public _Maybe_unary_or_binary_function<_Res, _ArgTypes...>,
  595       _Res operator()(_ArgTypes... __args) const;
  628       using _Invoker_type = _Res (*)(const _Any_data&, _ArgTypes&&...);
  689 	typedef _Function_handler<_Res(_ArgTypes...), _Functor> _My_handler;
  706       return _M_invoker(_M_functor, std::forward<_ArgTypes>(__args)...);

  108       typedef _Arg 	argument_type;   

  123       typedef _Tp        value_type;

  570 	_M_create_node(_Args&&... __args)
 1131 	emplace_back(_Args&&... __args)
 1799        _M_insert(iterator __position, _Args&&... __args)

  101 		      is_constructible<_T2, const _U2&>>::value;
  101 		      is_constructible<_T2, const _U2&>>::value;
  108 		      is_convertible<const _U2&, _T2>>::value;
  108 		      is_convertible<const _U2&, _T2>>::value;
  115 		      is_constructible<_T2, _U2&&>>::value;
  115 		      is_constructible<_T2, _U2&&>>::value;
  122 		      is_convertible<_U2&&, _T2>>::value;
  122 		      is_convertible<_U2&&, _T2>>::value;
  129 				  is_convertible<_U2&&, _T2>>;
  129 				  is_convertible<_U2&&, _T2>>;
  134 		      is_constructible<_T2, _U2&&>,
  134 		      is_constructible<_T2, _U2&&>,
  143 				  is_convertible<const _U2&, _T2>>;
  143 				  is_convertible<const _U2&, _T2>>;
  148 		      is_constructible<_T2, const _U2&&>,
  148 		      is_constructible<_T2, const _U2&&>,
  209     : private __pair_base<_T1, _T2>
  212       typedef _T2 second_type;   /// @c second_type is the second bound type
  215       _T2 second;                /// @c second is a copy of the second object
  252       using _PCCP = _PCC<true, _T1, _T2>;
  260       constexpr pair(const _T1& __a, const _T2& __b)
  269       explicit constexpr pair(const _T1& __a, const _T2& __b)
  283 			    _T1, _T2>;
  311        constexpr pair(_U1&& __x, const _T2& __y)
  318        explicit constexpr pair(_U1&& __x, const _T2& __y)
  325        constexpr pair(const _T1& __x, _U2&& __y)
  341 	constexpr pair(_U1&& __x, _U2&& __y)
  380 		       is_copy_assignable<_T2>>::value,
  391 		       is_move_assignable<_T2>>::value,
  403 				is_assignable<_T2&, const _U2&>>::value,
  403 				is_assignable<_T2&, const _U2&>>::value,
  405 	operator=(const pair<_U1, _U2>& __p)
  414 				is_assignable<_T2&, _U2&&>>::value,
  414 				is_assignable<_T2&, _U2&&>>::value,
  416 	operator=(pair<_U1, _U2>&& __p)
  524     make_pair(_T1&& __x, _T2&& __y)

  135 	construct(_Up* __p, _Args&&... __args)

   56     struct __is_empty_non_tuple : is_empty<_Tp> { };
  125       constexpr _Head_base(const _Head& __h)
  132         constexpr _Head_base(_UHead&& __h)
  133 	: _M_head_impl(std::forward<_UHead>(__h)) { }
  159       static constexpr _Head&
  162       static constexpr const _Head&
  165       _Head _M_head_impl;
  186     : public _Tuple_impl<_Idx + 1, _Tail...>,
  191       typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
  210       constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail)
  216         constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
  217 	: _Inherited(std::forward<_UTail>(__tail)...),
  230         constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
  235         constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
  242 	_Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
  248 		    const _Head& __head, const _Tail&... __tail)
  323 	    (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_head(__in));
  325 	    (_Tuple_impl<_Idx, _UHead, _UTails...>::_M_tail(__in));
  344     : private _Head_base<_Idx, _Head>
  348       typedef _Head_base<_Idx, _Head> _Base;
  350       static constexpr _Head&
  353       static constexpr const _Head&
  360       constexpr _Tuple_impl(const _Head& __head)
  365         constexpr _Tuple_impl(_UHead&& __head)
  366 	: _Base(std::forward<_UHead>(__head)) { }
  373       : _Base(std::forward<_Head>(_M_head(__in))) { }
  376         constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UHead>& __in)
  380         constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead>&& __in)
  390 		    const _Head& __head)
  451 	    = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in));
  451 	    = std::forward<_UHead>(_Tuple_impl<_Idx, _UHead>::_M_head(__in));
  473       return __and_<is_constructible<_Elements, const _UElements&>...>::value;
  473       return __and_<is_constructible<_Elements, const _UElements&>...>::value;
  479       return __and_<is_convertible<const _UElements&, _Elements>...>::value;
  479       return __and_<is_convertible<const _UElements&, _Elements>...>::value;
  485       return __and_<is_constructible<_Elements, _UElements&&>...>::value;
  485       return __and_<is_constructible<_Elements, _UElements&&>...>::value;
  491       return __and_<is_convertible<_UElements&&, _Elements>...>::value;
  491       return __and_<is_convertible<_UElements&&, _Elements>...>::value;
  907     class tuple<_T1, _T2> : public _Tuple_impl<0, _T1, _T2>
  909       typedef _Tuple_impl<0, _T1, _T2> _Inherited;
  939         _TC<is_same<_Dummy, void>::value, _T1, _T2>;
  947         constexpr tuple(const _T1& __a1, const _T2& __a2)
  956         explicit constexpr tuple(const _T1& __a1, const _T2& __a2)
  961       using _TMC = _TC<true, _T1, _T2>;
  971         constexpr tuple(_U1&& __a1, _U2&& __a2)
  995         constexpr tuple(const tuple<_U1, _U2>& __in)
 1013         constexpr tuple(tuple<_U1, _U2>&& __in)
 1031         constexpr tuple(const pair<_U1, _U2>& __in)
 1049         constexpr tuple(pair<_U1, _U2>&& __in)
 1051 		     std::forward<_U2>(__in.second)) { }
 1066 	tuple(allocator_arg_t __tag, const _Alloc& __a)
 1078 	      const _T1& __a1, const _T2& __a2)
 1090 	      const _T1& __a1, const _T2& __a2)
 1225         operator=(const tuple<_U1, _U2>& __in)
 1233         operator=(tuple<_U1, _U2>&& __in)
 1588     constexpr tuple<_Elements&...>
 1589     tie(_Elements&... __args) noexcept

  215     : public __is_void_helper<typename remove_cv<_Tp>::type>::type
  326     : public __is_integral_helper<typename remove_cv<_Tp>::type>::type
  354     : public __is_floating_point_helper<typename remove_cv<_Tp>::type>::type
  381     : public __is_pointer_helper<typename remove_cv<_Tp>::type>::type
  567     : public __is_null_pointer_helper<typename remove_cv<_Tp>::type>::type
  581     : public __or_<is_lvalue_reference<_Tp>,
  582                    is_rvalue_reference<_Tp>>::type
  588     : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
  588     : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
  601     : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
  601     : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
  602                           is_void<_Tp>>>::type
  611     : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
  611     : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
  611     : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
  612                    is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
  612                    is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
  631     : public __is_member_pointer_helper<typename remove_cv<_Tp>::type>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
  762     typename add_rvalue_reference<_Tp>::type declval() noexcept;
  777     : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
  777     : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
  798       typedef decltype(__test<_Tp>(0)) type;
  811                remove_all_extents<_Tp>::type>::type
  825     : public __is_destructible_safe<_Tp>::type
  889       typedef decltype(__test<_Tp>(0)) type;
  894     : public __and_<__not_<is_void<_Tp>>,
  895                     __is_default_constructible_impl<_Tp>>
  915     : public __is_default_constructible_atom<_Tp>::type
  921     : public __is_default_constructible_safe<_Tp>::type
  984       typedef decltype(__test<_Tp, _Arg>(0)) type;
  989     : public __and_<is_destructible<_Tp>,
  990                     __is_direct_constructible_impl<_Tp, _Arg>>
 1072 			 __is_direct_constructible_ref_cast<_Tp, _Arg>,
 1073 			 __is_direct_constructible_new_safe<_Tp, _Arg>
 1079     : public __is_direct_constructible_new<_Tp, _Arg>::type
 1119     : public __is_direct_constructible<_Tp, _Arg>
 1130     : public __is_constructible_impl<_Tp, _Args...>::type
 1215     : public __and_<is_constructible<_Tp, _Args...>,
 1216 		    __is_nt_constructible_impl<_Tp, _Args...>>
 1246     : public is_nothrow_constructible<_Tp, _Tp&&>
 1246     : public is_nothrow_constructible<_Tp, _Tp&&>
 1252     : public __is_nothrow_move_constructible_impl<_Tp>
 1286     : public is_assignable<_Tp&, const _Tp&>
 1286     : public is_assignable<_Tp&, const _Tp&>
 1292     : public __is_copy_assignable_impl<_Tp>
 1304     : public is_assignable<_Tp&, _Tp&&>
 1304     : public is_assignable<_Tp&, _Tp&&>
 1310     : public __is_move_assignable_impl<_Tp>
 1377     static void __helper(const _Tp&);
 1380     static true_type __test(const _Tp&,
 1381                             decltype(__helper<const _Tp&>({}))* = 0);
 1390     typedef decltype(__test(declval<_Tp>())) type;
 1395       : public __is_implicitly_default_constructible_impl<_Tp>::type
 1400       : public __and_<is_default_constructible<_Tp>,
 1401                       __is_implicitly_default_constructible_safe<_Tp>>
 1526 	static void __test_aux(_To1);
 1538       typedef decltype(__test<_From, _To>(0)) type;
 1545     : public __is_convertible_helper<_From, _To>::type
 1554     { typedef _Tp     type; };
 1563     { typedef _Tp     type; };
 1574       remove_const<typename remove_volatile<_Tp>::type>::type     type;
 1629     { typedef _Tp   type; };
 1633     { typedef _Tp   type; };
 1659     { typedef _Tp&&   type; };
 1664     : public __add_rvalue_reference_helper<_Tp>
 1955     { typedef _Tp     type; };
 2104     { typedef typename remove_cv<_Up>::type __type; };
 2131       typedef _Tp __type;
 2253     inline typename add_rvalue_reference<_Tp>::type
 2428       std::declval<_Fn>()(std::declval<_Args>()...)
 2439       typedef decltype(_S_test<_Functor, _ArgTypes...>(0)) type;
 2452 	_Functor, _ArgTypes...
 2458     : public __invoke_result<_Functor, _ArgTypes...>

  140   static void PrintValue(const T& value, ::std::ostream* os) {
  205     ::std::basic_ostream<Char, CharTraits>& os, const T& x) {
  206   TypeWithoutFormatter<T,
  207       (internal::IsAProtocolMessage<T>::value ? kProtobuf :
  208        internal::ImplicitlyConvertible<const T&, internal::BiggestInt>::value ?
  223 void DefaultPrintNonContainerTo(const T& value, ::std::ostream* os) {
  276   static ::std::string Format(const ToPrint& value) {
  351     const T1& value, const T2& /* other_operand */) {
  351     const T1& value, const T2& /* other_operand */) {
  352   return FormatForComparison<T1, T2>::Format(value);
  352   return FormatForComparison<T1, T2>::Format(value);
  366 void UniversalPrint(const T& value, ::std::ostream* os);
  373                     const C& container, ::std::ostream* os) {
  439                     const T& value, ::std::ostream* os) {
  455 void PrintTo(const T& value, ::std::ostream* os) {
  478   DefaultPrintTo(IsContainerTest<T>(0), is_pointer<T>(), value, os);
  699   static void Print(const T& value, ::std::ostream* os) {
  784   static void Print(const T& value, ::std::ostream* os) {
  856   typedef T T1;
  983   internal::UniversalTersePrinter<T>::Print(value, &ss);

 1377                                    const T1& lhs, const T2& rhs) {
 1377                                    const T1& lhs, const T2& rhs) {
 1389                             const T1& lhs,
 1390                             const T2& rhs) {
 1419                                  const T1& lhs,
 1420                                  const T2& rhs) {

   29   static const T& printable(const T& V) { return V; }
   29   static const T& printable(const T& V) { return V; }
   35 auto printable(const T &V) -> decltype(StreamSwitch<T>::printable(V)) {
   35 auto printable(const T &V) -> decltype(StreamSwitch<T>::printable(V)) {
   37   return StreamSwitch<T>::printable(V);

   94 ::std::string PrintToString(const T& value);