XXX: Manual unittest

Author: tstellar

llvm/lib/Transforms/Vectorize/VPlan.h

@@ -493,26 +493,26 @@ class VPBlockBase {
   const VPRegionBlock *getParent() const { return Parent; }
 
   /// \return A pointer to the plan containing the current block.
-  VPlan *getPlan();
+  LLVM_FUNC_ABI VPlan *getPlan();
   const VPlan *getPlan() const;
 
   /// Sets the pointer of the plan containing the block. The block must be the
   /// entry block into the VPlan.
-  void setPlan(VPlan *ParentPlan);
+  LLVM_FUNC_ABI void setPlan(VPlan *ParentPlan);
 
   void setParent(VPRegionBlock *P) { Parent = P; }
 
   /// \return the VPBasicBlock that is the entry of this VPBlockBase,
   /// recursively, if the latter is a VPRegionBlock. Otherwise, if this
   /// VPBlockBase is a VPBasicBlock, it is returned.
   const VPBasicBlock *getEntryBasicBlock() const;
-  VPBasicBlock *getEntryBasicBlock();
+  LLVM_FUNC_ABI VPBasicBlock *getEntryBasicBlock();
 
   /// \return the VPBasicBlock that is the exiting this VPBlockBase,
   /// recursively, if the latter is a VPRegionBlock. Otherwise, if this
   /// VPBlockBase is a VPBasicBlock, it is returned.
   const VPBasicBlock *getExitingBasicBlock() const;
-  VPBasicBlock *getExitingBasicBlock();
+  LLVM_FUNC_ABI VPBasicBlock *getExitingBasicBlock();
 
   const VPBlocksTy &getSuccessors() const { return Successors; }
   VPBlocksTy &getSuccessors() { return Successors; }
@@ -735,7 +735,7 @@ class VPRecipeBase : public ilist_node_with_parent<VPRecipeBase, VPBasicBlock>,
 
   /// Insert an unlinked recipe into a basic block immediately before
   /// the specified recipe.
-  void insertBefore(VPRecipeBase *InsertPos);
+  LLVM_FUNC_ABI void insertBefore(VPRecipeBase *InsertPos);
   /// Insert an unlinked recipe into \p BB immediately before the insertion
   /// point \p IP;
   void insertBefore(VPBasicBlock &BB, iplist<VPRecipeBase>::iterator IP);
@@ -746,12 +746,12 @@ class VPRecipeBase : public ilist_node_with_parent<VPRecipeBase, VPBasicBlock>,
 
   /// Unlink this recipe from its current VPBasicBlock and insert it into
   /// the VPBasicBlock that MovePos lives in, right after MovePos.
-  void moveAfter(VPRecipeBase *MovePos);
+  LLVM_FUNC_ABI void moveAfter(VPRecipeBase *MovePos);
 
   /// Unlink this recipe and insert into BB before I.
   ///
   /// \pre I is a valid iterator into BB.
-  void moveBefore(VPBasicBlock &BB, iplist<VPRecipeBase>::iterator I);
+  LLVM_FUNC_ABI void moveBefore(VPBasicBlock &BB, iplist<VPRecipeBase>::iterator I);
 
   /// This method unlinks 'this' from the containing basic block, but does not
   /// delete it.
@@ -760,7 +760,7 @@ class VPRecipeBase : public ilist_node_with_parent<VPRecipeBase, VPBasicBlock>,
   /// This method unlinks 'this' from the containing basic block and deletes it.
   ///
   /// \returns an iterator pointing to the element after the erased one
-  iplist<VPRecipeBase>::iterator eraseFromParent();
+  LLVM_FUNC_ABI iplist<VPRecipeBase>::iterator eraseFromParent();
 
   /// Returns the underlying instruction, if the recipe is a VPValue or nullptr
   /// otherwise.
@@ -782,18 +782,18 @@ class VPRecipeBase : public ilist_node_with_parent<VPRecipeBase, VPBasicBlock>,
   }
 
   /// Returns true if the recipe may have side-effects.
