Lines Matching defs:VPlan
1 //===- VPlan.h - Represent A Vectorizer Plan --------------------*- C++ -*-===//
19 /// 5. The VPlan class holding a candidate for vectorization;
65 class VPlan;
145 using VPlanPtr = std::unique_ptr<VPlan>;
229 /// VPTransformState holds information passed down when "executing" a VPlan,
234 InnerLoopVectorizer *ILV, VPlan *Plan,
369 /// Pointer to the VPlan code is generated for.
370 VPlan *Plan;
386 /// VPlan-based type analysis.
410 /// VPlan containing the block. Can only be set on the entry block of the
412 VPlan *Plan = nullptr;
488 VPlan *getPlan();
489 const VPlan *getPlan() const;
492 /// entry block into the VPlan.
493 void setPlan(VPlan *ParentPlan);
629 /// VPBlockBase, thereby "executing" the VPlan.
651 /// Note that the numbering is applied to the whole VPlan, so printing
652 /// individual blocks is consistent with the whole VPlan printing.
656 /// Print plain-text dump of this VPlan to \p O.
693 /// fallback until computing the cost of all recipes migrates to VPlan.
740 /// this VPRecipe, thereby "executing" the VPlan.
1184 /// This is a concrete Recipe that models a single VPlan-level instruction.
1193 /// VPlan opcodes, extending LLVM IR with idiomatics instructions.
1203 /// Creates a scalar phi in a leaf VPBB with a single predecessor in VPlan.
1204 /// The first operand is the incoming value from the predecessor in VPlan,
1206 /// (which are currently not modeled in VPlan).
1730 /// different VPlan for each VF with a valid variant.
2306 /// In the VPlan native path, all incoming VPValues & VPBasicBlock pairs are
2309 /// List of incoming blocks. Only used in the VPlan native path.
3542 friend class VPlan;
3544 /// Use VPlan::createVPBasicBlock to create VPBasicBlocks.
3609 assert(!Recipe->Parent && "Recipe already in VPlan");
3619 /// this VPBasicBlock, thereby "executing" the VPlan.
3645 /// Note that the numbering is applied to the whole VPlan, so printing
3646 /// individual blocks is consistent with the whole VPlan printing.
3668 /// Connect the VPBBs predecessors' in the VPlan CFG to the IR basic block
3681 /// Note: At the moment, VPIRBasicBlock can only be used to wrap VPlan's
3684 friend class VPlan;
3688 /// Use VPlan::createVPIRBasicBlock to create VPIRBasicBlocks.
3702 /// this VPBasicBlock, thereby "executing" the VPlan.
3719 friend class VPlan;
3732 /// Use VPlan::createVPRegionBlock to create VPRegionBlocks.
3789 /// this VPRegionBlock, thereby "executing" the VPlan.
3800 /// Note that the numbering is applied to the whole VPlan, so printing
3801 /// individual regions is consistent with the whole VPlan printing.
3812 /// VPlan models a candidate for vectorization, encoding various decisions take
3814 /// output IR instructions to generate, and their cost. VPlan holds a
3817 class VPlan {
3823 /// rest of VPlan execution.
3824 /// When this VPlan is used for the epilogue vector loop, the entry will be
3831 /// Holds the VFs applicable to this VPlan.
3834 /// Holds the UFs applicable to this VPlan. If empty, the VPlan is valid for
3838 /// Holds the name of the VPlan, for printing.
3859 /// VPlan.
3862 /// Contains all the external definitions created for this VPlan. External
3868 /// been modeled in VPlan directly.
3871 /// Blocks allocated and owned by the VPlan. They will be deleted once the
3872 /// VPlan is destroyed.
3875 /// Construct a VPlan with \p Entry to the plan and with \p ScalarHeader
3877 VPlan(VPBasicBlock *Entry, VPIRBasicBlock *ScalarHeader)
3885 /// Construct a VPlan for \p L. This will create VPIRBasicBlocks wrapping the
3887 /// scalar header blocks of the new VPlan.
3888 VPlan(Loop *L);
3890 /// Construct a VPlan with a new VPBasicBlock as entry, a VPIRBasicBlock
3892 VPlan(BasicBlock *ScalarHeaderBB, VPValue *TC) {
3898 ~VPlan();
3905 /// Create initial VPlan, having an "entry" VPBasicBlock (wrapping
3907 /// to happen before the CFG is modified (when executing a VPlan for the
3924 /// Generate the IR code for this VPlan.
3965 /// of the VPlan, that is leaf nodes except the scalar header. Defined in
3976 /// Resets the trip count for the VPlan. The caller must make sure all uses of
4047 assert(!Value2VPValue.count(V) && "Value already exists in VPlan");
4051 assert(Value2VPValue.count(V) && "Value does not exist in VPlan");
4061 /// Print the live-ins of this VPlan to \p O.
4064 /// Print this VPlan to \p O.
4067 /// Print this VPlan in DOT format to \p O.
4078 // VPlan native path.
4093 /// Clone the current VPlan, update all VPValues of the new VPlan and cloned
4095 VPlan *duplicate();
4098 /// present. The returned block is owned by the VPlan and deleted once the
4099 /// VPlan is destroyed.
4109 /// is owned by the VPlan and deleted once the VPlan is destroyed.
4120 /// The returned block is owned by the VPlan and deleted once the VPlan is
4131 /// block is owned by the VPlan and deleted once the VPlan is destroyed.
4136 /// successors of the block in VPlan. The returned block is owned by the VPlan
4137 /// and deleted once the VPlan is destroyed.
4142 /// VPlanPrinter prints a given VPlan to a given output stream. The printing is
4146 const VPlan &Plan;
4185 VPlanPrinter(raw_ostream &O, const VPlan &P)
4204 inline raw_ostream &operator<<(raw_ostream &OS, const VPlan &Plan) {
4219 /// Recursively \p Region and populate VPlan based interleave groups based on
4223 /// Recursively traverse \p Block and populate VPlan based interleave groups
4229 VPInterleavedAccessInfo(VPlan &Plan, InterleavedAccessInfo &IAI);
4249 /// Class that maps (parts of) an existing VPlan to trees of combined
4275 /// Mapping of values in the original VPlan to a combined VPInstruction.