1 //===- RegionInfoImpl.h - SESE region detection analysis --------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
9 // Detects single entry single exit regions in the control flow graph.
10 //===----------------------------------------------------------------------===//
12 #ifndef LLVM_ANALYSIS_REGIONINFOIMPL_H
13 #define LLVM_ANALYSIS_REGIONINFOIMPL_H
15 #include "llvm/ADT/GraphTraits.h"
16 #include "llvm/ADT/PostOrderIterator.h"
17 #include "llvm/ADT/STLExtras.h"
18 #include "llvm/ADT/SmallVector.h"
19 #include "llvm/ADT/iterator_range.h"
20 #include "llvm/Analysis/DominanceFrontier.h"
21 #include "llvm/Analysis/LoopInfo.h"
22 #include "llvm/Analysis/PostDominators.h"
23 #include "llvm/Analysis/RegionInfo.h"
24 #include "llvm/Analysis/RegionIterator.h"
25 #include "llvm/Support/Debug.h"
26 #include "llvm/Support/ErrorHandling.h"
27 #include "llvm/Support/raw_ostream.h"
34 #include <type_traits>
37 #define DEBUG_TYPE "region"
41 //===----------------------------------------------------------------------===//
42 /// RegionBase Implementation
44 RegionBase<Tr>::RegionBase(BlockT *Entry, BlockT *Exit,
45 typename Tr::RegionInfoT *RInfo, DomTreeT *dt,
47 : RegionNodeBase<Tr>(Parent, Entry, 1), RI(RInfo), DT(dt), exit(Exit) {}
50 RegionBase<Tr>::~RegionBase() {
51 // Only clean the cache for this Region. Caches of child Regions will be
52 // cleaned when the child Regions are deleted.
57 void RegionBase<Tr>::replaceEntry(BlockT *BB) {
58 this->entry.setPointer(BB);
62 void RegionBase<Tr>::replaceExit(BlockT *BB) {
63 assert(exit && "No exit to replace!");
68 void RegionBase<Tr>::replaceEntryRecursive(BlockT *NewEntry) {
69 std::vector<RegionT *> RegionQueue;
70 BlockT *OldEntry = getEntry();
72 RegionQueue.push_back(static_cast<RegionT *>(this));
73 while (!RegionQueue.empty()) {
74 RegionT *R = RegionQueue.back();
75 RegionQueue.pop_back();
77 R->replaceEntry(NewEntry);
78 for (std::unique_ptr<RegionT> &Child : *R) {
79 if (Child->getEntry() == OldEntry)
80 RegionQueue.push_back(Child.get());
86 void RegionBase<Tr>::replaceExitRecursive(BlockT *NewExit) {
87 std::vector<RegionT *> RegionQueue;
88 BlockT *OldExit = getExit();
90 RegionQueue.push_back(static_cast<RegionT *>(this));
91 while (!RegionQueue.empty()) {
92 RegionT *R = RegionQueue.back();
93 RegionQueue.pop_back();
95 R->replaceExit(NewExit);
96 for (std::unique_ptr<RegionT> &Child : *R) {
97 if (Child->getExit() == OldExit)
98 RegionQueue.push_back(Child.get());
104 bool RegionBase<Tr>::contains(const BlockT *B) const {
105 BlockT *BB = const_cast<BlockT *>(B);
107 if (!DT->getNode(BB))
110 BlockT *entry = getEntry(), *exit = getExit();
116 return (DT->dominates(entry, BB) &&
117 !(DT->dominates(exit, BB) && DT->dominates(entry, exit)));
121 bool RegionBase<Tr>::contains(const LoopT *L) const {
122 // BBs that are not part of any loop are element of the Loop
123 // described by the NULL pointer. This loop is not part of any region,
124 // except if the region describes the whole function.
126 return getExit() == nullptr;
128 if (!contains(L->getHeader()))
131 SmallVector<BlockT *, 8> ExitingBlocks;
132 L->getExitingBlocks(ExitingBlocks);
134 for (BlockT *BB : ExitingBlocks) {
143 typename Tr::LoopT *RegionBase<Tr>::outermostLoopInRegion(LoopT *L) const {
147 while (L && contains(L->getParentLoop())) {
148 L = L->getParentLoop();
155 typename Tr::LoopT *RegionBase<Tr>::outermostLoopInRegion(LoopInfoT *LI,
157 assert(LI && BB && "LI and BB cannot be null!");
158 LoopT *L = LI->getLoopFor(BB);
159 return outermostLoopInRegion(L);
163 typename RegionBase<Tr>::BlockT *RegionBase<Tr>::getEnteringBlock() const {
164 BlockT *entry = getEntry();
165 BlockT *enteringBlock = nullptr;
167 for (BlockT *Pred : make_range(InvBlockTraits::child_begin(entry),
168 InvBlockTraits::child_end(entry))) {
169 if (DT->getNode(Pred) && !contains(Pred)) {
173 enteringBlock = Pred;
177 return enteringBlock;
181 typename RegionBase<Tr>::BlockT *RegionBase<Tr>::getExitingBlock() const {
182 BlockT *exit = getExit();
183 BlockT *exitingBlock = nullptr;
188 for (BlockT *Pred : make_range(InvBlockTraits::child_begin(exit),
189 InvBlockTraits::child_end(exit))) {
190 if (contains(Pred)) {
202 bool RegionBase<Tr>::isSimple() const {
203 return !isTopLevelRegion() && getEnteringBlock() && getExitingBlock();
207 std::string RegionBase<Tr>::getNameStr() const {
208 std::string exitName;
209 std::string entryName;
211 if (getEntry()->getName().empty()) {
212 raw_string_ostream OS(entryName);
214 getEntry()->printAsOperand(OS, false);
216 entryName = getEntry()->getName();
219 if (getExit()->getName().empty()) {
220 raw_string_ostream OS(exitName);
222 getExit()->printAsOperand(OS, false);
224 exitName = getExit()->getName();
226 exitName = "<Function Return>";
228 return entryName + " => " + exitName;
232 void RegionBase<Tr>::verifyBBInRegion(BlockT *BB) const {
234 llvm_unreachable("Broken region found: enumerated BB not in region!");
236 BlockT *entry = getEntry(), *exit = getExit();
239 make_range(BlockTraits::child_begin(BB), BlockTraits::child_end(BB))) {
240 if (!contains(Succ) && exit != Succ)
241 llvm_unreachable("Broken region found: edges leaving the region must go "
242 "to the exit node!");
246 for (BlockT *Pred : make_range(InvBlockTraits::child_begin(BB),
247 InvBlockTraits::child_end(BB))) {
249 llvm_unreachable("Broken region found: edges entering the region must "
250 "go to the entry node!");
256 void RegionBase<Tr>::verifyWalk(BlockT *BB, std::set<BlockT *> *visited) const {
257 BlockT *exit = getExit();
261 verifyBBInRegion(BB);
264 make_range(BlockTraits::child_begin(BB), BlockTraits::child_end(BB))) {
265 if (Succ != exit && visited->find(Succ) == visited->end())
266 verifyWalk(Succ, visited);
271 void RegionBase<Tr>::verifyRegion() const {
272 // Only do verification when user wants to, otherwise this expensive check
273 // will be invoked by PMDataManager::verifyPreservedAnalysis when
274 // a regionpass (marked PreservedAll) finish.
275 if (!RegionInfoBase<Tr>::VerifyRegionInfo)
278 std::set<BlockT *> visited;
279 verifyWalk(getEntry(), &visited);
283 void RegionBase<Tr>::verifyRegionNest() const {
284 for (const std::unique_ptr<RegionT> &R : *this)
285 R->verifyRegionNest();
291 typename RegionBase<Tr>::element_iterator RegionBase<Tr>::element_begin() {
292 return GraphTraits<RegionT *>::nodes_begin(static_cast<RegionT *>(this));
296 typename RegionBase<Tr>::element_iterator RegionBase<Tr>::element_end() {
297 return GraphTraits<RegionT *>::nodes_end(static_cast<RegionT *>(this));
301 typename RegionBase<Tr>::const_element_iterator
302 RegionBase<Tr>::element_begin() const {
303 return GraphTraits<const RegionT *>::nodes_begin(
304 static_cast<const RegionT *>(this));
308 typename RegionBase<Tr>::const_element_iterator
309 RegionBase<Tr>::element_end() const {
310 return GraphTraits<const RegionT *>::nodes_end(
311 static_cast<const RegionT *>(this));
315 typename Tr::RegionT *RegionBase<Tr>::getSubRegionNode(BlockT *BB) const {
316 using RegionT = typename Tr::RegionT;
318 RegionT *R = RI->getRegionFor(BB);
323 // If we pass the BB out of this region, that means our code is broken.
324 assert(contains(R) && "BB not in current region!");
326 while (contains(R->getParent()) && R->getParent() != this)
329 if (R->getEntry() != BB)
336 typename Tr::RegionNodeT *RegionBase<Tr>::getBBNode(BlockT *BB) const {
337 assert(contains(BB) && "Can get BB node out of this region!");
339 typename BBNodeMapT::const_iterator at = BBNodeMap.find(BB);
341 if (at == BBNodeMap.end()) {
342 auto Deconst = const_cast<RegionBase<Tr> *>(this);
343 typename BBNodeMapT::value_type V = {
345 llvm::make_unique<RegionNodeT>(static_cast<RegionT *>(Deconst), BB)};
346 at = BBNodeMap.insert(std::move(V)).first;
348 return at->second.get();
352 typename Tr::RegionNodeT *RegionBase<Tr>::getNode(BlockT *BB) const {
353 assert(contains(BB) && "Can get BB node out of this region!");
354 if (RegionT *Child = getSubRegionNode(BB))
355 return Child->getNode();
357 return getBBNode(BB);
361 void RegionBase<Tr>::transferChildrenTo(RegionT *To) {
362 for (std::unique_ptr<RegionT> &R : *this) {
364 To->children.push_back(std::move(R));
370 void RegionBase<Tr>::addSubRegion(RegionT *SubRegion, bool moveChildren) {
371 assert(!SubRegion->parent && "SubRegion already has a parent!");
372 assert(llvm::find_if(*this,
373 [&](const std::unique_ptr<RegionT> &R) {
374 return R.get() == SubRegion;
375 }) == children.end() &&
376 "Subregion already exists!");
378 SubRegion->parent = static_cast<RegionT *>(this);
379 children.push_back(std::unique_ptr<RegionT>(SubRegion));
384 assert(SubRegion->children.empty() &&
385 "SubRegions that contain children are not supported");
387 for (RegionNodeT *Element : elements()) {
388 if (!Element->isSubRegion()) {
389 BlockT *BB = Element->template getNodeAs<BlockT>();
391 if (SubRegion->contains(BB))
392 RI->setRegionFor(BB, SubRegion);
396 std::vector<std::unique_ptr<RegionT>> Keep;
397 for (std::unique_ptr<RegionT> &R : *this) {
398 if (SubRegion->contains(R.get()) && R.get() != SubRegion) {
399 R->parent = SubRegion;
400 SubRegion->children.push_back(std::move(R));
402 Keep.push_back(std::move(R));
408 std::move_iterator<typename RegionSet::iterator>(Keep.begin()),
409 std::move_iterator<typename RegionSet::iterator>(Keep.end()));
413 typename Tr::RegionT *RegionBase<Tr>::removeSubRegion(RegionT *Child) {
414 assert(Child->parent == this && "Child is not a child of this region!");
415 Child->parent = nullptr;
416 typename RegionSet::iterator I =
417 llvm::find_if(children, [&](const std::unique_ptr<RegionT> &R) {
418 return R.get() == Child;
420 assert(I != children.end() && "Region does not exit. Unable to remove.");
421 children.erase(children.begin() + (I - begin()));
426 unsigned RegionBase<Tr>::getDepth() const {
429 for (RegionT *R = getParent(); R != nullptr; R = R->getParent())
436 typename Tr::RegionT *RegionBase<Tr>::getExpandedRegion() const {
437 unsigned NumSuccessors = Tr::getNumSuccessors(exit);
439 if (NumSuccessors == 0)
442 RegionT *R = RI->getRegionFor(exit);
444 if (R->getEntry() != exit) {
445 for (BlockT *Pred : make_range(InvBlockTraits::child_begin(getExit()),
446 InvBlockTraits::child_end(getExit())))
449 if (Tr::getNumSuccessors(exit) == 1)
450 return new RegionT(getEntry(), *BlockTraits::child_begin(exit), RI, DT);
454 while (R->getParent() && R->getParent()->getEntry() == exit)
457 for (BlockT *Pred : make_range(InvBlockTraits::child_begin(getExit()),
458 InvBlockTraits::child_end(getExit()))) {
459 if (!(contains(Pred) || R->contains(Pred)))
463 return new RegionT(getEntry(), R->getExit(), RI, DT);
467 void RegionBase<Tr>::print(raw_ostream &OS, bool print_tree, unsigned level,
468 PrintStyle Style) const {
470 OS.indent(level * 2) << '[' << level << "] " << getNameStr();
472 OS.indent(level * 2) << getNameStr();
476 if (Style != PrintNone) {
477 OS.indent(level * 2) << "{\n";
478 OS.indent(level * 2 + 2);
480 if (Style == PrintBB) {
481 for (const auto *BB : blocks())
482 OS << BB->getName() << ", "; // TODO: remove the last ","
483 } else if (Style == PrintRN) {
484 for (const RegionNodeT *Element : elements()) {
485 OS << *Element << ", "; // TODO: remove the last ",
493 for (const std::unique_ptr<RegionT> &R : *this)
494 R->print(OS, print_tree, level + 1, Style);
497 if (Style != PrintNone)
498 OS.indent(level * 2) << "} \n";
501 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
503 void RegionBase<Tr>::dump() const {
504 print(dbgs(), true, getDepth(), RegionInfoBase<Tr>::printStyle);
509 void RegionBase<Tr>::clearNodeCache() {
511 for (std::unique_ptr<RegionT> &R : *this)
515 //===----------------------------------------------------------------------===//
516 // RegionInfoBase implementation
520 RegionInfoBase<Tr>::RegionInfoBase() = default;
523 RegionInfoBase<Tr>::~RegionInfoBase() {
528 void RegionInfoBase<Tr>::verifyBBMap(const RegionT *R) const {
529 assert(R && "Re must be non-null");
530 for (const typename Tr::RegionNodeT *Element : R->elements()) {
531 if (Element->isSubRegion()) {
532 const RegionT *SR = Element->template getNodeAs<RegionT>();
535 BlockT *BB = Element->template getNodeAs<BlockT>();
536 if (getRegionFor(BB) != R)
537 llvm_unreachable("BB map does not match region nesting");
543 bool RegionInfoBase<Tr>::isCommonDomFrontier(BlockT *BB, BlockT *entry,
544 BlockT *exit) const {
545 for (BlockT *P : make_range(InvBlockTraits::child_begin(BB),
546 InvBlockTraits::child_end(BB))) {
547 if (DT->dominates(entry, P) && !DT->dominates(exit, P))
555 bool RegionInfoBase<Tr>::isRegion(BlockT *entry, BlockT *exit) const {
556 assert(entry && exit && "entry and exit must not be null!");
558 using DST = typename DomFrontierT::DomSetType;
560 DST *entrySuccs = &DF->find(entry)->second;
562 // Exit is the header of a loop that contains the entry. In this case,
563 // the dominance frontier must only contain the exit.
564 if (!DT->dominates(entry, exit)) {
565 for (typename DST::iterator SI = entrySuccs->begin(),
566 SE = entrySuccs->end();
568 if (*SI != exit && *SI != entry)
575 DST *exitSuccs = &DF->find(exit)->second;
577 // Do not allow edges leaving the region.
578 for (BlockT *Succ : *entrySuccs) {
579 if (Succ == exit || Succ == entry)
581 if (exitSuccs->find(Succ) == exitSuccs->end())
583 if (!isCommonDomFrontier(Succ, entry, exit))
587 // Do not allow edges pointing into the region.
588 for (BlockT *Succ : *exitSuccs) {
589 if (DT->properlyDominates(entry, Succ) && Succ != exit)
597 void RegionInfoBase<Tr>::insertShortCut(BlockT *entry, BlockT *exit,
598 BBtoBBMap *ShortCut) const {
599 assert(entry && exit && "entry and exit must not be null!");
601 typename BBtoBBMap::iterator e = ShortCut->find(exit);
603 if (e == ShortCut->end())
604 // No further region at exit available.
605 (*ShortCut)[entry] = exit;
607 // We found a region e that starts at exit. Therefore (entry, e->second)
608 // is also a region, that is larger than (entry, exit). Insert the
610 BlockT *BB = e->second;
611 (*ShortCut)[entry] = BB;
616 typename Tr::DomTreeNodeT *
617 RegionInfoBase<Tr>::getNextPostDom(DomTreeNodeT *N, BBtoBBMap *ShortCut) const {
618 typename BBtoBBMap::iterator e = ShortCut->find(N->getBlock());
620 if (e == ShortCut->end())
623 return PDT->getNode(e->second)->getIDom();
627 bool RegionInfoBase<Tr>::isTrivialRegion(BlockT *entry, BlockT *exit) const {
628 assert(entry && exit && "entry and exit must not be null!");
630 unsigned num_successors =
631 BlockTraits::child_end(entry) - BlockTraits::child_begin(entry);
633 if (num_successors <= 1 && exit == *(BlockTraits::child_begin(entry)))
640 typename Tr::RegionT *RegionInfoBase<Tr>::createRegion(BlockT *entry,
642 assert(entry && exit && "entry and exit must not be null!");
644 if (isTrivialRegion(entry, exit))
648 new RegionT(entry, exit, static_cast<RegionInfoT *>(this), DT);
649 BBtoRegion.insert({entry, region});
651 #ifdef EXPENSIVE_CHECKS
652 region->verifyRegion();
654 DEBUG(region->verifyRegion());
657 updateStatistics(region);
662 void RegionInfoBase<Tr>::findRegionsWithEntry(BlockT *entry,
663 BBtoBBMap *ShortCut) {
666 DomTreeNodeT *N = PDT->getNode(entry);
670 RegionT *lastRegion = nullptr;
671 BlockT *lastExit = entry;
673 // As only a BasicBlock that postdominates entry can finish a region, walk the
674 // post dominance tree upwards.
675 while ((N = getNextPostDom(N, ShortCut))) {
676 BlockT *exit = N->getBlock();
681 if (isRegion(entry, exit)) {
682 RegionT *newRegion = createRegion(entry, exit);
685 newRegion->addSubRegion(lastRegion);
687 lastRegion = newRegion;
691 // This can never be a region, so stop the search.
692 if (!DT->dominates(entry, exit))
696 // Tried to create regions from entry to lastExit. Next time take a
697 // shortcut from entry to lastExit.
698 if (lastExit != entry)
699 insertShortCut(entry, lastExit, ShortCut);
703 void RegionInfoBase<Tr>::scanForRegions(FuncT &F, BBtoBBMap *ShortCut) {
704 using FuncPtrT = typename std::add_pointer<FuncT>::type;
706 BlockT *entry = GraphTraits<FuncPtrT>::getEntryNode(&F);
707 DomTreeNodeT *N = DT->getNode(entry);
709 // Iterate over the dominance tree in post order to start with the small
710 // regions from the bottom of the dominance tree. If the small regions are
711 // detected first, detection of bigger regions is faster, as we can jump
712 // over the small regions.
713 for (auto DomNode : post_order(N))
714 findRegionsWithEntry(DomNode->getBlock(), ShortCut);
718 typename Tr::RegionT *RegionInfoBase<Tr>::getTopMostParent(RegionT *region) {
719 while (region->getParent())
720 region = region->getParent();
726 void RegionInfoBase<Tr>::buildRegionsTree(DomTreeNodeT *N, RegionT *region) {
727 BlockT *BB = N->getBlock();
729 // Passed region exit
730 while (BB == region->getExit())
731 region = region->getParent();
733 typename BBtoRegionMap::iterator it = BBtoRegion.find(BB);
735 // This basic block is a start block of a region. It is already in the
736 // BBtoRegion relation. Only the child basic blocks have to be updated.
737 if (it != BBtoRegion.end()) {
738 RegionT *newRegion = it->second;
739 region->addSubRegion(getTopMostParent(newRegion));
742 BBtoRegion[BB] = region;
745 for (DomTreeNodeBase<BlockT> *C : *N) {
746 buildRegionsTree(C, region);
750 #ifdef EXPENSIVE_CHECKS
752 bool RegionInfoBase<Tr>::VerifyRegionInfo = true;
755 bool RegionInfoBase<Tr>::VerifyRegionInfo = false;
759 typename Tr::RegionT::PrintStyle RegionInfoBase<Tr>::printStyle =
760 RegionBase<Tr>::PrintNone;
763 void RegionInfoBase<Tr>::print(raw_ostream &OS) const {
764 OS << "Region tree:\n";
765 TopLevelRegion->print(OS, true, 0, printStyle);
766 OS << "End region tree\n";
769 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
771 void RegionInfoBase<Tr>::dump() const { print(dbgs()); }
775 void RegionInfoBase<Tr>::releaseMemory() {
778 delete TopLevelRegion;
779 TopLevelRegion = nullptr;
783 void RegionInfoBase<Tr>::verifyAnalysis() const {
784 // Do only verify regions if explicitely activated using EXPENSIVE_CHECKS or
785 // -verify-region-info
786 if (!RegionInfoBase<Tr>::VerifyRegionInfo)
789 TopLevelRegion->verifyRegionNest();
791 verifyBBMap(TopLevelRegion);
794 // Region pass manager support.
796 typename Tr::RegionT *RegionInfoBase<Tr>::getRegionFor(BlockT *BB) const {
797 typename BBtoRegionMap::const_iterator I = BBtoRegion.find(BB);
798 return I != BBtoRegion.end() ? I->second : nullptr;
802 void RegionInfoBase<Tr>::setRegionFor(BlockT *BB, RegionT *R) {
807 typename Tr::RegionT *RegionInfoBase<Tr>::operator[](BlockT *BB) const {
808 return getRegionFor(BB);
812 typename RegionInfoBase<Tr>::BlockT *
813 RegionInfoBase<Tr>::getMaxRegionExit(BlockT *BB) const {
814 BlockT *Exit = nullptr;
817 // Get largest region that starts at BB.
818 RegionT *R = getRegionFor(BB);
819 while (R && R->getParent() && R->getParent()->getEntry() == BB)
822 // Get the single exit of BB.
823 if (R && R->getEntry() == BB)
825 else if (++BlockTraits::child_begin(BB) == BlockTraits::child_end(BB))
826 Exit = *BlockTraits::child_begin(BB);
827 else // No single exit exists.
830 // Get largest region that starts at Exit.
831 RegionT *ExitR = getRegionFor(Exit);
832 while (ExitR && ExitR->getParent() &&
833 ExitR->getParent()->getEntry() == Exit)
834 ExitR = ExitR->getParent();
836 for (BlockT *Pred : make_range(InvBlockTraits::child_begin(Exit),
837 InvBlockTraits::child_end(Exit))) {
838 if (!R->contains(Pred) && !ExitR->contains(Pred))
842 // This stops infinite cycles.
843 if (DT->dominates(Exit, BB))
853 typename Tr::RegionT *RegionInfoBase<Tr>::getCommonRegion(RegionT *A,
855 assert(A && B && "One of the Regions is NULL");
860 while (!B->contains(A))
867 typename Tr::RegionT *
868 RegionInfoBase<Tr>::getCommonRegion(SmallVectorImpl<RegionT *> &Regions) const {
869 RegionT *ret = Regions.back();
872 for (RegionT *R : Regions)
873 ret = getCommonRegion(ret, R);
879 typename Tr::RegionT *
880 RegionInfoBase<Tr>::getCommonRegion(SmallVectorImpl<BlockT *> &BBs) const {
881 RegionT *ret = getRegionFor(BBs.back());
884 for (BlockT *BB : BBs)
885 ret = getCommonRegion(ret, getRegionFor(BB));
891 void RegionInfoBase<Tr>::calculate(FuncT &F) {
892 using FuncPtrT = typename std::add_pointer<FuncT>::type;
894 // ShortCut a function where for every BB the exit of the largest region
895 // starting with BB is stored. These regions can be threated as single BBS.
896 // This improves performance on linear CFGs.
899 scanForRegions(F, &ShortCut);
900 BlockT *BB = GraphTraits<FuncPtrT>::getEntryNode(&F);
901 buildRegionsTree(DT->getNode(BB), TopLevelRegion);
904 } // end namespace llvm
908 #endif // LLVM_ANALYSIS_REGIONINFOIMPL_H