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

References

gen/lib/Target/AArch64/AArch64GenDAGISel.inc
115660   AArch64CC::CondCode CC = static_cast<AArch64CC::CondCode>(N->getZExtValue());
include/llvm/ADT/Optional.h
  144     T value;
  172   T &getValue() LLVM_LVALUE_FUNCTION noexcept {
  176   T const &getValue() const LLVM_LVALUE_FUNCTION noexcept {
  181   T &&getValue() && noexcept {
  206       ::new ((void *)std::addressof(value)) T(std::move(y));
  216   optional_detail::OptionalStorage<T> Storage;
  219   using value_type = T;
  224   Optional(const T &y) : Storage(optional_detail::in_place_t{}, y) {}
  227   Optional(T &&y) : Storage(optional_detail::in_place_t{}, std::move(y)) {}
  230   Optional &operator=(T &&y) {
  241   static inline Optional create(const T *y) {
  245   Optional &operator=(const T &y) {
  253   const T *getPointer() const { return &Storage.getValue(); }
  254   T *getPointer() { return &Storage.getValue(); }
  255   const T &getValue() const LLVM_LVALUE_FUNCTION { return Storage.getValue(); }
  256   T &getValue() LLVM_LVALUE_FUNCTION { return Storage.getValue(); }
  260   const T *operator->() const { return getPointer(); }
  261   T *operator->() { return getPointer(); }
  262   const T &operator*() const LLVM_LVALUE_FUNCTION { return getValue(); }
  263   T &operator*() LLVM_LVALUE_FUNCTION { return getValue(); }
  266   constexpr T getValueOr(U &&value) const LLVM_LVALUE_FUNCTION {
  271   T &&getValue() && { return std::move(Storage.getValue()); }
  272   T &&operator*() && { return std::move(Storage.getValue()); }
  275   T getValueOr(U &&value) && {
include/llvm/ADT/StringSwitch.h
   48   Optional<T> Result;
   67   StringSwitch &Case(StringLiteral S, T Value) {
   74   StringSwitch& EndsWith(StringLiteral S, T Value) {
   81   StringSwitch& StartsWith(StringLiteral S, T Value) {
   88   StringSwitch &Cases(StringLiteral S0, StringLiteral S1, T Value) {
   93                       T Value) {
   98                       StringLiteral S3, T Value) {
  103                       StringLiteral S3, StringLiteral S4, T Value) {
  109                       T Value) {
  115                       StringLiteral S6, T Value) {
  121                       StringLiteral S6, StringLiteral S7, T Value) {
  128                       T Value) {
  135                       StringLiteral S9, T Value) {
  140   StringSwitch &CaseLower(StringLiteral S, T Value) {
  147   StringSwitch &EndsWithLower(StringLiteral S, T Value) {
  154   StringSwitch &StartsWithLower(StringLiteral S, T Value) {
  161   StringSwitch &CasesLower(StringLiteral S0, StringLiteral S1, T Value) {
  166                            T Value) {
  171                            StringLiteral S3, T Value) {
  176                            StringLiteral S3, StringLiteral S4, T Value) {
  181   R Default(T Value) {
  181   R Default(T Value) {
  188   operator R() {
include/llvm/Support/type_traits.h
   91     T t;
  122     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
  122     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
  122     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
  130     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
  130     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
  130     static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
  145       std::is_copy_constructible<detail::trivial_helper<T>>::value;
  147       !std::is_copy_constructible<T>::value;
  151       std::is_move_constructible<detail::trivial_helper<T>>::value;
  153       !std::is_move_constructible<T>::value;
  157       is_copy_assignable<detail::trivial_helper<T>>::value;
  159       !is_copy_assignable<T>::value;
  163       is_move_assignable<detail::trivial_helper<T>>::value;
  165       !is_move_assignable<T>::value;
  169       std::is_destructible<detail::trivial_helper<T>>::value;
lib/Target/AArch64/AArch64CondBrTuning.cpp
  114   AArch64CC::CondCode CC;
lib/Target/AArch64/AArch64ConditionOptimizer.cpp
  101   using CmpInfo = std::tuple<int, unsigned, AArch64CC::CondCode>;
  111   CmpInfo adjustCmp(MachineInstr *CmpMI, AArch64CC::CondCode Cmp);
  113   bool adjustTo(MachineInstr *CmpMI, AArch64CC::CondCode Cmp, MachineInstr *To,
  228 static AArch64CC::CondCode getAdjustedCmp(AArch64CC::CondCode Cmp) {
  228 static AArch64CC::CondCode getAdjustedCmp(AArch64CC::CondCode Cmp) {
  242     MachineInstr *CmpMI, AArch64CC::CondCode Cmp) {
  273   AArch64CC::CondCode Cmp;
  304 static bool parseCond(ArrayRef<MachineOperand> Cond, AArch64CC::CondCode &CC) {
  318   AArch64CC::CondCode Cmp, MachineInstr *To, int ToImm)
  375     AArch64CC::CondCode HeadCmp;
  380     AArch64CC::CondCode TrueCmp;
lib/Target/AArch64/AArch64ConditionalCompares.cpp
  163   AArch64CC::CondCode HeadCmpBBCC;
  169   AArch64CC::CondCode CmpBBTailCC;
  272 static bool parseCond(ArrayRef<MachineOperand> Cond, AArch64CC::CondCode &CC) {
lib/Target/AArch64/AArch64FastISel.cpp
  194   bool foldXALUIntrinsic(AArch64CC::CondCode &CC, const Instruction *I,
 2246 static AArch64CC::CondCode getCompareCC(CmpInst::Predicate Pred) {
 2462       AArch64CC::CondCode CC = getCompareCC(Predicate);
 2463       AArch64CC::CondCode ExtraCC = AArch64CC::AL;
 2508     AArch64CC::CondCode CC = AArch64CC::NE;
 2639   AArch64CC::CondCode CC = getCompareCC(Predicate);
 2641   AArch64CC::CondCode invertedCC = getInvertedCondCode(CC);
 2743   AArch64CC::CondCode CC = AArch64CC::NE;
 2744   AArch64CC::CondCode ExtraCC = AArch64CC::AL;
 3381 bool AArch64FastISel::foldXALUIntrinsic(AArch64CC::CondCode &CC,
 3427   AArch64CC::CondCode TmpCC;
 3724     AArch64CC::CondCode CC = AArch64CC::Invalid;
lib/Target/AArch64/AArch64ISelLowering.cpp
 1428 static AArch64CC::CondCode changeIntCCToAArch64CC(ISD::CondCode CC) {
 1457                                   AArch64CC::CondCode &CondCode,
 1458                                   AArch64CC::CondCode &CondCode2) {
 1520                                      AArch64CC::CondCode &CondCode,
 1521                                      AArch64CC::CondCode &CondCode2) {
 1550                                         AArch64CC::CondCode &CondCode,
 1551                                         AArch64CC::CondCode &CondCode2,
 1702                                          AArch64CC::CondCode Predicate,
 1703                                          AArch64CC::CondCode OutCC,
 1728   AArch64CC::CondCode InvOutCC = AArch64CC::getInvertedCondCode(OutCC);
 1811     AArch64CC::CondCode &OutCC, bool Negate, SDValue CCOp,
 1812     AArch64CC::CondCode Predicate) {
 1828       AArch64CC::CondCode ExtraCC;
 1908   AArch64CC::CondCode RHSCC;
 1923                                AArch64CC::CondCode &OutCC) {
 2049   AArch64CC::CondCode AArch64CC;
 2102 getAArch64XALUOOp(AArch64CC::CondCode &CC, SDValue Op, SelectionDAG &DAG) {
 2251     AArch64CC::CondCode CC;
 2354   AArch64CC::CondCode CC;
 4714     AArch64CC::CondCode OFCC;
 4797   AArch64CC::CondCode CC1, CC2;
 4990   AArch64CC::CondCode CC1, CC2;
 5134       AArch64CC::CondCode AArch64CC = changeIntCCToAArch64CC(CC);
 5145       AArch64CC::CondCode AArch64CC = changeIntCCToAArch64CC(CC);
 5168   AArch64CC::CondCode CC1, CC2;
 5229     AArch64CC::CondCode OFCC;
 8051                                     AArch64CC::CondCode CC, bool NoNans, EVT VT,
 8155     AArch64CC::CondCode AArch64CC = changeIntCCToAArch64CC(CC);
 8182   AArch64CC::CondCode CC1, CC2;
10167   AArch64CC::CondCode CC;
lib/Target/AArch64/AArch64InstrInfo.cpp
  299     AArch64CC::CondCode CC = (AArch64CC::CondCode)(int)Cond[0].getImm();
  546   AArch64CC::CondCode CC;
 1304 static AArch64CC::CondCode findCondCodeUsedByInstr(const MachineInstr &Instr) {
 1332 static UsedNZCV getUsedNZCV(AArch64CC::CondCode CC) {
 1423       AArch64CC::CondCode CC = findCondCodeUsedByInstr(Instr);
 4864     AArch64CC::CondCode CC = (AArch64CC::CondCode)DefMI->getOperand(3).getImm();
lib/Target/AArch64/AArch64InstructionSelector.cpp
  871 static AArch64CC::CondCode changeICMPPredToAArch64CC(CmpInst::Predicate P) {
  899                                       AArch64CC::CondCode &CondCode,
  900                                       AArch64CC::CondCode &CondCode2) {
  976     const AArch64CC::CondCode CC = changeICMPPredToAArch64CC(
 2223     AArch64CC::CondCode CC1, CC2;
 3368   const AArch64CC::CondCode InvCC = changeICMPPredToAArch64CC(
 3429   AArch64CC::CondCode CondCode;
 3440     AArch64CC::CondCode CondCode2;
 3519   const AArch64CC::CondCode CC = changeICMPPredToAArch64CC(P);
lib/Target/AArch64/AArch64RedundantCopyElimination.cpp
  145   AArch64CC::CondCode CC = (AArch64CC::CondCode)CondBr.getOperand(0).getImm();
lib/Target/AArch64/AArch64SpeculationHardening.cpp
  154                                AArch64CC::CondCode &CondCode) const;
  156                           AArch64CC::CondCode &CondCode, DebugLoc DL) const;
  188     AArch64CC::CondCode &CondCode) const {
  226     MachineBasicBlock &SplitEdgeBB, AArch64CC::CondCode &CondCode,
  247   AArch64CC::CondCode CondCode;
  256     AArch64CC::CondCode InvCondCode = AArch64CC::getInvertedCondCode(CondCode);
lib/Target/AArch64/AsmParser/AArch64AsmParser.cpp
  154   AArch64CC::CondCode parseCondCodeString(StringRef Cond);
  358     AArch64CC::CondCode Code;
  514   AArch64CC::CondCode getCondCode() const {
 1892   CreateCondCode(AArch64CC::CondCode Code, SMLoc S, SMLoc E, MCContext &Ctx) {
 2665 AArch64CC::CondCode AArch64AsmParser::parseCondCodeString(StringRef Cond) {
 2666   AArch64CC::CondCode CC = StringSwitch<AArch64CC::CondCode>(Cond.lower())
 2714   AArch64CC::CondCode CC = parseCondCodeString(Cond);
 3797     AArch64CC::CondCode CC = parseCondCodeString(Head);
lib/Target/AArch64/MCTargetDesc/AArch64InstPrinter.cpp
 1053   AArch64CC::CondCode CC = (AArch64CC::CondCode)MI->getOperand(OpNum).getImm();
 1060   AArch64CC::CondCode CC = (AArch64CC::CondCode)MI->getOperand(OpNum).getImm();
lib/Target/AArch64/Utils/AArch64BaseInfo.h
  256 inline static const char *getCondCodeName(CondCode Code) {
  278 inline static CondCode getInvertedCondCode(CondCode Code) {
  278 inline static CondCode getInvertedCondCode(CondCode Code) {
  288 inline static unsigned getNZCVToSatisfyCondCode(CondCode Code) {
usr/include/c++/7.4.0/bits/move.h
   46     inline _GLIBCXX_CONSTEXPR _Tp*
   47     __addressof(_Tp& __r) _GLIBCXX_NOEXCEPT
   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
  136     inline _GLIBCXX17_CONSTEXPR _Tp*
  137     addressof(_Tp& __r) noexcept
  143     const _Tp* addressof(const _Tp&&) = delete;
  143     const _Tp* addressof(const _Tp&&) = delete;
usr/include/c++/7.4.0/tuple
   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)
  313 	  _M_head(*this) = _Tuple_impl<_Idx, _UElements...>::_M_head(__in);
  314 	  _M_tail(*this) = _Tuple_impl<_Idx, _UElements...>::_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)
  442 	  _M_head(*this) = _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;
  508       return  __not_<is_same<tuple<_Elements...>,
  510 			       typename remove_reference<_UElements...>::type
  556     class tuple : public _Tuple_impl<0, _Elements...>
  558       typedef _Tuple_impl<0, _Elements...> _Inherited;
  598             _Elements...>;
  608         constexpr tuple(const _Elements&... __elements)
  619       explicit constexpr tuple(const _Elements&... __elements)
  628                       _Elements...>;
  636                       _Elements...>;
  646         constexpr tuple(_UElements&&... __elements)
  647         : _Inherited(std::forward<_UElements>(__elements)...) { }
  668             _Elements...>;
  730 	      const _Elements&... __elements)
  741                        const _Elements&... __elements)
  853         operator=(const tuple<_UElements...>& __in)
  863         operator=(tuple<_UElements...>&& __in)
 1280     : tuple_element<__i - 1, tuple<_Tail...> > { };
 1303     __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
 1304     { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
 1308     __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
 1313     constexpr __tuple_element_t<__i, tuple<_Elements...>>&
 1314     get(tuple<_Elements...>& __t) noexcept
 1319     constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
 1320     get(const tuple<_Elements...>& __t) noexcept
 1325     constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
 1326     get(tuple<_Elements...>&& __t) noexcept
 1588     constexpr tuple<_Elements&...>
 1589     tie(_Elements&... __args) noexcept
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
  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
 1142     : public is_constructible<_Tp, const _Tp&>
 1142     : public is_constructible<_Tp, const _Tp&>
 1148     : public __is_copy_constructible_impl<_Tp>
 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>
 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; };