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

References

include/llvm/ADT/DenseMap.h
   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) {
  338         P->getSecond().~ValueT();
  380         ::new (&DestBucket->getSecond()) ValueT(std::move(B->getSecond()));
  384         B->getSecond().~ValueT();
  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)
include/llvm/CodeGen/GlobalISel/LegalizerInfo.h
   95 raw_ostream &operator<<(raw_ostream &OS, LegalizeActions::LegalizeAction Action);
  148   LegalizeAction Action;
  154   LegalizeActionStep(LegalizeAction Action, unsigned TypeIdx,
  294   LegalizeAction Action;
  298   LegalizeRule(LegalityPredicate Predicate, LegalizeAction Action,
  307   LegalizeAction getAction() const { return Action; }
  375   LegalizeRuleSet &actionIf(LegalizeAction Action,
  382   LegalizeRuleSet &actionIf(LegalizeAction Action, LegalityPredicate Predicate,
  389   LegalizeRuleSet &actionFor(LegalizeAction Action,
  396   LegalizeRuleSet &actionFor(LegalizeAction Action,
  405   LegalizeRuleSet &actionFor(LegalizeAction Action,
  413   LegalizeRuleSet &actionFor(LegalizeAction Action,
  423   LegalizeRuleSet &actionForTypeWithAnyImm(LegalizeAction Action,
  432   LegalizeRuleSet &actionForCartesianProduct(LegalizeAction Action,
  443   actionForCartesianProduct(LegalizeAction Action,
  455       LegalizeAction Action, std::initializer_list<LLT> Types0,
  481     return actionIf(LegalizeAction::Legal, Predicate);
  485     return actionFor(LegalizeAction::Legal, Types);
  490     return actionFor(LegalizeAction::Legal, Types);
  496     return actionForTypeWithAnyImm(LegalizeAction::Legal, Types);
  503     return actionIf(LegalizeAction::Legal,
  510     return actionForCartesianProduct(LegalizeAction::Legal, Types);
  516     return actionForCartesianProduct(LegalizeAction::Legal, Types0, Types1);
  523     return actionForCartesianProduct(LegalizeAction::Legal, Types0, Types1,
  530     return actionIf(LegalizeAction::Legal, always);
  539     return actionIf(LegalizeAction::Lower, always);
  548     return actionIf(LegalizeAction::Lower, Predicate);
  556     return actionIf(LegalizeAction::Lower, Predicate, Mutation);
  561     return actionFor(LegalizeAction::Lower, Types,
  568     return actionFor(LegalizeAction::Lower, Types, Mutation);
  573     return actionFor(LegalizeAction::Lower, Types,
  580     return actionFor(LegalizeAction::Lower, Types, Mutation);
  587     return actionForCartesianProduct(LegalizeAction::Lower, Types0, Types1);
  595     return actionForCartesianProduct(LegalizeAction::Lower, Types0, Types1,
  604     return actionIf(LegalizeAction::Libcall, Predicate);
  607     return actionFor(LegalizeAction::Libcall, Types);
  611     return actionFor(LegalizeAction::Libcall, Types);
  615     return actionForCartesianProduct(LegalizeAction::Libcall, Types);
  620     return actionForCartesianProduct(LegalizeAction::Libcall, Types0, Types1);
  630     return actionIf(LegalizeAction::WidenScalar, Predicate, Mutation);
  639     return actionIf(LegalizeAction::NarrowScalar, Predicate, Mutation);
  649     return actionIf(LegalizeAction::MoreElements, Predicate, Mutation);
  658     return actionIf(LegalizeAction::FewerElements, Predicate, Mutation);
  663     return actionIf(LegalizeAction::Unsupported, always);
  666     return actionIf(LegalizeAction::Unsupported, Predicate);
  669     return actionIf(LegalizeAction::Unsupported,
  673     return actionIf(LegalizeAction::Lower,
  681     return actionIf(LegalizeAction::Custom, Predicate);
  684     return actionFor(LegalizeAction::Custom, Types);
  690     return actionFor(LegalizeAction::Custom, Types);
  694     return actionForCartesianProduct(LegalizeAction::Custom, Types);
  699     return actionForCartesianProduct(LegalizeAction::Custom, Types0, Types1);
  713         LegalizeAction::WidenScalar, sizeNotPow2(typeIdx(TypeIdx)),
  723         LegalizeAction::WidenScalar, scalarOrEltSizeNotPow2(typeIdx(TypeIdx)),
  729     return actionIf(LegalizeAction::NarrowScalar, isScalar(typeIdx(TypeIdx)),
  735     return actionIf(LegalizeAction::FewerElements, isVector(typeIdx(TypeIdx)),
  743     return actionIf(LegalizeAction::WidenScalar,
  753     return actionIf(LegalizeAction::WidenScalar,
  763     return actionIf(LegalizeAction::WidenScalar,
  772     return actionIf(LegalizeAction::NarrowScalar,
  781     return actionIf(LegalizeAction::NarrowScalar,
  794         LegalizeAction::NarrowScalar,
  850     return actionIf(LegalizeAction::MoreElements,
  861         LegalizeAction::MoreElements,
  879         LegalizeAction::FewerElements,
  910     add({always, LegalizeAction::UseLegacyRules});
  944   static bool needsLegalizingToDifferentSize(const LegalizeAction Action) {
  958   using SizeAndAction = std::pair<uint16_t, LegalizeAction>;
  967   void setAction(const InstrAspect &Aspect, LegalizeAction Action) {
 1094                                             LegalizeAction IncreaseAction,
 1095                                             LegalizeAction DecreaseAction);
 1099                                               LegalizeAction DecreaseAction,
 1100                                               LegalizeAction IncreaseAction);
 1144     return getAction(Query).Action == LegalizeAction::Legal;
 1166   std::pair<LegalizeAction, LLT>
 1317   std::pair<LegalizeAction, LLT>
 1321   std::pair<LegalizeAction, LLT>
 1328   using TypeMap = DenseMap<LLT, LegalizeAction>;
lib/CodeGen/GlobalISel/LegalizerHelper.cpp
 3679     auto QAction = LI.getAction(Q).Action;
lib/CodeGen/GlobalISel/LegalizerInfo.cpp
   45 raw_ostream &llvm::operator<<(raw_ostream &OS, LegalizeAction Action) {
  185     return {LegalizeAction::UseLegacyRules, 0, LLT{}};
  201   return {LegalizeAction::Unsupported, 0, LLT{}};
  301         const LegalizeAction Action = LLT2Action.second;
  378 std::pair<LegalizeAction, LLT>
  458   if (Step.Action != LegalizeAction::UseLegacyRules) {
  514   auto Action = getAction(MI, MRI).Action;
  528     const SizeAndActionsVec &v, LegalizeAction IncreaseAction,
  529     LegalizeAction DecreaseAction) {
  548     const SizeAndActionsVec &v, LegalizeAction DecreaseAction,
  549     LegalizeAction IncreaseAction) {
  573   LegalizeAction Action = Vec[VecIdx].second;
  618 std::pair<LegalizeAction, LLT>
  647 std::pair<LegalizeAction, LLT>
unittests/CodeGen/GlobalISel/LegalizerInfoTest.cpp
   20 operator<<(std::ostream &OS, const LegalizeAction Act) {
usr/include/c++/7.4.0/bits/move.h
   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
  198       _Tp __tmp = _GLIBCXX_MOVE(__a);
usr/include/c++/7.4.0/bits/stl_pair.h
  100 	return __and_<is_constructible<_T1, const _U1&>,
  100 	return __and_<is_constructible<_T1, const _U1&>,
  101 		      is_constructible<_T2, const _U2&>>::value;
  101 		      is_constructible<_T2, const _U2&>>::value;
  107 	return __and_<is_convertible<const _U1&, _T1>,
  107 	return __and_<is_convertible<const _U1&, _T1>,
  108 		      is_convertible<const _U2&, _T2>>::value;
  108 		      is_convertible<const _U2&, _T2>>::value;
  114 	return __and_<is_constructible<_T1, _U1&&>,
  114 	return __and_<is_constructible<_T1, _U1&&>,
  115 		      is_constructible<_T2, _U2&&>>::value;
  115 		      is_constructible<_T2, _U2&&>>::value;
  121 	return __and_<is_convertible<_U1&&, _T1>,
  121 	return __and_<is_convertible<_U1&&, _T1>,
  122 		      is_convertible<_U2&&, _T2>>::value;
  122 		      is_convertible<_U2&&, _T2>>::value;
  128 	using __do_converts = __and_<is_convertible<const _U1&, _T1>,
  128 	using __do_converts = __and_<is_convertible<const _U1&, _T1>,
  129 				  is_convertible<_U2&&, _T2>>;
  129 				  is_convertible<_U2&&, _T2>>;
  133 	return __and_<is_constructible<_T1, const _U1&>,
  133 	return __and_<is_constructible<_T1, const _U1&>,
  134 		      is_constructible<_T2, _U2&&>,
  134 		      is_constructible<_T2, _U2&&>,
  142 	using __do_converts = __and_<is_convertible<_U1&&, _T1>,
  142 	using __do_converts = __and_<is_convertible<_U1&&, _T1>,
  143 				  is_convertible<const _U2&, _T2>>;
  143 				  is_convertible<const _U2&, _T2>>;
  147 	return __and_<is_constructible<_T1, _U1&&>,
  147 	return __and_<is_constructible<_T1, _U1&&>,
  148 		      is_constructible<_T2, const _U2&&>,
  148 		      is_constructible<_T2, const _U2&&>,
  209     : private __pair_base<_T1, _T2>
  209     : private __pair_base<_T1, _T2>
  211       typedef _T1 first_type;    /// @c first_type is the first bound type
  212       typedef _T2 second_type;   /// @c second_type is the second bound type
  214       _T1 first;                 /// @c first is a copy of the first object
  215       _T2 second;                /// @c second is a copy of the second object
  252       using _PCCP = _PCC<true, _T1, _T2>;
  252       using _PCCP = _PCC<true, _T1, _T2>;
  260       constexpr pair(const _T1& __a, const _T2& __b)
  260       constexpr pair(const _T1& __a, const _T2& __b)
  269       explicit constexpr pair(const _T1& __a, const _T2& __b)
  269       explicit constexpr pair(const _T1& __a, const _T2& __b)
  283 			    _T1, _T2>;
  283 			    _T1, _T2>;
  291         constexpr pair(const pair<_U1, _U2>& __p)
  311        constexpr pair(_U1&& __x, const _T2& __y)
  311        constexpr pair(_U1&& __x, const _T2& __y)
  312        : first(std::forward<_U1>(__x)), second(__y) { }
  318        explicit constexpr pair(_U1&& __x, const _T2& __y)
  325        constexpr pair(const _T1& __x, _U2&& __y)
  325        constexpr pair(const _T1& __x, _U2&& __y)
  326        : first(__x), second(std::forward<_U2>(__y)) { }
  332        explicit pair(const _T1& __x, _U2&& __y)
  341 	constexpr pair(_U1&& __x, _U2&& __y)
  341 	constexpr pair(_U1&& __x, _U2&& __y)
  342 	: first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
  342 	: first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
  360 	constexpr pair(pair<_U1, _U2>&& __p)
  379 		__and_<is_copy_assignable<_T1>,
  380 		       is_copy_assignable<_T2>>::value,
  390 		__and_<is_move_assignable<_T1>,
  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)
  448     operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
  448     operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
  454     operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
  454     operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y)
  495     swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
  495     swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
  524     make_pair(_T1&& __x, _T2&& __y)
usr/include/c++/7.4.0/tuple
  125       constexpr _Head_base(const _Head& __h)
  132         constexpr _Head_base(_UHead&& __h)
  159       static constexpr _Head&
  162       static constexpr const _Head&
  194       static constexpr _Head&
  197       static constexpr const _Head&
  210       constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail)
  216         constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
  248 		    const _Head& __head, const _Tail&... __tail)
  473       return __and_<is_constructible<_Elements, const _UElements&>...>::value;
  479       return __and_<is_convertible<const _UElements&, _Elements>...>::value;
  485       return __and_<is_constructible<_Elements, _UElements&&>...>::value;
  491       return __and_<is_convertible<_UElements&&, _Elements>...>::value;
  608         constexpr tuple(const _Elements&... __elements)
  619       explicit constexpr tuple(const _Elements&... __elements)
  646         constexpr tuple(_UElements&&... __elements)
  730 	      const _Elements&... __elements)
  741                        const _Elements&... __elements)
 1302     constexpr _Head&
 1307     constexpr const _Head&
 1313     constexpr __tuple_element_t<__i, tuple<_Elements...>>&
 1319     constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
 1325     constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
usr/include/c++/7.4.0/type_traits
  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
  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
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
  777     : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
  777     : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
  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
 1160     : public is_constructible<_Tp, _Tp&&>
 1160     : public is_constructible<_Tp, _Tp&&>
 1166     : public __is_move_constructible_impl<_Tp>
 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>
 1352     : public is_nothrow_assignable<_Tp&, _Tp&&>
 1352     : public is_nothrow_assignable<_Tp&, _Tp&&>
 1358     : public __is_nt_move_assignable_impl<_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; };
 1558     { 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; };
 2131       typedef _Tp __type;
 2574       typename remove_reference<_Tp>::type>::type>::type
 2579     typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>,
 2580 			      is_move_constructible<_Tp>,
 2581 			      is_move_assignable<_Tp>>::value>::type
 2582     swap(_Tp&, _Tp&)
 2582     swap(_Tp&, _Tp&)
 2609           noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))
 2609           noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))
 2629       typedef decltype(__test<_Tp>(0)) type;
 2639     : public __is_nothrow_swappable_impl<_Tp>::type