-  bool mayHaveSideEffects() const;
+  LLVM_FUNC_ABI bool mayHaveSideEffects() const;
 
   /// Returns true for PHI-like recipes.
   bool isPhi() const {
     return getVPDefID() >= VPFirstPHISC && getVPDefID() <= VPLastPHISC;
   }
 
   /// Returns true if the recipe may read from memory.
-  bool mayReadFromMemory() const;
+  LLVM_FUNC_ABI bool mayReadFromMemory() const;
 
   /// Returns true if the recipe may write to memory.
-  bool mayWriteToMemory() const;
+  LLVM_FUNC_ABI bool mayWriteToMemory() const;
 
   /// Returns true if the recipe may read from or write to memory.
   bool mayReadOrWriteMemory() const {
@@ -856,7 +856,7 @@ class VPRecipeWithIRFlags : public VPRecipeBase {
     char AllowContract : 1;
     char ApproxFunc : 1;
 
-    FastMathFlagsTy(const FastMathFlags &FMF);
+    LLVM_FUNC_ABI FastMathFlagsTy(const FastMathFlags &FMF);
   };
 
   OperationType OpType;
@@ -1015,7 +1015,7 @@ class VPRecipeWithIRFlags : public VPRecipeBase {
 /// While as any Recipe it may generate a sequence of IR instructions when
 /// executed, these instructions would always form a single-def expression as
 /// the VPInstruction is also a single def-use vertex.
-class VPInstruction : public VPRecipeWithIRFlags, public VPValue {
+class LLVM_CLASS_ABI VPInstruction : public VPRecipeWithIRFlags, public VPValue {
   friend class VPlanSlp;
 
 public:
@@ -1151,7 +1151,7 @@ class VPInstruction : public VPRecipeWithIRFlags, public VPValue {
 /// VPWidenRecipe is a recipe for producing a copy of vector type its
 /// ingredient. This recipe covers most of the traditional vectorization cases
 /// where each ingredient transforms into a vectorized version of itself.
-class VPWidenRecipe : public VPRecipeWithIRFlags, public VPValue {
+class LLVM_CLASS_ABI VPWidenRecipe : public VPRecipeWithIRFlags, public VPValue {
   unsigned Opcode;
 
 public:
@@ -1213,7 +1213,7 @@ class VPWidenCastRecipe : public VPRecipeBase, public VPValue {
 };
 
 /// A recipe for widening Call instructions.
-class VPWidenCallRecipe : public VPRecipeBase, public VPValue {
+class LLVM_CLASS_ABI VPWidenCallRecipe : public VPRecipeBase, public VPValue {
   /// ID of the vector intrinsic to call when widening the call. If set the
   /// Intrinsic::not_intrinsic, a library call will be used instead.
   Intrinsic::ID VectorIntrinsicID;
@@ -1246,7 +1246,7 @@ class VPWidenCallRecipe : public VPRecipeBase, public VPValue {
 };
 
 /// A recipe for widening select instructions.
-struct VPWidenSelectRecipe : public VPRecipeBase, public VPValue {
+struct LLVM_CLASS_ABI VPWidenSelectRecipe : public VPRecipeBase, public VPValue {
   template <typename IterT>
   VPWidenSelectRecipe(SelectInst &I, iterator_range<IterT> Operands)
       : VPRecipeBase(VPDef::VPWidenSelectSC, Operands, I.getDebugLoc()),
@@ -1275,7 +1275,7 @@ struct VPWidenSelectRecipe : public VPRecipeBase, public VPValue {
 };
 
 /// A recipe for handling GEP instructions.
-class VPWidenGEPRecipe : public VPRecipeWithIRFlags, public VPValue {
+class LLVM_CLASS_ABI VPWidenGEPRecipe : public VPRecipeWithIRFlags, public VPValue {
   bool isPointerLoopInvariant() const {
     return getOperand(0)->isDefinedOutsideVectorRegions();
   }
@@ -1618,7 +1618,7 @@ class VPReductionPHIRecipe : public VPHeaderPHIRecipe {
 
 /// A recipe for vectorizing a phi-node as a sequence of mask-based select
 /// instructions.
-class VPBlendRecipe : public VPRecipeBase, public VPValue {
+class LLVM_CLASS_ABI VPBlendRecipe : public VPRecipeBase, public VPValue {
 public:
   /// The blend operation is a User of the incoming values and of their
   /// respective masks, ordered [I0, M0, I1, M1, ...]. Note that a single value
@@ -1668,7 +1668,7 @@ class VPBlendRecipe : public VPRecipeBase, public VPValue {
 /// or stores into one wide load/store and shuffles. The first operand of a
 /// VPInterleave recipe is the address, followed by the stored values, followed
 /// by an optional mask.
-class VPInterleaveRecipe : public VPRecipeBase {
+class LLVM_CLASS_ABI VPInterleaveRecipe : public VPRecipeBase {
   const InterleaveGroup<Instruction> *IG;
 
   /// Indicates if the interleave group is in a conditional block and requires a
@@ -1752,7 +1752,7 @@ class VPInterleaveRecipe : public VPRecipeBase {
 /// A recipe to represent inloop reduction operations, performing a reduction on
 /// a vector operand into a scalar value, and adding the result to a chain.
 /// The Operands are {ChainOp, VecOp, [Condition]}.
-class VPReductionRecipe : public VPRecipeBase, public VPValue {
+class LLVM_CLASS_ABI VPReductionRecipe : public VPRecipeBase, public VPValue {
   /// The recurrence decriptor for the reduction in question.
   const RecurrenceDescriptor &RdxDesc;
 
@@ -1792,7 +1792,7 @@ class VPReductionRecipe : public VPRecipeBase, public VPValue {
 /// copies of the original scalar type, one per lane, instead of producing a
 /// single copy of widened type for all lanes. If the instruction is known to be
 /// uniform only one copy, per lane zero, will be generated.
-class VPReplicateRecipe : public VPRecipeWithIRFlags, public VPValue {
+class LLVM_CLASS_ABI VPReplicateRecipe : public VPRecipeWithIRFlags, public VPValue {
   /// Indicator if only a single replica per lane is needed.
   bool IsUniform;
 
@@ -1855,7 +1855,7 @@ class VPReplicateRecipe : public VPRecipeWithIRFlags, public VPValue {
 };
 
 /// A recipe for generating conditional branches on the bits of a mask.
-class VPBranchOnMaskRecipe : public VPRecipeBase {
+class LLVM_CLASS_ABI VPBranchOnMaskRecipe : public VPRecipeBase {
 public:
   VPBranchOnMaskRecipe(VPValue *BlockInMask)
       : VPRecipeBase(VPDef::VPBranchOnMaskSC, {}) {
@@ -1902,7 +1902,7 @@ class VPBranchOnMaskRecipe : public VPRecipeBase {
 /// order to merge values that are set under such a branch and feed their uses.
 /// The phi nodes can be scalar or vector depending on the users of the value.
 /// This recipe works in concert with VPBranchOnMaskRecipe.
-class VPPredInstPHIRecipe : public VPRecipeBase, public VPValue {
+class LLVM_CLASS_ABI VPPredInstPHIRecipe : public VPRecipeBase, public VPValue {
 public:
   /// Construct a VPPredInstPHIRecipe given \p PredInst whose value needs a phi
   /// nodes after merging back from a Branch-on-Mask.
@@ -1935,7 +1935,7 @@ class VPPredInstPHIRecipe : public VPRecipeBase, public VPValue {
 /// - For store: Address, stored value, optional mask
 /// TODO: We currently execute only per-part unless a specific instance is
 /// provided.
-class VPWidenMemoryInstructionRecipe : public VPRecipeBase {
+class LLVM_CLASS_ABI VPWidenMemoryInstructionRecipe : public VPRecipeBase {
   Instruction &Ingredient;
 
   // Whether the loaded-from / stored-to addresses are consecutive.
@@ -2057,7 +2057,7 @@ class VPExpandSCEVRecipe : public VPRecipeBase, public VPValue {
 /// start value (either 0 or the resume value when vectorizing the epilogue
 /// loop). VPWidenCanonicalIVRecipe represents the vector version of the
 /// canonical induction variable.
-class VPCanonicalIVPHIRecipe : public VPHeaderPHIRecipe {
+class LLVM_CLASS_ABI VPCanonicalIVPHIRecipe : public VPHeaderPHIRecipe {
 public:
   VPCanonicalIVPHIRecipe(VPValue *StartV, DebugLoc DL)
       : VPHeaderPHIRecipe(VPDef::VPCanonicalIVPHISC, nullptr, StartV, DL) {}
@@ -2206,7 +2206,7 @@ class VPDerivedIVRecipe : public VPRecipeBase, public VPValue {
 
 /// A recipe for handling phi nodes of integer and floating-point inductions,
 /// producing their scalar values.
-class VPScalarIVStepsRecipe : public VPRecipeWithIRFlags, public VPValue {
+class LLVM_CLASS_ABI VPScalarIVStepsRecipe : public VPRecipeWithIRFlags, public VPValue {
   Instruction::BinaryOps InductionOpcode;
 
 public:
@@ -2250,7 +2250,7 @@ class VPScalarIVStepsRecipe : public VPRecipeWithIRFlags, public VPValue {
 /// VPBasicBlock serves as the leaf of the Hierarchical Control-Flow Graph. It
 /// holds a sequence of zero or more VPRecipe's each representing a sequence of
 /// output IR instructions. All PHI-like recipes must come before any non-PHI recipes.
-class VPBasicBlock : public VPBlockBase {
+class LLVM_CLASS_ABI VPBasicBlock : public VPBlockBase {
 public:
   using RecipeListTy = iplist<VPRecipeBase>;
 
@@ -2374,7 +2374,7 @@ class VPBasicBlock : public VPBlockBase {
 /// this replication indicator helps to keep a single model for multiple
 /// candidate VF's. The actual replication takes place only once the desired VF
 /// and UF have been determined.
-class VPRegionBlock : public VPBlockBase {
+class LLVM_CLASS_ABI VPRegionBlock : public VPBlockBase {
   /// Hold the Single Entry of the SESE region modelled by the VPRegionBlock.
   VPBlockBase *Entry;
 
@@ -2548,11 +2548,11 @@ class VPlan {
            "preheader must be disconnected");
   }
 
-  ~VPlan();
+  LLVM_FUNC_ABI ~VPlan();
 
   /// Create an initial VPlan with preheader and entry blocks. Creates a
   /// VPExpandSCEVRecipe for \p TripCount and uses it as plan's trip count.
-  static VPlanPtr createInitialVPlan(const SCEV *TripCount,
+  LLVM_FUNC_ABI static VPlanPtr createInitialVPlan(const SCEV *TripCount,
                                      ScalarEvolution &PSE);
 
   /// Prepare the plan for execution, setting up the required live-in values.
@@ -2889,7 +2889,7 @@ class VPInterleavedAccessInfo {
                   InterleavedAccessInfo &IAI);
 
 public:
-  VPInterleavedAccessInfo(VPlan &Plan, InterleavedAccessInfo &IAI);
+  LLVM_FUNC_ABI VPInterleavedAccessInfo(VPlan &Plan, InterleavedAccessInfo &IAI);
 
   ~VPInterleavedAccessInfo() {
     SmallPtrSet<InterleaveGroup<VPInstruction> *, 4> DelSet;
@@ -2995,7 +2995,7 @@ class VPlanSlp {
 
   /// Tries to build an SLP tree rooted at \p Operands and returns a
   /// VPInstruction combining \p Operands, if they can be combined.
-  VPInstruction *buildGraph(ArrayRef<VPValue *> Operands);
+  LLVM_FUNC_ABI VPInstruction *buildGraph(ArrayRef<VPValue *> Operands);
 
   /// Return the width of the widest combined bundle in bits.
   unsigned getWidestBundleBits() const { return WidestBundleBits; }

llvm/lib/Transforms/Vectorize/VPlanHCFGBuilder.h

@@ -65,7 +65,7 @@ class VPlanHCFGBuilder {
       : TheLoop(Lp), LI(LI), Plan(P) {}
 
   /// Build H-CFG for TheLoop and update Plan accordingly.
-  void buildHierarchicalCFG();
+  LLVM_FUNC_ABI void buildHierarchicalCFG();
 };
 } // namespace llvm
 

llvm/lib/Transforms/Vectorize/VPlanTransforms.h

@@ -31,7 +31,7 @@ class VPRecipeBuilder;
 struct VPlanTransforms {
   /// Replaces the VPInstructions in \p Plan with corresponding
   /// widen recipes.
-  static void
+  LLVM_FUNC_ABI static void
   VPInstructionsToVPRecipes(VPlanPtr &Plan,
                             function_ref<const InductionDescriptor *(PHINode *)>
                                 GetIntOrFpInductionDescriptor,

llvm/lib/Transforms/Vectorize/VPlanValue.h

@@ -64,7 +64,7 @@ class VPValue {
   /// VPValue is not defined by any recipe modeled in VPlan.
   VPDef *Def;
 
-  VPValue(const unsigned char SC, Value *UV = nullptr, VPDef *Def = nullptr);
+  LLVM_FUNC_ABI VPValue(const unsigned char SC, Value *UV = nullptr, VPDef *Def = nullptr);
 
   // DESIGN PRINCIPLE: Access to the underlying IR must be strictly limited to
   // the front-end and back-end of VPlan so that the middle-end is as
@@ -101,7 +101,7 @@ class VPValue {
   VPValue(const VPValue &) = delete;
   VPValue &operator=(const VPValue &) = delete;
 
-  virtual ~VPValue();
+  LLVM_FUNC_ABI virtual ~VPValue();
 
   /// \return an ID for the concrete type of this object.
   /// This is used to implement the classof checks. This should not be used
@@ -161,11 +161,11 @@ class VPValue {
     return Current != user_end();
   }
 
-  void replaceAllUsesWith(VPValue *New);
+  LLVM_FUNC_ABI void replaceAllUsesWith(VPValue *New);
 
   /// Returns the recipe defining this VPValue or nullptr if it is not defined
   /// by a recipe, i.e. is a live-in.
-  VPRecipeBase *getDefiningRecipe();
+  LLVM_FUNC_ABI VPRecipeBase *getDefiningRecipe();
   const VPRecipeBase *getDefiningRecipe() const;
 
   /// Returns true if this VPValue is defined by a recipe.

llvm/lib/Transforms/Vectorize/VPlanVerifier.h

@@ -24,6 +24,8 @@
 #ifndef LLVM_TRANSFORMS_VECTORIZE_VPLANVERIFIER_H
 #define LLVM_TRANSFORMS_VECTORIZE_VPLANVERIFIER_H
 
+#include "llvm/Support/Compiler.h"
+
 namespace llvm {
 class VPRegionBlock;
 class VPlan;
@@ -41,7 +43,7 @@ struct VPlanVerifier {
   /// 1. all phi-like recipes must be at the beginning of a block, with no other
   /// recipes in between. Note that currently there is still an exception for
   /// VPBlendRecipes.
-  static bool verifyPlanIsValid(const VPlan &Plan);
+  LLVM_FUNC_ABI static bool verifyPlanIsValid(const VPlan &Plan);
 };
 } // namespace llvm