LLVM 24.0.0git
MustExecute.h
Go to the documentation of this file.
1//===- MustExecute.h - Is an instruction known to execute--------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8/// \file
9/// Contains a collection of routines for determining if a given instruction is
10/// guaranteed to execute if a given point in control flow is reached. The most
11/// common example is an instruction within a loop being provably executed if we
12/// branch to the header of it's containing loop.
13///
14/// There are two interfaces available to determine if an instruction is
15/// executed once a given point in the control flow is reached:
16/// 1) A loop-centric one derived from LoopSafetyInfo.
17/// 2) A "must be executed context"-based one implemented in the
18/// MustBeExecutedContextExplorer.
19/// Please refer to the class comments for more information.
20///
21//===----------------------------------------------------------------------===//
22
23#ifndef LLVM_ANALYSIS_MUSTEXECUTE_H
24#define LLVM_ANALYSIS_MUSTEXECUTE_H
25
26#include "llvm/ADT/DenseMap.h"
27#include "llvm/ADT/DenseSet.h"
28#include "llvm/ADT/MapVector.h"
29#include "llvm/ADT/SetVector.h"
33#include "llvm/IR/PassManager.h"
35
36namespace llvm {
37
38namespace {
39template <typename T> using GetterTy = std::function<T *(const Function &F)>;
40}
41
42class BasicBlock;
43class DominatorTree;
44class Loop;
45class LoopInfo;
47class raw_ostream;
48
49/// Captures loop safety information.
50/// It keep information for loop blocks may throw exception or otherwise
51/// exit abnormally on any iteration of the loop which might actually execute
52/// at runtime. The primary way to consume this information is via
53/// isGuaranteedToExecute below, but some callers bailout or fallback to
54/// alternate reasoning if a loop contains any implicit control flow.
55/// NOTE: LoopSafetyInfo contains cached information regarding loops and their
56/// particular blocks. Cached information may not be valid after control flow
57/// changes.
59 // Used to update funclet bundle operands.
60 mutable std::optional<DenseMap<BasicBlock *, ColorVector>> BlockColors;
61
62 // Cache whether (the start of) this block is guaranteed to execute if the
63 // loop is entered.
64 mutable DenseMap<const BasicBlock *, bool> GuaranteedToExecute;
65
66 bool allLoopPathsLeadToBlockImpl(const BasicBlock *BB,
67 const DominatorTree *DT) const;
68
69 /// Computes block colors.
70 void computeBlockColors() const;
71
72protected:
73 const Loop *CurLoop;
74
75public:
76 /// Returns block colors map that is used to update funclet operand bundles.
78
79 /// Copy colors of block \p Old into the block \p New.
81
82 /// Returns true iff the block \p BB potentially may throw exception. It can
83 /// be false-positive in cases when we want to avoid complex analysis.
84 virtual bool blockMayThrow(const BasicBlock *BB) const = 0;
85
86 /// Returns true iff any block of the loop for which this info is contains an
87 /// instruction that may throw or otherwise exit abnormally.
88 virtual bool anyBlockMayThrow() const = 0;
89
90 /// Return true if we must reach the block \p BB under assumption that the
91 /// loop is entered.
93 const DominatorTree *DT) const;
94
95 /// Returns true if the instruction in a loop is guaranteed to execute at
96 /// least once (under the assumption that the loop is entered).
97 virtual bool isGuaranteedToExecute(const Instruction &Inst,
98 const DominatorTree *DT) const = 0;
99
101
102 virtual ~LoopSafetyInfo() = default;
103};
104
105
106/// Simple and conservative implementation of LoopSafetyInfo that can give
107/// false-positive answers to its queries in order to avoid complicated
108/// analysis.
110 bool MayThrow = false; // The current loop contains an instruction which
111 // may throw.
112 bool HeaderMayThrow = false; // Same as previous, but specific to loop header
113
114 void computeLoopSafetyInfo();
115
116public:
117 explicit SimpleLoopSafetyInfo(const Loop *L) : LoopSafetyInfo(L) {
118 computeLoopSafetyInfo();
119 }
120
121 bool blockMayThrow(const BasicBlock *BB) const override;
122
123 bool anyBlockMayThrow() const override;
124
125 bool isGuaranteedToExecute(const Instruction &Inst,
126 const DominatorTree *DT) const override;
127};
128
129/// This implementation of LoopSafetyInfo use ImplicitControlFlowTracking to
130/// give precise answers on "may throw" queries. This implementation uses cache
131/// that should be invalidated by calling the methods insertInstructionTo and
132/// removeInstruction whenever we modify a basic block's contents by adding or
133/// removing instructions.
135 bool MayThrow = false; // The current loop contains an instruction which
136 // may throw.
137 // Contains information about implicit control flow in this loop's blocks.
138 mutable ImplicitControlFlowTracking ICF;
139 // Contains information about instruction that may possibly write memory.
140 mutable MemoryWriteTracking MW;
141
142 void computeLoopSafetyInfo();
143
144public:
145 explicit ICFLoopSafetyInfo(const Loop *L) : LoopSafetyInfo(L) {
146 computeLoopSafetyInfo();
147 }
148
149 bool blockMayThrow(const BasicBlock *BB) const override;
150
151 bool anyBlockMayThrow() const override;
152
153 bool isGuaranteedToExecute(const Instruction &Inst,
154 const DominatorTree *DT) const override;
155
156 /// Returns true if we could not execute a memory-modifying instruction before
157 /// we enter \p BB under assumption that the loop is entered.
158 bool doesNotWriteMemoryBefore(const BasicBlock *BB) const;
159
160 /// Returns true if we could not execute a memory-modifying instruction before
161 /// we execute \p I under assumption that the loop is entered.
162 bool doesNotWriteMemoryBefore(const Instruction &I) const;
163
164 /// Inform the safety info that we are planning to insert a new instruction
165 /// \p Inst into the basic block \p BB. It will make all cache updates to keep
166 /// it correct after this insertion.
167 void insertInstructionTo(const Instruction *Inst, const BasicBlock *BB);
168
169 /// Inform safety info that we are planning to remove the instruction \p Inst
170 /// from its block. It will make all cache updates to keep it correct after
171 /// this removal.
172 void removeInstruction(const Instruction *Inst);
173};
174
176 const LoopInfo *LI);
177
178struct MustBeExecutedContextExplorer;
179
180/// Enum that allows us to spell out the direction.
184};
185
186/// Must be executed iterators visit stretches of instructions that are
187/// guaranteed to be executed together, potentially with other instruction
188/// executed in-between.
189///
190/// Given the following code, and assuming all statements are single
191/// instructions which transfer execution to the successor (see
192/// isGuaranteedToTransferExecutionToSuccessor), there are two possible
193/// outcomes. If we start the iterator at A, B, or E, we will visit only A, B,
194/// and E. If we start at C or D, we will visit all instructions A-E.
195///
196/// \code
197/// A;
198/// B;
199/// if (...) {
200/// C;
201/// D;
202/// }
203/// E;
204/// \endcode
205///
206///
207/// Below is the example extneded with instructions F and G. Now we assume F
208/// might not transfer execution to it's successor G. As a result we get the
209/// following visit sets:
210///
211/// Start Instruction | Visit Set
212/// A | A, B, E, F
213/// B | A, B, E, F
214/// C | A, B, C, D, E, F
215/// D | A, B, C, D, E, F
216/// E | A, B, E, F
217/// F | A, B, E, F
218/// G | A, B, E, F, G
219///
220///
221/// \code
222/// A;
223/// B;
224/// if (...) {
225/// C;
226/// D;
227/// }
228/// E;
229/// F; // Might not transfer execution to its successor G.
230/// G;
231/// \endcode
232///
233///
234/// A more complex example involving conditionals, loops, break, and continue
235/// is shown below. We again assume all instructions will transmit control to
236/// the successor and we assume we can prove the inner loop to be finite. We
237/// omit non-trivial branch conditions as the exploration is oblivious to them.
238/// Constant branches are assumed to be unconditional in the CFG. The resulting
239/// visist sets are shown in the table below.
240///
241/// \code
242/// A;
243/// while (true) {
244/// B;
245/// if (...)
246/// C;
247/// if (...)
248/// continue;
249/// D;
250/// if (...)
251/// break;
252/// do {
253/// if (...)
254/// continue;
255/// E;
256/// } while (...);
257/// F;
258/// }
259/// G;
260/// \endcode
261///
262/// Start Instruction | Visit Set
263/// A | A, B
264/// B | A, B
265/// C | A, B, C
266/// D | A, B, D
267/// E | A, B, D, E, F
268/// F | A, B, D, F
269/// G | A, B, D, G
270///
271///
272/// Note that the examples show optimal visist sets but not necessarily the ones
273/// derived by the explorer depending on the available CFG analyses (see
274/// MustBeExecutedContextExplorer). Also note that we, depending on the options,
275/// the visit set can contain instructions from other functions.
277 /// Type declarations that make his class an input iterator.
278 ///{
279 typedef const Instruction *value_type;
280 typedef std::ptrdiff_t difference_type;
281 typedef const Instruction **pointer;
282 typedef const Instruction *&reference;
283 typedef std::input_iterator_tag iterator_category;
284 ///}
285
287
289
291 : Visited(std::move(Other.Visited)), Explorer(Other.Explorer),
292 CurInst(Other.CurInst), Head(Other.Head), Tail(Other.Tail) {}
293
295 if (this != &Other) {
296 std::swap(Visited, Other.Visited);
297 std::swap(CurInst, Other.CurInst);
298 std::swap(Head, Other.Head);
299 std::swap(Tail, Other.Tail);
300 }
301 return *this;
302 }
303
305
306 /// Pre- and post-increment operators.
307 ///{
309 CurInst = advance();
310 return *this;
311 }
312
314 MustBeExecutedIterator tmp(*this);
315 operator++();
316 return tmp;
317 }
318 ///}
319
320 /// Equality and inequality operators. Note that we ignore the history here.
321 ///{
323 return CurInst == Other.CurInst && Head == Other.Head && Tail == Other.Tail;
324 }
325
327 return !(*this == Other);
328 }
329 ///}
330
331 /// Return the underlying instruction.
332 const Instruction *&operator*() { return CurInst; }
333
334private:
335 using VisitedSetTy =
337
338 /// Private constructors.
340
341 /// Reset the iterator to its initial state pointing at \p I.
342 void reset(const Instruction *I);
343
344 /// Reset the iterator to point at \p I, keep cached state.
345 void resetInstruction(const Instruction *I);
346
347 /// Try to advance one of the underlying positions (Head or Tail).
348 ///
349 /// \return The next instruction in the must be executed context, or nullptr
350 /// if none was found.
351 LLVM_ABI const Instruction *advance();
352
353 /// A set to track the visited instructions in order to deal with endless
354 /// loops and recursion.
355 VisitedSetTy Visited;
356
357 /// A reference to the explorer that created this iterator.
358 ExplorerTy &Explorer;
359
360 /// The instruction we are currently exposing to the user. There is always an
361 /// instruction that we know is executed with the given program point,
362 /// initially the program point itself.
363 const Instruction *CurInst;
364
365 /// Two positions that mark the program points where this iterator will look
366 /// for the next instruction. Note that the current instruction is either the
367 /// one pointed to by Head, Tail, or both.
368 const Instruction *Head, *Tail;
369
371};
372
373/// A "must be executed context" for a given program point PP is the set of
374/// instructions, potentially before and after PP, that are executed always when
375/// PP is reached. The MustBeExecutedContextExplorer an interface to explore
376/// "must be executed contexts" in a module through the use of
377/// MustBeExecutedIterator.
378///
379/// The explorer exposes "must be executed iterators" that traverse the must be
380/// executed context. There is little information sharing between iterators as
381/// the expected use case involves few iterators for "far apart" instructions.
382/// If that changes, we should consider caching more intermediate results.
384
385 /// In the description of the parameters we use PP to denote a program point
386 /// for which the must be executed context is explored, or put differently,
387 /// for which the MustBeExecutedIterator is created.
388 ///
389 /// \param ExploreInterBlock Flag to indicate if instructions in blocks
390 /// other than the parent of PP should be
391 /// explored.
392 /// \param ExploreCFGForward Flag to indicate if instructions located after
393 /// PP in the CFG, e.g., post-dominating PP,
394 /// should be explored.
395 /// \param ExploreCFGBackward Flag to indicate if instructions located
396 /// before PP in the CFG, e.g., dominating PP,
397 /// should be explored.
400 GetterTy<const LoopInfo> LIGetter =
401 [](const Function &) { return nullptr; },
402 GetterTy<const DominatorTree> DTGetter =
403 [](const Function &) { return nullptr; },
404 GetterTy<const PostDominatorTree> PDTGetter =
405 [](const Function &) { return nullptr; })
408 ExploreCFGBackward(ExploreCFGBackward), LIGetter(LIGetter),
409 DTGetter(DTGetter), PDTGetter(PDTGetter), EndIterator(*this, nullptr) {}
410
411 /// Iterator-based interface. \see MustBeExecutedIterator.
412 ///{
415
416 /// Return an iterator to explore the context around \p PP.
418 auto &It = InstructionIteratorMap[PP];
419 if (!It)
420 It.reset(new iterator(*this, PP));
421 return *It;
422 }
423
424 /// Return an iterator to explore the cached context around \p PP.
425 const_iterator &begin(const Instruction *PP) const {
426 return *InstructionIteratorMap.find(PP)->second;
427 }
428
429 /// Return an universal end iterator.
430 ///{
431 iterator &end() { return EndIterator; }
432 iterator &end(const Instruction *) { return EndIterator; }
433
434 const_iterator &end() const { return EndIterator; }
435 const_iterator &end(const Instruction *) const { return EndIterator; }
436 ///}
437
438 /// Return an iterator range to explore the context around \p PP.
442
443 /// Return an iterator range to explore the cached context around \p PP.
445 return llvm::make_range(begin(PP), end(PP));
446 }
447 ///}
448
449 /// Return true if \p I is in the context of \p PP.
450 ///
451 /// That is the case if iterating over the context of \p PP visits \p I.
452 /// This does not explore the context of every program point separately but
453 /// uses summaries of the contexts of basic blocks that are shared by all
454 /// program points.
455 LLVM_ABI bool isInContextOf(const Instruction *I, const Instruction *PP);
456
457 /// Check \p Pred on all terminators in the context of \p PP and return
458 /// true if it holds for all of them.
459 LLVM_ABI bool
461 function_ref<bool(const Instruction *)> Pred);
462
463 /// Return the next instruction that is guaranteed to be executed after \p PP.
464 ///
465 /// \param It The iterator that is used to traverse the must be
466 /// executed context.
467 /// \param PP The program point for which the next instruction
468 /// that is guaranteed to execute is determined.
469 LLVM_ABI const Instruction *
471 const Instruction *PP);
472 /// Return the previous instr. that is guaranteed to be executed before \p PP.
473 ///
474 /// \param It The iterator that is used to traverse the must be
475 /// executed context.
476 /// \param PP The program point for which the previous instr.
477 /// that is guaranteed to execute is determined.
478 LLVM_ABI const Instruction *
480 const Instruction *PP);
481
482 /// Find the next join point from \p InitBB in forward direction.
484
485 /// Find the next join point from \p InitBB in backward direction.
487
488 /// Parameter that limit the performed exploration. See the constructor for
489 /// their meaning.
490 ///{
494 ///}
495
496private:
497 /// Getters for common CFG analyses: LoopInfo, DominatorTree, and
498 /// PostDominatorTree.
499 ///{
500 GetterTy<const LoopInfo> LIGetter;
501 GetterTy<const DominatorTree> DTGetter;
502 GetterTy<const PostDominatorTree> PDTGetter;
503 ///}
504
505 /// Map to cache isGuaranteedToTransferExecutionToSuccessor results.
507
508 /// Map to cache containsIrreducibleCFG results.
510
511 /// Map from instructions to associated must be executed iterators.
513 InstructionIteratorMap;
514
515 /// Return the first instruction at or after \p PP in its block that is not
516 /// guaranteed to transfer execution to its successor, or null if there is
517 /// none.
518 const Instruction *getForwardStop(const Instruction *PP);
519
520 /// Return the block in which the forward exploration continues after the
521 /// terminator of \p BB, or null if it stops.
522 const BasicBlock *getForwardNextBlock(const BasicBlock *BB);
523
524 /// Return the block in which the backward exploration continues before the
525 /// first instruction of \p BB, or null if it stops.
526 const BasicBlock *getBackwardNextBlock(const BasicBlock *BB);
527
528 /// Caches for getForwardNextBlock and getBackwardNextBlock.
531
532 /// Map from blocks to the instructions in them that are not guaranteed to
533 /// transfer execution to their successor, in order.
535 NonTransferringMap;
536
537 /// Map from blocks to the blocks in the forward context after their
538 /// terminator. Each block maps to the last instruction in the context, or
539 /// null if all of its instructions are in the context.
542 ForwardContextMap;
543
544 /// Map from blocks to the blocks in the backward context before their first
545 /// instruction. All instructions of these blocks are in the context.
546 using BackwardContextTy = SmallSetVector<const BasicBlock *, 8>;
548 BackwardContextMap;
549
550 /// Return the forward context after the terminator of \p BB.
551 const ForwardContextTy &getForwardContext(const BasicBlock *BB);
552
553 /// Return the backward context before the first instruction of \p BB.
554 const BackwardContextTy &getBackwardContext(const BasicBlock *BB);
555
556 /// A unique end iterator.
557 MustBeExecutedIterator EndIterator;
558};
559
561 : public RequiredPassInfoMixin<MustExecutePrinterPass> {
562 raw_ostream &OS;
563
564public:
567};
568
570 : public RequiredPassInfoMixin<MustBeExecutedContextPrinterPass> {
571 raw_ostream &OS;
572
573public:
576};
577
578} // namespace llvm
579
580#endif
SDValue Pred
#define LLVM_ABI
Definition Compiler.h:211
This file defines the DenseMap class.
This file defines the DenseSet and SmallDenseSet classes.
This header defines various interfaces for pass management in LLVM.
#define F(x, y, z)
Definition MD5.cpp:54
#define I(x, y, z)
Definition MD5.cpp:57
This file implements a map that provides insertion order iteration.
#define T
This file implements a set that has insertion order iteration characteristics.
This file defines the SmallVector class.
LLVM Basic Block Representation.
Definition BasicBlock.h:62
Implements a dense probed hash-table based set.
Definition DenseSet.h:283
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
Definition Dominators.h:122
ICFLoopSafetyInfo(const Loop *L)
This class allows to keep track on instructions with implicit control flow.
LLVM_ABI void copyColors(BasicBlock *New, BasicBlock *Old)
Copy colors of block Old into the block New.
LoopSafetyInfo(const Loop *CurLoop)
LLVM_ABI const DenseMap< BasicBlock *, ColorVector > & getBlockColors() const
Returns block colors map that is used to update funclet operand bundles.
virtual ~LoopSafetyInfo()=default
LLVM_ABI bool allLoopPathsLeadToBlock(const BasicBlock *BB, const DominatorTree *DT) const
Return true if we must reach the block BB under assumption that the loop is entered.
virtual bool anyBlockMayThrow() const =0
Returns true iff any block of the loop for which this info is contains an instruction that may throw ...
virtual bool blockMayThrow(const BasicBlock *BB) const =0
Returns true iff the block BB potentially may throw exception.
virtual bool isGuaranteedToExecute(const Instruction &Inst, const DominatorTree *DT) const =0
Returns true if the instruction in a loop is guaranteed to execute at least once (under the assumptio...
const Loop * CurLoop
Definition MustExecute.h:73
Represents a single loop in the control flow graph.
Definition LoopInfo.h:40
This class implements a map that also provides access to all stored values in a deterministic order.
Definition MapVector.h:39
A Module instance is used to store all the information related to an LLVM module.
Definition Module.h:68
LLVM_ABI PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM)
MustBeExecutedContextPrinterPass(raw_ostream &OS)
LLVM_ABI PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM)
MustExecutePrinterPass(raw_ostream &OS)
PostDominatorTree Class - Concrete subclass of DominatorTree that is used to compute the post-dominat...
A set of analyses that are preserved following a run of a transformation pass.
Definition Analysis.h:112
SimpleLoopSafetyInfo(const Loop *L)
A SetVector that performs no allocations if smaller than a certain size.
Definition SetVector.h:346
An efficient, type-erasing, non-owning reference to a callable.
A range adaptor for a pair of iterators.
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition raw_ostream.h:53
This is an optimization pass for GlobalISel generic memory operations.
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
@ Other
Any other memory.
Definition ModRef.h:68
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
Definition STLExtras.h:1933
AnalysisManager< Function > FunctionAnalysisManager
Convenience typedef for the Function analysis manager.
LLVM_ABI bool mayContainIrreducibleControl(const Function &F, const LoopInfo *LI)
ExplorationDirection
Enum that allows us to spell out the direction.
AnalysisManager< Module > ModuleAnalysisManager
Convenience typedef for the Module analysis manager.
Definition MIRParser.h:39
Implement std::hash so that hash_code can be used in STL containers.
Definition BitVector.h:879
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Definition BitVector.h:881
const bool ExploreInterBlock
Parameter that limit the performed exploration.
const_iterator & begin(const Instruction *PP) const
Return an iterator to explore the cached context around PP.
LLVM_ABI const BasicBlock * findBackwardJoinPoint(const BasicBlock *InitBB)
Find the next join point from InitBB in backward direction.
LLVM_ABI const Instruction * getMustBeExecutedNextInstruction(MustBeExecutedIterator &It, const Instruction *PP)
Return the next instruction that is guaranteed to be executed after PP.
iterator & end()
Return an universal end iterator.
MustBeExecutedContextExplorer(bool ExploreInterBlock, bool ExploreCFGForward, bool ExploreCFGBackward, GetterTy< const LoopInfo > LIGetter=[](const Function &) { return nullptr;}, GetterTy< const DominatorTree > DTGetter=[](const Function &) { return nullptr;}, GetterTy< const PostDominatorTree > PDTGetter=[](const Function &) { return nullptr;})
In the description of the parameters we use PP to denote a program point for which the must be execut...
const_iterator & end() const
iterator & begin(const Instruction *PP)
Return an iterator to explore the context around PP.
LLVM_ABI bool checkForAllTerminatorsInContext(const Instruction *PP, function_ref< bool(const Instruction *)> Pred)
Check Pred on all terminators in the context of PP and return true if it holds for all of them.
llvm::iterator_range< iterator > range(const Instruction *PP)
}
LLVM_ABI bool isInContextOf(const Instruction *I, const Instruction *PP)
}
LLVM_ABI const Instruction * getMustBeExecutedPrevInstruction(MustBeExecutedIterator &It, const Instruction *PP)
Return the previous instr.
LLVM_ABI const BasicBlock * findForwardJoinPoint(const BasicBlock *InitBB)
Find the next join point from InitBB in forward direction.
const_iterator & end(const Instruction *) const
iterator & end(const Instruction *)
llvm::iterator_range< const_iterator > range(const Instruction *PP) const
Return an iterator range to explore the cached context around PP.
const MustBeExecutedIterator const_iterator
MustBeExecutedIterator iterator
Iterator-based interface.
Must be executed iterators visit stretches of instructions that are guaranteed to be executed togethe...
bool operator!=(const MustBeExecutedIterator &Other) const
const Instruction * value_type
Type declarations that make his class an input iterator.
MustBeExecutedIterator(const MustBeExecutedIterator &Other)=default
MustBeExecutedContextExplorer ExplorerTy
}
const Instruction *& reference
const Instruction ** pointer
bool operator==(const MustBeExecutedIterator &Other) const
}
std::input_iterator_tag iterator_category
MustBeExecutedIterator(MustBeExecutedIterator &&Other)
MustBeExecutedIterator & operator=(MustBeExecutedIterator &&Other)
MustBeExecutedIterator operator++(int)
friend struct MustBeExecutedContextExplorer
MustBeExecutedIterator & operator++()
Pre- and post-increment operators.
const Instruction *& operator*()
}
A CRTP mix-in for passes that should not be skipped.