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

Declarations

include/llvm/Analysis/BlockFrequencyInfoImpl.h
   58 class MachineLoop;
include/llvm/CodeGen/MachineLoopInfo.h
   42 class MachineLoop;
include/llvm/CodeGen/MachineTraceMetrics.h
   63 class MachineLoop;
include/llvm/CodeGen/TargetInstrInfo.h
   46 class MachineLoop;
include/llvm/CodeGen/TargetLowering.h
   84 class MachineLoop;

References

include/llvm/ADT/STLExtras.h
  154 auto adl_begin(ContainerTy &&container)
  162 auto adl_end(ContainerTy &&container)
  178 auto adl_begin(ContainerTy &&container)
  184 auto adl_end(ContainerTy &&container)
 1224 bool is_contained(R &&Range, const E &Element) {
include/llvm/Analysis/BlockFrequencyInfoImpl.h
  556   using LoopT = MachineLoop;
include/llvm/Analysis/CFG.h
  150     for (const auto *Lp = LI.getLoopFor(Src); Lp; Lp = Lp->getParentLoop()) {
include/llvm/Analysis/LoopInfo.h
   75   LoopT *ParentLoop;
   77   std::vector<LoopT *> SubLoops;
   89   LoopBase(const LoopBase<BlockT, LoopT> &) = delete;
   90   const LoopBase<BlockT, LoopT> &
   91   operator=(const LoopBase<BlockT, LoopT> &) = delete;
  100     for (const LoopT *CurLoop = ParentLoop; CurLoop;
  106   LoopT *getParentLoop() const { return ParentLoop; }
  109   void setParentLoop(LoopT *L) {
  115   bool contains(const LoopT *L) const {
  131   template <class InstT> bool contains(const InstT *Inst) const {
  136   const std::vector<LoopT *> &getSubLoops() const {
  140   std::vector<LoopT *> &getSubLoopsVector() {
  144   typedef typename std::vector<LoopT *>::const_iterator iterator;
  146       typename std::vector<LoopT *>::const_reverse_iterator reverse_iterator;
  325   static void getInnerLoopsInPreorder(const LoopT &L,
  327     SmallVector<LoopT *, 4> PreOrderWorklist;
  331       LoopT *L = PreOrderWorklist.pop_back_val();
  341   SmallVector<const LoopT *, 4> getLoopsInPreorder() const {
  342     SmallVector<const LoopT *, 4> PreOrderLoops;
  343     const LoopT *CurLoop = static_cast<const LoopT *>(this);
  348   SmallVector<LoopT *, 4> getLoopsInPreorder() {
  349     SmallVector<LoopT *, 4> PreOrderLoops;
  350     LoopT *CurLoop = static_cast<LoopT *>(this);
  365   void addBasicBlockToLoop(BlockT *NewBB, LoopInfoBase<BlockT, LoopT> &LI);
  371   void replaceChildLoopWith(LoopT *OldChild, LoopT *NewChild);
  371   void replaceChildLoopWith(LoopT *OldChild, LoopT *NewChild);
  375   void addChildLoop(LoopT *NewChild) {
  384   LoopT *removeChildLoop(iterator I) {
  387     LoopT *Child = *I;
  396   LoopT *removeChildLoop(LoopT *Child) {
  396   LoopT *removeChildLoop(LoopT *Child) {
  453   void verifyLoopNest(DenseSet<const LoopT *> *Loops) const;
  485     for (auto *SubLoop : SubLoops)
  499 raw_ostream &operator<<(raw_ostream &OS, const LoopBase<BlockT, LoopT> &Loop) {
  850   DenseMap<const BlockT *, LoopT *> BBMap;
  851   std::vector<LoopT *> TopLevelLoops;
  874     for (auto *L : TopLevelLoops)
  886     for (auto *L : TopLevelLoops)
  892   template <typename... ArgsTy> LoopT *AllocateLoop(ArgsTy &&... Args) {
  893     LoopT *Storage = LoopAllocator.Allocate<LoopT>();
  893     LoopT *Storage = LoopAllocator.Allocate<LoopT>();
  894     return new (Storage) LoopT(std::forward<ArgsTy>(Args)...);
  900   typedef typename std::vector<LoopT *>::const_iterator iterator;
  902       typename std::vector<LoopT *>::const_reverse_iterator reverse_iterator;
  914   SmallVector<LoopT *, 4> getLoopsInPreorder();
  924   SmallVector<LoopT *, 4> getLoopsInReverseSiblingPreorder();
  928   LoopT *getLoopFor(const BlockT *BB) const { return BBMap.lookup(BB); }
  931   const LoopT *operator[](const BlockT *BB) const { return getLoopFor(BB); }
  936     const LoopT *L = getLoopFor(BB);
  942     const LoopT *L = getLoopFor(BB);
  949   LoopT *removeLoop(iterator I) {
  951     LoopT *L = *I;
  960   void changeLoopFor(BlockT *BB, LoopT *L) {
  970   void changeTopLevelLoop(LoopT *OldLoop, LoopT *NewLoop) {
  970   void changeTopLevelLoop(LoopT *OldLoop, LoopT *NewLoop) {
  979   void addTopLevelLoop(LoopT *New) {
  990       for (LoopT *L = I->second; L; L = L->getParentLoop())
  999   static bool isNotAlreadyContainedIn(const LoopT *SubLoop,
 1000                                       const LoopT *ParentLoop) {
 1026   void destroy(LoopT *L) {
include/llvm/Analysis/LoopInfoImpl.h
  248   LoopT *L = static_cast<LoopT *>(this);
  270   typename std::vector<LoopT *>::iterator I = find(SubLoops, OldChild);
  418 static void discoverAndMapSubloop(LoopT *L, ArrayRef<BlockT *> Backedges,
  419                                   LoopInfoBase<BlockT, LoopT> *LI,
  432     LoopT *Subloop = LI->getLoopFor(PredBB);
  448       while (LoopT *Parent = Subloop->getParentLoop())
  479   LoopInfoBase<BlockT, LoopT> *LI;
  482   PopulateLoopsDFS(LoopInfoBase<BlockT, LoopT> *li) : LI(li) {}
  502   LoopT *Subloop = LI->getLoopFor(Block);
  556       LoopT *L = AllocateLoop(Header);
  562   PopulateLoopsDFS<BlockT, LoopT> DFS(this);
  568   SmallVector<LoopT *, 4> PreOrderLoops, PreOrderWorklist;
  574   for (LoopT *RootL : reverse(*this)) {
  586   SmallVector<LoopT *, 4> PreOrderLoops, PreOrderWorklist;
  592   for (LoopT *RootL : *this) {
  597       LoopT *L = PreOrderWorklist.pop_back_val();
  629 void addInnerLoopsToHeadersMap(DenseMap<BlockT *, const LoopT *> &LoopHeaders,
  630                                const LoopInfoBase<BlockT, LoopT> &LI,
  631                                const LoopT &L) {
  633   for (LoopT *SL : L)
  639 static void compareLoops(const LoopT *L, const LoopT *OtherL,
  639 static void compareLoops(const LoopT *L, const LoopT *OtherL,
  640                          DenseMap<BlockT *, const LoopT *> &OtherLoopHeaders) {
  648   const LoopT *ParentL = L, *OtherParentL = OtherL;
  656   for (const LoopT *SubL : *L) {
  658     const LoopT *OtherSubL = OtherLoopHeaders.lookup(SubH);
  683   DenseSet<const LoopT *> Loops;
  693     LoopT *L = Entry.second;
  696     for (LoopT *ChildLoop : *L)
  702   LoopInfoBase<BlockT, LoopT> OtherLI;
  708   DenseMap<BlockT *, const LoopT *> OtherLoopHeaders;
  709   for (LoopT *L : OtherLI)
  715   for (LoopT *L : *this) {
  717     const LoopT *OtherL = OtherLoopHeaders.lookup(Header);
include/llvm/CodeGen/MachineLoopInfo.h
   45 class MachineLoop : public LoopBase<MachineBasicBlock, MachineLoop> {
   87   LoopInfoBase<MachineBasicBlock, MachineLoop> LI;
  102   LoopInfoBase<MachineBasicBlock, MachineLoop>& getBase() { return LI; }
  109   MachineBasicBlock *findLoopPreheader(MachineLoop *L,
  113   using iterator = LoopInfoBase<MachineBasicBlock, MachineLoop>::iterator;
  120   inline MachineLoop *getLoopFor(const MachineBasicBlock *BB) const {
  125   inline const MachineLoop *operator[](const MachineBasicBlock *BB) const {
  149   inline MachineLoop *removeLoop(iterator I) { return LI.removeLoop(I); }
  154   inline void changeLoopFor(MachineBasicBlock *BB, MachineLoop *L) {
  160   inline void changeTopLevelLoop(MachineLoop *OldLoop, MachineLoop *NewLoop) {
  160   inline void changeTopLevelLoop(MachineLoop *OldLoop, MachineLoop *NewLoop) {
  165   inline void addTopLevelLoop(MachineLoop *New) {
  179   using NodeRef = const MachineLoop *;
  182   static NodeRef getEntryNode(const MachineLoop *L) { return L; }
  188   using NodeRef = MachineLoop *;
  191   static NodeRef getEntryNode(MachineLoop *L) { return L; }
include/llvm/CodeGen/MachinePipeliner.h
  103   bool canPipelineLoop(MachineLoop &L);
  104   bool scheduleLoop(MachineLoop &L);
  105   bool swingModuloScheduler(MachineLoop &L);
  106   void setPragmaPipelineOptions(MachineLoop &L);
  119   MachineLoop &Loop;
  199   SwingSchedulerDAG(MachinePipeliner &P, MachineLoop &L, LiveIntervals &lis,
include/llvm/CodeGen/MachineRegionInfo.h
   41   using LoopT = MachineLoop;
include/llvm/CodeGen/MachineTraceMetrics.h
  345     const MachineLoop *getLoopFor(const MachineBasicBlock*) const;
include/llvm/CodeGen/ModuloSchedule.h
   81   MachineLoop *Loop;
  105   ModuloSchedule(MachineFunction &MF, MachineLoop *Loop,
  118   MachineLoop *getLoop() const { return Loop; }
include/llvm/CodeGen/TargetInstrInfo.h
  714   virtual bool analyzeLoop(MachineLoop &L, MachineInstr *&IndVarInst,
include/llvm/CodeGen/TargetLowering.h
 1616   virtual Align getPrefLoopAlignment(MachineLoop *ML = nullptr) const {
include/llvm/Support/Allocator.h
   81   template <typename T> T *Allocate(size_t Num = 1) {
   82     return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
   82     return static_cast<T *>(Allocate(Num * sizeof(T), alignof(T)));
   88       !std::is_same<typename std::remove_cv<T>::type, void>::value, void>::type
   89   Deallocate(T *Ptr, size_t Num = 1) {
   90     Deallocate(static_cast<const void *>(Ptr), Num * sizeof(T));
include/llvm/Support/PointerLikeTypeTraits.h
   56   static inline void *getAsVoidPointer(T *P) { return P; }
   57   static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
   59   enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };
   91   typedef PointerLikeTypeTraits<T *> NonConst;
   93   static inline const void *getAsVoidPointer(const T *P) {
   96   static inline const T *getFromVoidPointer(const void *P) {
lib/CodeGen/AsmPrinter/AsmPrinter.cpp
 2842 static void PrintParentLoopComment(raw_ostream &OS, const MachineLoop *Loop,
 2854 static void PrintChildLoopComment(raw_ostream &OS, const MachineLoop *Loop,
 2857   for (const MachineLoop *CL : *Loop) {
 2871   const MachineLoop *Loop = LI->getLoopFor(&MBB);
lib/CodeGen/BranchFolding.cpp
  474     if (MachineLoop *ML = MLI->getLoopFor(&CurMBB))
 1128     MachineLoop *ML;
lib/CodeGen/CalcSpillWeights.cpp
  156   MachineLoop *loop = nullptr;
lib/CodeGen/MachineBasicBlock.cpp
 1076     if (MachineLoop *TIL = MLI->getLoopFor(this)) {
 1079       if (MachineLoop *DestLoop = MLI->getLoopFor(Succ)) {
 1096           if (MachineLoop *P = DestLoop->getParentLoop())
lib/CodeGen/MachineBlockPlacement.cpp
  466       const MachineLoop &L, const BlockFilterSet &LoopBlockSet);
  468       const MachineLoop &L, const BlockFilterSet &LoopBlockSet);
  470       const MachineLoop &L, const BlockFilterSet &LoopBlockSet,
  472   BlockFilterSet collectLoopBlockSet(const MachineLoop &L);
  473   void buildLoopChains(const MachineLoop &L);
  478       BlockChain &LoopChain, const MachineLoop &L,
 1954     const MachineLoop &L,
 2019 MachineBlockPlacement::findBestLoopTop(const MachineLoop &L,
 2048 MachineBlockPlacement::findBestLoopExit(const MachineLoop &L,
 2109       if (MachineLoop *ExitLoop = MLI->getLoopFor(Succ)) {
 2289     BlockChain &LoopChain, const MachineLoop &L,
 2427 MachineBlockPlacement::collectLoopBlockSet(const MachineLoop &L) {
 2464 void MachineBlockPlacement::buildLoopChains(const MachineLoop &L) {
 2467   for (const MachineLoop *InnerLoop : L)
 2593   for (MachineLoop *L : *MLI)
 2763     MachineLoop *L = MLI->getLoopFor(ChainBB);
lib/CodeGen/MachineCombiner.cpp
  503   const MachineLoop *ML = MLI->getLoopFor(MBB);
lib/CodeGen/MachineLICM.cpp
  110     MachineLoop *CurLoop;          // The current loop we are working on.
  292 static bool LoopIsOuterMostWithPredecessor(MachineLoop *CurLoop) {
  297   for (MachineLoop *L = CurLoop->getParentLoop(); L; L = L->getParentLoop())
  340   SmallVector<MachineLoop *, 8> Worklist(MLI->begin(), MLI->end());
  505     const MachineLoop *ML = MLI->getLoopFor(BB);
  689     const MachineLoop *ML = MLI->getLoopFor(BB);
lib/CodeGen/MachineLoopInfo.cpp
  111 MachineLoopInfo::findLoopPreheader(MachineLoop *L,
  138     MachineLoop *T = getLoopFor(S);
lib/CodeGen/MachinePipeliner.cpp
  233 bool MachinePipeliner::scheduleLoop(MachineLoop &L) {
  261 void MachinePipeliner::setPragmaPipelineOptions(MachineLoop &L) {
  308 bool MachinePipeliner::canPipelineLoop(MachineLoop &L) {
  382 bool MachinePipeliner::swingModuloScheduler(MachineLoop &L) {
lib/CodeGen/MachineTraceMetrics.cpp
  167 const MachineLoop*
  303 static bool isExitingLoop(const MachineLoop *From, const MachineLoop *To) {
  303 static bool isExitingLoop(const MachineLoop *From, const MachineLoop *To) {
  328   const MachineLoop *CurLoop = getLoopFor(MBB);
  356   const MachineLoop *CurLoop = getLoopFor(MBB);
  459       if (const MachineLoop *FromLoop = LB.Loops->getLoopFor(*From)) {
  596       const MachineLoop *Loop = getLoopFor(MBB);
  604       const MachineLoop *Loop = getLoopFor(MBB);
  605       const MachineLoop *SuccLoop = getLoopFor(TBI.Succ);
 1069       if (const MachineLoop *Loop = getLoopFor(MBB))
lib/CodeGen/ModuloSchedule.cpp
 1273   KernelRewriter(MachineLoop &L, ModuloSchedule &S,
 1279 KernelRewriter::KernelRewriter(MachineLoop &L, ModuloSchedule &S,
 1936   void runOnLoop(MachineFunction &MF, MachineLoop &L);
 1957   for (auto *L : MLI) {
 1985 void ModuloScheduleTest::runOnLoop(MachineFunction &MF, MachineLoop &L) {
lib/CodeGen/PHIElimination.cpp
  568   const MachineLoop *CurLoop = MLI ? MLI->getLoopFor(&MBB) : nullptr;
  585       const MachineLoop *PreLoop = MLI ? MLI->getLoopFor(PreMBB) : nullptr;
lib/CodeGen/RegAllocGreedy.cpp
  544   void reportNumberOfSplillsReloads(MachineLoop *L, unsigned &Reloads,
  550     for (MachineLoop *L : *Loops) {
 3138 void RAGreedy::reportNumberOfSplillsReloads(MachineLoop *L, unsigned &Reloads,
 3148   for (MachineLoop *SubLoop : *L) {
lib/CodeGen/SplitKit.cpp
  898   const MachineLoop *DefLoop = Loops.getLoopFor(DefMBB);
  906     const MachineLoop *Loop = Loops.getLoopFor(MBB);
lib/Target/AArch64/AArch64FalkorHWPFFix.cpp
  203   void runOnLoop(MachineLoop &L, MachineFunction &Fn);
  676 void FalkorHWPFFix::runOnLoop(MachineLoop &L, MachineFunction &Fn) {
  832   for (MachineLoop *I : LI)
lib/Target/AMDGPU/AMDILCFGStructurizer.cpp
  120   using LoopLandInfoMap = std::map<MachineLoop *, MachineBasicBlock *>;
  196     for (MachineLoop::iterator iter = LoopInfo.begin(),
  204   MachineBasicBlock *getLoopLandInfo(MachineLoop *LoopRep) const;
  270   int mergeLoop(MachineLoop *LoopRep);
  310   MachineBasicBlock *normalizeInfiniteLoopExit(MachineLoop *LoopRep);
  335   std::map<MachineLoop *, bool> Visited;
  351 MachineBasicBlock *AMDGPUCFGStructurizer::getLoopLandInfo(MachineLoop *LoopRep)
  360   MachineLoop *LoopRep = MLI->getLoopFor(MBB);
  375   MachineLoop *LoopRep = MLI->getLoopFor(MBB);
  720     MachineLoop *LoopRep = (*It);
 1014   std::deque<MachineLoop *> NestedLoops;
 1016     for (MachineLoop *ML : depth_first(It))
 1026   for (MachineLoop *ExaminedLoop : NestedLoops) {
 1038 int AMDGPUCFGStructurizer::mergeLoop(MachineLoop *LoopRep) {
 1070   MachineLoop *ParentLoop = LoopRep->getParentLoop();
 1082     MachineLoop *LoopRep = MLI->getLoopFor(Src1MBB);
 1576 AMDGPUCFGStructurizer::normalizeInfiniteLoopExit(MachineLoop* LoopRep) {
lib/Target/AMDGPU/SIISelLowering.cpp
10741 Align SITargetLowering::getPrefLoopAlignment(MachineLoop *ML) const {
10788   for (MachineLoop *P = ML->getParentLoop(); P; P = P->getParentLoop()) {
lib/Target/AMDGPU/SIISelLowering.h
  403   Align getPrefLoopAlignment(MachineLoop *ML) const override;
lib/Target/ARM/ARMLowOverheadLoops.cpp
   65     bool ProcessLoop(MachineLoop *ML);
   77     void Expand(MachineLoop *ML, MachineInstr *Start,
  213 bool ARMLowOverheadLoops::ProcessLoop(MachineLoop *ML) {
  441 void ARMLowOverheadLoops::Expand(MachineLoop *ML, MachineInstr *Start,
lib/Target/Hexagon/HexagonEarlyIfConv.cpp
  177     bool matchFlowPattern(MachineBasicBlock *B, MachineLoop *L,
  179     bool visitBlock(MachineBasicBlock *B, MachineLoop *L);
  180     bool visitLoop(MachineLoop *L);
  234   MachineLoop *L = MLI->getLoopFor(SB);
  239     MachineLoop *L, FlowPattern &FP) {
  597       MachineLoop *L) {
  643 bool HexagonEarlyIfConversion::visitLoop(MachineLoop *L) {
  650     for (MachineLoop::iterator I = L->begin(), E = L->end(); I != E; ++I)
lib/Target/Hexagon/HexagonHardwareLoops.cpp
  182     bool findInductionRegister(MachineLoop *L, unsigned &Reg,
  194     CountValue *getLoopTripCount(MachineLoop *L,
  204     CountValue *computeCount(MachineLoop *Loop, const MachineOperand *Start,
  215     bool containsInvalidInstruction(MachineLoop *L, bool IsInnerHWLoop) const;
  219     bool convertToHardwareLoop(MachineLoop *L, bool &L0used, bool &L1used);
  237     bool isLoopFeeder(MachineLoop *L, MachineBasicBlock *A, MachineInstr *MI,
  244                                MachineBasicBlock *MBB, MachineLoop *L,
  251                                      MachineBasicBlock *MBB, MachineLoop *L,
  297     bool fixupInductionVariable(MachineLoop *L);
  301     MachineBasicBlock *createPreheaderForLoop(MachineLoop *L);
  401 bool HexagonHardwareLoops::findInductionRegister(MachineLoop *L,
  565 CountValue *HexagonHardwareLoops::getLoopTripCount(MachineLoop *L,
  724 CountValue *HexagonHardwareLoops::computeCount(MachineLoop *Loop,
 1011 bool HexagonHardwareLoops::containsInvalidInstruction(MachineLoop *L,
 1123 bool HexagonHardwareLoops::convertToHardwareLoop(MachineLoop *L,
 1134   for (MachineLoop::iterator I = L->begin(), E = L->end(); I != E; ++I) {
 1364 bool HexagonHardwareLoops::isLoopFeeder(MachineLoop *L, MachineBasicBlock *A,
 1388     MachineLoop *L, LoopFeederMap &LoopFeederPhi) const {
 1416     MachineBasicBlock *MBB, MachineLoop *L,
 1606 bool HexagonHardwareLoops::fixupInductionVariable(MachineLoop *L) {
 1849       MachineLoop *L) {
 1991   MachineLoop *ParentLoop = L->getParentLoop();
lib/Target/Hexagon/HexagonSplitDouble.cpp
   93     using LoopRegMap = std::map<const MachineLoop *, USet>;
  103     void collectIndRegsForLoop(const MachineLoop *L, USet &Rs);
  455         const MachineLoop *L = MLI->getLoopFor(PB);
  476 void HexagonSplitDoubleRegs::collectIndRegsForLoop(const MachineLoop *L,
  573   using LoopVector = std::vector<MachineLoop *>;
  586     MachineLoop *L = WorkQ[i];
lib/Target/PowerPC/PPCISelLowering.cpp
14167 Align PPCTargetLowering::getPrefLoopAlignment(MachineLoop *ML) const {
lib/Target/PowerPC/PPCISelLowering.h
  748     Align getPrefLoopAlignment(MachineLoop *ML) const override;
lib/Target/SystemZ/SystemZMachineScheduler.cpp
   41                                              const MachineLoop *Loop) {
lib/Target/WebAssembly/WebAssemblyCFGSort.cpp
   60   const T *Region;
   63   ConcreteRegion(const T *Region) : Region(Region) {}
   83   DenseMap<const MachineLoop *, std::unique_ptr<Region>> LoopMap;
   92     const auto *ML = MLI.getLoopFor(MBB);
  100       LoopMap[ML] = std::make_unique<ConcreteRegion<MachineLoop>>(ML);
  250     if (MachineLoop *L = MLI.getLoopFor(&MBB))
  296       if (MachineLoop *SuccL = MLI.getLoopFor(Succ))
lib/Target/WebAssembly/WebAssemblyCFGStackify.cpp
  378   MachineLoop *Loop = MLI.getLoopFor(&MBB);
lib/Target/WebAssembly/WebAssemblyUtilities.h
   39 template <typename T> MachineBasicBlock *getBottom(const T *Unit) {
lib/Target/X86/X86CmovConversion.cpp
  223   SmallVector<MachineLoop *, 4> Loops(MLI.begin(), MLI.end());
  227     for (MachineLoop *Child : Loops[i]->getSubLoops())
  230   for (MachineLoop *CurrLoop : Loops) {
lib/Target/X86/X86FixupBWInsts.cpp
  371     if (MachineLoop *ML = MLI->getLoopFor(&MBB))
usr/include/c++/7.4.0/bits/move.h
   72     constexpr _Tp&&
   83     constexpr _Tp&&
usr/include/c++/7.4.0/bits/range_access.h
   48     begin(_Container& __cont) -> decltype(__cont.begin())
   58     begin(const _Container& __cont) -> decltype(__cont.begin())
   68     end(_Container& __cont) -> decltype(__cont.end())
   78     end(const _Container& __cont) -> decltype(__cont.end())
usr/include/c++/7.4.0/type_traits
 1554     { typedef _Tp     type; };
 1563     { typedef _Tp     type; };
 1574       remove_const<typename remove_volatile<_Tp>::type>::type     type;
 1633     { typedef _Tp   type; };
 1983     { typedef _Up     type; };