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

Declarations

lib/Transforms/Vectorize/SLPVectorizer.cpp
  492   struct ScheduleData;

References

lib/Transforms/Vectorize/SLPVectorizer.cpp
 1385   TreeEntry *newTreeEntry(ArrayRef<Value *> VL, Optional<ScheduleData *> Bundle,
 1407       for (ScheduleData *BundleMember = Bundle.getValue(); BundleMember;
 1604         ScheduleData *SD = NextInBundle;
 1619     ScheduleData *FirstInBundle = nullptr;
 1623     ScheduleData *NextInBundle = nullptr;
 1627     ScheduleData *NextLoadStore = nullptr;
 1631     SmallVector<ScheduleData *, 4> MemoryDependencies;
 1672                                         const BoUpSLP::ScheduleData &SD) {
 1705     ScheduleData *getScheduleData(Value *V) {
 1706       ScheduleData *SD = ScheduleDataMap[V];
 1712     ScheduleData *getScheduleData(Value *V, Value *Key) {
 1717         ScheduleData *SD = I->second[Key];
 1724     bool isInSchedulingRegion(ScheduleData *SD) {
 1731     void schedule(ScheduleData *SD, ReadyListType &ReadyList) {
 1735       ScheduleData *BundleMember = SD;
 1751               ScheduleData *DepBundle = OpDef->FirstInBundle;
 1779         for (ScheduleData *MemoryDepSD : BundleMember->MemoryDependencies) {
 1783             ScheduleData *DepBundle = MemoryDepSD->FirstInBundle;
 1796                          function_ref<void(ScheduleData *SD)> Action) {
 1797       if (ScheduleData *SD = getScheduleData(V))
 1825     Optional<ScheduleData *>
 1833     ScheduleData *allocateScheduleDataChunks();
 1842                           ScheduleData *PrevLoadStore,
 1843                           ScheduleData *NextLoadStore);
 1847     void calculateDependencies(ScheduleData *SD, bool InsertInReadyList,
 1856     std::vector<std::unique_ptr<ScheduleData[]>> ScheduleDataChunks;
 1868     DenseMap<Value *, ScheduleData *> ScheduleDataMap;
 1871     DenseMap<Value *, SmallDenseMap<Value *, ScheduleData *>>
 1874     struct ReadyList : SmallVector<ScheduleData *, 8> {
 1875       void insert(ScheduleData *SD) { push_back(SD); }
 1889     ScheduleData *FirstLoadStoreInRegion = nullptr;
 1893     ScheduleData *LastLoadStoreInRegion = nullptr;
 2300   Optional<ScheduleData *> Bundle = BS.tryScheduleBundle(VL, this, S);
 3573     auto *Bundle =
 4478 Optional<BoUpSLP::ScheduleData *>
 4486   ScheduleData *PrevInBundle = nullptr;
 4487   ScheduleData *Bundle = nullptr;
 4499     ScheduleData *BundleMember = getScheduleData(V);
 4554     ScheduleData *pickedSD = ReadyInsts.back();
 4573   ScheduleData *Bundle = getScheduleData(OpValue);
 4581   ScheduleData *BundleMember = Bundle;
 4585     ScheduleData *Next = BundleMember->NextInBundle;
 4595 BoUpSLP::ScheduleData *BoUpSLP::BlockScheduling::allocateScheduleDataChunks() {
 4598     ScheduleDataChunks.push_back(std::make_unique<ScheduleData[]>(ChunkSize));
 4612     ScheduleData *ISD = getScheduleData(I);
 4617     ScheduleData *SD = allocateScheduleDataChunks();
 4683                                                 ScheduleData *PrevLoadStore,
 4684                                                 ScheduleData *NextLoadStore) {
 4685   ScheduleData *CurrentLoadStore = PrevLoadStore;
 4687     ScheduleData *SD = ScheduleDataMap[I];
 4717 void BoUpSLP::BlockScheduling::calculateDependencies(ScheduleData *SD,
 4722   SmallVector<ScheduleData *, 10> WorkList;
 4726     ScheduleData *SD = WorkList.back();
 4729     ScheduleData *BundleMember = SD;
 4741           ScheduleData *UseSD = getScheduleData(BundleMember->Inst);
 4744             ScheduleData *DestBundle = UseSD->FirstInBundle;
 4753               ScheduleData *UseSD = getScheduleData(U);
 4756                 ScheduleData *DestBundle = UseSD->FirstInBundle;
 4773         ScheduleData *DepDest = BundleMember->NextLoadStore;
 4803               ScheduleData *DestBundle = DepDest->FirstInBundle;
 4868     bool operator()(ScheduleData *SD1, ScheduleData *SD2) const {
 4868     bool operator()(ScheduleData *SD1, ScheduleData *SD2) const {
 4872   std::set<ScheduleData *, ScheduleDataCompare> ReadyInsts;
 4897     ScheduleData *picked = *ReadyInsts.begin();
 4902     ScheduleData *BundleMember = picked;
usr/include/c++/7.4.0/bits/unique_ptr.h
  103         default_delete(const default_delete<_Up[]>&) noexcept { }
  107       typename enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value>::type
  107       typename enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value>::type
  108 	operator()(_Up* __ptr) const
  110 	static_assert(sizeof(_Tp)>0,
  122 	  using type = _Up*;
  137       using pointer = typename _Ptr<_Tp, _Dp>::type;
  401 	typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;
  403       __uniq_ptr_impl<_Tp, _Dp> _M_t;
  411 	  = __and_< is_base_of<_Tp, _Up>,
  412 		    __not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up>>> >;
  412 		    __not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up>>> >;
  412 		    __not_<is_same<__remove_cv<_Tp>, __remove_cv<_Up>>> >;
  415       using pointer	  = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
  416       using element_type  = _Tp;
  815     { typedef unique_ptr<_Tp[]> __array; };
  831     { return unique_ptr<_Tp>(new remove_extent_t<_Tp>[__num]()); }
  831     { return unique_ptr<_Tp>(new remove_extent_t<_Tp>[__num]()); }
usr/include/c++/7.4.0/type_traits
  215     : public __is_void_helper<typename remove_cv<_Tp>::type>::type
  581     : public __or_<is_lvalue_reference<_Tp>,
  582                    is_rvalue_reference<_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
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
  638     : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
 1554     { typedef _Tp     type; };
 1563     { typedef _Tp     type; };
 1574       remove_const<typename remove_volatile<_Tp>::type>::type     type;
 1645     { typedef _Tp&   type; };
 1650     : public __add_lvalue_reference_helper<_Tp>
 1950     { typedef _Tp     type; };
 1983     { typedef _Up     type; };