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

References

  108   Ret (*callback)(intptr_t callable, Params ...params) = nullptr;
  112   static Ret callback_fn(intptr_t callable, Params ...params) {
  114         std::forward<Params>(params)...);
  129   Ret operator()(Params ...params) const {
  130     return callback(callable, std::forward<Params>(params)...);

  138   SmallVector<T, N> Vector;
  139   std::set<T, C> Set;
  141   using VIterator = typename SmallVector<T, N>::const_iterator;
  142   using mutable_iterator = typename SmallVector<T, N>::iterator;
  151   using const_iterator = SmallSetIterator<T, N, C>;
  164   size_type count(const T &V) const {
  180   std::pair<NoneType, bool> insert(const T &V) {
  207   bool erase(const T &V) {
  238   VIterator vfind(const T &V) const {

   75   AlignedCharArrayUnion<T> FirstEl;
  114   using value_type = T;
  115   using iterator = T *;
  116   using const_iterator = const T *;
  121   using reference = T &;
  122   using const_reference = const T &;
  123   using pointer = T *;
  124   using const_pointer = const T *;
  259 class SmallVectorTemplateBase<T, true> : public SmallVectorTemplateCommon<T> {
  264   static void destroy_range(T *, T *) {}
  264   static void destroy_range(T *, T *) {}
  299   void grow(size_t MinSize = 0) { this->grow_pod(MinSize, sizeof(T)); }
  302   void push_back(const T &Elt) {
  305     memcpy(reinterpret_cast<void *>(this->end()), &Elt, sizeof(T));
  315 class SmallVectorImpl : public SmallVectorTemplateBase<T> {
  316   using SuperClass = SmallVectorTemplateBase<T>;
  357   void resize(size_type N, const T &NV) {
  374   LLVM_NODISCARD T pop_back_val() {
  397   void append(size_type NumInputs, const T &Elt) {
  405   void append(std::initializer_list<T> IL) {
  412   void assign(size_type NumElts, const T &Elt) {
  429   void assign(std::initializer_list<T> IL) {
  467   iterator insert(iterator I, T &&Elt) {
  497   iterator insert(iterator I, const T &Elt) {
  526   iterator insert(iterator I, size_type NumToInsert, const T &Elt) {
  637   void insert(iterator I, std::initializer_list<T> IL) {
  820   AlignedCharArrayUnion<T> InlineElts[N];
  837 class SmallVector : public SmallVectorImpl<T>, SmallVectorStorage<T, N> {
  837 class SmallVector : public SmallVectorImpl<T>, SmallVectorStorage<T, N> {
  846   explicit SmallVector(size_t Size, const T &Value = T())
  865   SmallVector(std::initializer_list<T> IL) : SmallVectorImpl<T>(N) {
  884   SmallVector(SmallVectorImpl<T> &&RHS) : SmallVectorImpl<T>(N) {

  297 inline std::error_code make_error_code(instrprof_error E) {
  303   InstrProfError(instrprof_error Err) : Err(Err) {
  315   instrprof_error get() const { return Err; }
  319   static instrprof_error take(Error E) {
  320     auto Err = instrprof_error::success;
  320     auto Err = instrprof_error::success;
  331   instrprof_error Err;
  339   instrprof_error FirstError = instrprof_error::success;
  339   instrprof_error FirstError = instrprof_error::success;
  362   void addError(instrprof_error IE);
  381     if (FirstError == instrprof_error::success)
  384     FirstError = instrprof_error::success;
  469       return make_error<InstrProfError>(instrprof_error::malformed);
  675              function_ref<void(instrprof_error)> Warn);
  677   void scale(uint64_t Weight, function_ref<void(instrprof_error)> Warn);
  748              function_ref<void(instrprof_error)> Warn);
  752   void scale(uint64_t Weight, function_ref<void(instrprof_error)> Warn);
  835                           function_ref<void(instrprof_error)> Warn);
  839                           function_ref<void(instrprof_error)> Warn);

   62   instrprof_error LastError = instrprof_error::success;
   62   instrprof_error LastError = instrprof_error::success;
  101   Error error(instrprof_error Err) {
  103     if (Err == instrprof_error::success)
  111   Error success() { return error(instrprof_error::success); }
  115   bool isEOF() { return LastError == instrprof_error::eof; }
  118   bool hasError() { return LastError != instrprof_error::success && !isEOF(); }

   90       return make_error<InstrProfError>(instrprof_error::unsupported_version);

   30   T t;
   39 template <typename T> union SizerImpl<T> { char arr[sizeof(T)]; };
   50       llvm::detail::SizerImpl<T, Ts...>)];

  330 template <typename ErrT, typename... ArgTs> Error make_error(ArgTs &&... Args) {
  331   return Error(std::make_unique<ErrT>(std::forward<ArgTs>(Args)...));

   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;

  223     instrprof_error IPE = InstrProfError::take(std::move(E));
  224     if (IPE == instrprof_error::hash_mismatch) {
  227     } else if (IPE != instrprof_error::unknown_function)

  436         return make_error<InstrProfError>(instrprof_error::malformed);

   76 static std::string getInstrProfErrString(instrprof_error Err) {
   78   case instrprof_error::success:
   80   case instrprof_error::eof:
   82   case instrprof_error::unrecognized_format:
   84   case instrprof_error::bad_magic:
   86   case instrprof_error::bad_header:
   88   case instrprof_error::unsupported_version:
   90   case instrprof_error::unsupported_hash_type:
   92   case instrprof_error::too_large:
   94   case instrprof_error::truncated:
   96   case instrprof_error::malformed:
   98   case instrprof_error::unknown_function:
  100   case instrprof_error::hash_mismatch:
  102   case instrprof_error::count_mismatch:
  104   case instrprof_error::counter_overflow:
  106   case instrprof_error::value_site_count_mismatch:
  108   case instrprof_error::compress_failed:
  110   case instrprof_error::uncompress_failed:
  112   case instrprof_error::empty_raw_profile:
  114   case instrprof_error::zlib_unavailable:
  184 void SoftInstrProfErrors::addError(instrprof_error IE) {
  185   if (IE == instrprof_error::success)
  188   if (FirstError == instrprof_error::success)
  192   case instrprof_error::hash_mismatch:
  195   case instrprof_error::count_mismatch:
  198   case instrprof_error::counter_overflow:
  201   case instrprof_error::value_site_count_mismatch:
  412     return make_error<InstrProfError>(instrprof_error::compress_failed);
  450         return make_error<InstrProfError>(instrprof_error::zlib_unavailable);
  458         return make_error<InstrProfError>(instrprof_error::uncompress_failed);
  603                                      function_ref<void(instrprof_error)> Warn) {
  616         Warn(instrprof_error::counter_overflow);
  625                                      function_ref<void(instrprof_error)> Warn) {
  630       Warn(instrprof_error::counter_overflow);
  638     function_ref<void(instrprof_error)> Warn) {
  642     Warn(instrprof_error::value_site_count_mismatch);
  656                             function_ref<void(instrprof_error)> Warn) {
  660     Warn(instrprof_error::count_mismatch);
  669       Warn(instrprof_error::counter_overflow);
  678     function_ref<void(instrprof_error)> Warn) {
  684                             function_ref<void(instrprof_error)> Warn) {
  689       Warn(instrprof_error::counter_overflow);
  857     return make_error<InstrProfError>(instrprof_error::malformed);
  860     return make_error<InstrProfError>(instrprof_error::malformed);
  865       return make_error<InstrProfError>(instrprof_error::malformed);
  868       return make_error<InstrProfError>(instrprof_error::malformed);
  880     return make_error<InstrProfError>(instrprof_error::truncated);
  885     return make_error<InstrProfError>(instrprof_error::too_large);

   66     return make_error<InstrProfError>(instrprof_error::too_large);
   69     return make_error<InstrProfError>(instrprof_error::empty_raw_profile);
   82     return make_error<InstrProfError>(instrprof_error::unrecognized_format);
  117     return make_error<InstrProfError>(instrprof_error::too_large);
  121     return make_error<InstrProfError>(instrprof_error::bad_magic);
  169     return error(instrprof_error::bad_header);
  200     return error(instrprof_error::malformed);
  206       return error(instrprof_error::malformed);
  252     return error(instrprof_error::eof);
  262     return error(instrprof_error::truncated);
  264     return error(instrprof_error::malformed);
  269     return error(instrprof_error::truncated);
  271     return error(instrprof_error::malformed);
  273     return error(instrprof_error::malformed);
  280       return error(instrprof_error::truncated);
  283       return error(instrprof_error::malformed);
  307     return error(instrprof_error::bad_magic);
  309     return error(instrprof_error::bad_header);
  324     return make_error<InstrProfError>(instrprof_error::eof);
  328     return make_error<InstrProfError>(instrprof_error::malformed);
  331     return make_error<InstrProfError>(instrprof_error::malformed);
  335     return make_error<InstrProfError>(instrprof_error::bad_magic);
  360     return error(instrprof_error::unsupported_version);
  379     return error(instrprof_error::bad_header);
  414     return error(instrprof_error::malformed);
  422     return error(instrprof_error::malformed);
  426     return error(instrprof_error::malformed);
  579     return make_error<InstrProfError>(instrprof_error::unknown_function);
  583     return make_error<InstrProfError>(instrprof_error::malformed);
  592     return make_error<InstrProfError>(instrprof_error::eof);
  597     return make_error<InstrProfError>(instrprof_error::malformed);
  703                     return Err->get() == instrprof_error::unknown_function
  804     return error(instrprof_error::truncated);
  812     return error(instrprof_error::bad_magic);
  818     return error(instrprof_error::unsupported_version);
  830     return error(instrprof_error::unsupported_hash_type);
  881   return error(instrprof_error::hash_mismatch);

 1146       auto Err = IPE.get();
 1150       if (Err == instrprof_error::unknown_function) {
 1154       } else if (Err == instrprof_error::hash_mismatch ||
 1155                  Err == instrprof_error::malformed) {

  972     auto IPE = llvm::InstrProfError::take(std::move(E));
  973     if (IPE == llvm::instrprof_error::unknown_function)
  975     else if (IPE == llvm::instrprof_error::hash_mismatch)
  977     else if (IPE == llvm::instrprof_error::malformed)

   70       instrprof_error instrError = IPE.get();
   72       if (instrError == instrprof_error::unrecognized_format) {
  108   auto IPE = instrprof_error::success;
  108   auto IPE = instrprof_error::success;
  118     if (IPE != instrprof_error::success) {
  120       case instrprof_error::hash_mismatch:
  121       case instrprof_error::count_mismatch:
  122       case instrprof_error::value_site_count_mismatch:
  189   SmallSet<instrprof_error, 4> &WriterErrorCodes;
  192                 SmallSet<instrprof_error, 4> &WriterErrorCodes)
  207     instrprof_error IPE = InstrProfError::take(std::move(E));
  208     if (IPE != instrprof_error::empty_raw_profile)
  236     instrprof_error IPE = InstrProfError::take(std::move(E));
  237     if (IPE != instrprof_error::empty_raw_profile)
  266       instrprof_error IPE = InstrProfError::take(std::move(E));
  285     instrprof_error IPE = InstrProfError::take(std::move(E));
  306   SmallSet<instrprof_error, 4> WriterErrorCodes;
  701   SmallSet<instrprof_error, 4> WriterErrorCodes;

   24 ErrorEquals(instrprof_error Expected, Error E) {
   25   instrprof_error Found;
  571   instrprof_error Result;
  573   Result = instrprof_error::success;
  578   Result = instrprof_error::success;
  582   Result = instrprof_error::success;
  590   Result = instrprof_error::success;
  599   Result = instrprof_error::success;

  387       using allocator_type = allocator<_Tp>;
  389       using value_type = _Tp;
  392       using pointer = _Tp*;
  395       using const_pointer = const _Tp*;
  474 	construct(allocator_type& __a, _Up* __p, _Args&&... __args)
  474 	construct(allocator_type& __a, _Up* __p, _Args&&... __args)
  486 	destroy(allocator_type& __a, _Up* __p)

   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

  108       typedef _Arg 	argument_type;   
  111       typedef _Result 	result_type;  
  121       typedef _Arg1 	first_argument_type; 
  124       typedef _Arg2 	second_argument_type;
  381     struct less : public binary_function<_Tp, _Tp, bool>
  381     struct less : public binary_function<_Tp, _Tp, bool>
  385       operator()(const _Tp& __x, const _Tp& __y) const
  385       operator()(const _Tp& __x, const _Tp& __y) const
  870     : public unary_function<_Tp,_Tp>
  870     : public unary_function<_Tp,_Tp>
  872       _Tp&
  873       operator()(_Tp& __x) const
  876       const _Tp&
  877       operator()(const _Tp& __x) const

  110       typedef _Key     key_type;
  111       typedef _Key     value_type;
  119 	rebind<_Key>::other _Key_alloc_type;

  218       typedef _Rb_tree_node<_Val>* _Link_type;
  231       __gnu_cxx::__aligned_membuf<_Val> _M_storage;
  233       _Val*
  237       const _Val*
  258       typedef _Tp  value_type;
  259       typedef _Tp& reference;
  260       typedef _Tp* pointer;
  265       typedef _Rb_tree_iterator<_Tp>        _Self;
  267       typedef _Rb_tree_node<_Tp>*           _Link_type;
  328       typedef _Tp        value_type;
  329       typedef const _Tp& reference;
  330       typedef const _Tp* pointer;
  332       typedef _Rb_tree_iterator<_Tp> iterator;
  337       typedef _Rb_tree_const_iterator<_Tp>        _Self;
  339       typedef const _Rb_tree_node<_Tp>*           _Link_type;
  447         rebind<_Rb_tree_node<_Val> >::other _Node_allocator;
  454       typedef _Rb_tree_node<_Val>* 		_Link_type;
  455       typedef const _Rb_tree_node<_Val>*	_Const_Link_type;
  554 	  operator()(_Arg&& __arg) const
  563       typedef _Key 				key_type;
  564       typedef _Val 				value_type;
  621 	_M_construct_node(_Link_type __node, _Args&&... __args)
  625 	      ::new(__node) _Rb_tree_node<_Val>;
  640         _M_create_node(_Args&&... __args)
  758       static const _Key&
  782       static const _Key&
  834 	_M_insert_(_Base_ptr __x, _Base_ptr __y, _Arg&& __v, _NodeGen&);
  894 		     const _Key& __k);
  898 		     const _Key& __k) const;
  902 		     const _Key& __k);
  906 		     const _Key& __k) const;
 1011         _M_insert_unique(_Arg&& __x);

  824     make_unique(_Args&&... __args)
  825     { return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...)); }

   52       struct _Tp2 { _Tp _M_t; };
   54       alignas(__alignof__(_Tp2::_M_t)) unsigned char _M_storage[sizeof(_Tp)];
   69       _Tp*
   73       const _Tp*

  117       { typedef typename _Base_type::template rebind_alloc<_Tp> other; };

  135 	construct(_Up* __p, _Args&&... __args)
  135 	construct(_Up* __p, _Args&&... __args)
  136 	{ ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
  140 	destroy(_Up* __p) { __p->~_Up(); }
  140 	destroy(_Up* __p) { __p->~_Up(); }

   50       typedef _E 		value_type;
   51       typedef const _E& 	reference;
   52       typedef const _E& 	const_reference;
   54       typedef const _E* 	iterator;
   55       typedef const _E* 	const_iterator;

  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>
 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; };

  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);