minor cosmetic changes to VC ConstantLoader

---------------------------

Author: aparshin-intel

IGC/VectorCompiler/lib/GenXCodeGen/GenXConstants.cpp

@@ -172,6 +172,7 @@ bool genx::loadNonSimpleConstants(
         continue;
       ConstantLoader CL(C, Subtarget, DL, Inst, AddedInstructions);
       if (CL.needFixingSimple()) {
+        Modified = true;
         CL.fixSimple(i);
         continue;
       }
@@ -773,7 +774,7 @@ bool genx::loadPhiConstants(Function &F, DominatorTree *DT,
         Value *Load = nullptr;
         Instruction *InsertBefore = InsertBB->getTerminator();
         if (!CL.isSimple())
-          Load = CL.loadNonSimple(InsertBefore);
+          Load = CL.loadBig(InsertBefore);
         else
           Load = CL.load(InsertBefore);
         Modified = true;
@@ -852,6 +853,7 @@ bool genx::isReplicatedConstantVector(
 }
 
 void ConstantLoader::fixSimple(int OperandIdx) {
+  IGC_ASSERT_MESSAGE(User, "user must be provided");
   IGC_ASSERT_MESSAGE(NewC, "no need to fix simple case");
   IGC_ASSERT_MESSAGE(User->getOperand(OperandIdx) == C,
     "wrong arguments: wrong operand index was provided");
@@ -870,8 +872,7 @@ void ConstantLoader::fixSimple(int OperandIdx) {
  *
  * Return:  new instruction
  */
-Instruction *ConstantLoader::loadNonSimple(Instruction *Inst)
-{
+Instruction *ConstantLoader::loadNonSimple(Instruction *Inst) {
   IGC_ASSERT(!isSimple());
   if (!isLegalSize())
     return loadBig(Inst);
@@ -1153,8 +1154,7 @@ Instruction *ConstantLoader::loadNonSimple(Instruction *Inst)
  *          maximizing how many of NeededBits are set
  */
 unsigned ConstantLoader::getRegionBits(unsigned NeededBits,
-    unsigned OptionalBits, unsigned VecWidth)
-{
+    unsigned OptionalBits, unsigned VecWidth) {
   if (!NeededBits)
     return 0;
   // Get the first and last element numbers in NeededBits.
@@ -1257,8 +1257,7 @@ Instruction *ConstantLoader::loadSplatConstant(Instruction *InsertPos) {
  *
  * Return:  new instruction
  */
-Instruction *ConstantLoader::load(Instruction *InsertBefore)
-{
+Instruction *ConstantLoader::load(Instruction *InsertBefore) {
   IGC_ASSERT(isSimple());
   // Do not splat load on byte data as HW does not support byte imm source.
   if (!C->getType()->getScalarType()->isIntegerTy(8))
@@ -1335,8 +1334,7 @@ Instruction *ConstantLoader::loadNonPackedIntConst(Instruction *InsertBefore) {
  * ConstantLoader::loadBig : insert instruction to load a constant that might
  *      be illegally sized
  */
-Instruction *ConstantLoader::loadBig(Instruction *InsertBefore)
-{
+Instruction *ConstantLoader::loadBig(Instruction *InsertBefore) {
   if (isLegalSize() || isa<UndefValue>(C)) {
     // Does not need legalizing.
     if (!isSimple())
@@ -1388,12 +1386,11 @@ Instruction *ConstantLoader::loadBig(Instruction *InsertBefore)
 /***********************************************************************
  * ConstantLoader::isLegalSize : detect if a constant is a legal size
  */
-bool ConstantLoader::isLegalSize()
-{
+bool ConstantLoader::isLegalSize() const {
   auto *VT = dyn_cast<IGCLLVM::FixedVectorType>(C->getType());
   if (!VT)
     return true;
-  const int NumBits = DL.getTypeSizeInBits(C->getType());
+  const int NumBits = DL.getTypeSizeInBits(VT);
   if (!llvm::isPowerOf2_32(NumBits))
     return false;
   const int GRFSizeInBits = Subtarget.getGRFByteSize() * genx::ByteBits;
@@ -1411,8 +1408,7 @@ bool ConstantLoader::isLegalSize()
  * This does not do a thorough check so it misses some cases of a constant
  * that would split into simple constants.
  */
-bool ConstantLoader::isBigSimple()
-{
+bool ConstantLoader::isBigSimple() const {
   IGC_ASSERT_MESSAGE(!needFixingSimple(),
     "simple case shall be fixed first before this call");
   if (isa<UndefValue>(C))
@@ -1432,8 +1428,7 @@ bool ConstantLoader::isBigSimple()
  *
  * A simple constant is one we know can be a constant operand in an instruction.
  */
-bool ConstantLoader::isSimple()
-{
+bool ConstantLoader::isSimple() const {
   IGC_ASSERT_MESSAGE(!needFixingSimple(),
     "simple case shall be fixed first before this call");
   if (isa<UndefValue>(C))
@@ -1465,8 +1460,7 @@ bool ConstantLoader::allowI64Ops() const {
  * ConstantLoader::isPackedIntVector : check for a packed int vector
  *    (having already done the analysis in the ConstantLoader constructor)
  */
-bool ConstantLoader::isPackedIntVector()
-{
+bool ConstantLoader::isPackedIntVector() const {
   // Check for a packed int vector. Either the element type must be i16, or
   // the user (instruction using the constant) must be genx.constanti or
   // wrregion or wrconstregion. Not allowed if the user is a logic op.
@@ -1498,7 +1492,7 @@ bool ConstantLoader::isPackedIntVector()
  * ConstantLoader::isPackedFloatVector : check for a packed float vector
  *    (having already done the analysis in the ConstantLoader constructor)
  */
-bool ConstantLoader::isPackedFloatVector() {
+bool ConstantLoader::isPackedFloatVector() const {
   auto *VT = dyn_cast<IGCLLVM::FixedVectorType>(C->getType());
   if (!VT)
     return false;
@@ -1514,8 +1508,7 @@ bool ConstantLoader::isPackedFloatVector() {
  * A "consolidated constant" is one where a vector of byte or short is
  * turned into the equivalent (as if by bitcast) vector of int.
  */
-Constant *ConstantLoader::getConsolidatedConstant(Constant *C)
-{
+Constant *ConstantLoader::getConsolidatedConstant(Constant *C) {
   if (isa<UndefValue>(C))
     return nullptr;
   auto *VT = dyn_cast<IGCLLVM::FixedVectorType>(C->getType());
@@ -1573,8 +1566,7 @@ Constant *ConstantLoader::getConsolidatedConstant(Constant *C)
  * (integer 8 or fp 4) can be loaded as a packed vector, possibly scaled
  * and adjusted.
  */
-void ConstantLoader::analyze()
-{
+void ConstantLoader::analyze() {
   auto *VT = dyn_cast<IGCLLVM::FixedVectorType>(C->getType());
   if (!VT)
     return;
@@ -1593,8 +1585,7 @@ void ConstantLoader::analyze()
     analyzeForPackedFloat(NumElements);
 }
 
-void ConstantLoader::analyzeForPackedInt(unsigned NumElements)
-{
+void ConstantLoader::analyzeForPackedInt(unsigned NumElements) {
   // Get element values.
   int64_t Min = INT64_MAX;
   int64_t Max = INT64_MIN;

IGC/VectorCompiler/lib/GenXCodeGen/GenXConstants.h

@@ -6,8 +6,8 @@ SPDX-License-Identifier: MIT
 
 ============================= end_copyright_notice ===========================*/
 
-#ifndef GENX_CONSTANTS_H
-#define GENX_CONSTANTS_H
+#ifndef LIB_GENXCODEGEN_GENXCONSTANTS_H
+#define LIB_GENXCODEGEN_GENXCONSTANTS_H
 
 #include "GenXSubtarget.h"
 #include "llvm/ADT/SmallVector.h"
@@ -20,6 +20,10 @@ namespace genx {
 
 // ConstantLoader : class to insert instruction(s) to load a constant
 class ConstantLoader {
+  friend bool loadNonSimpleConstants(
+    Instruction *Inst, const GenXSubtarget &Subtarget, const DataLayout &DL,
+    SmallVectorImpl<Instruction *> *AddedInstructions);
+
   Constant *C;
   Instruction *User;
 
@@ -58,27 +62,34 @@ class ConstantLoader {
         AddedInstructions(AddedInstructions) {
     analyze();
   }
+
   Instruction *load(Instruction *InsertBefore);
   Instruction *loadBig(Instruction *InsertBefore);
-  Instruction *loadNonSimple(Instruction *InsertBefore);
-  Instruction *loadNonPackedIntConst(Instruction *InsertBefore);
-  bool needFixingSimple() const { return NewC; }
-  void fixSimple(int OperandIdx);
-  bool isBigSimple();
-  bool isSimple();
-  bool isLegalSize();
+
+  bool isBigSimple() const;
+  bool isSimple() const;
+  bool isLegalSize() const;
 
 private:
   bool allowI64Ops() const;
-  bool isPackedIntVector();
-  bool isPackedFloatVector();
+
   void analyze();
+  void analyzeForPackedInt(unsigned NumElements);
+  void analyzeForPackedFloat(unsigned NumElements);
+
+  bool isPackedIntVector() const;
+  bool isPackedFloatVector() const;
+
   Constant *getConsolidatedConstant(Constant *C);
   unsigned getRegionBits(unsigned NeededBits, unsigned OptionalBits,
                          unsigned VecWidth);
-  void analyzeForPackedInt(unsigned NumElements);
-  void analyzeForPackedFloat(unsigned NumElements);
-  Instruction *loadSplatConstant(Instruction *InsertPos);
+
+  bool needFixingSimple() const { return NewC; }
+  void fixSimple(int OperandIdx);
+
+  Instruction *loadNonSimple(Instruction *InsertBefore);
+  Instruction *loadSplatConstant(Instruction *InsertPt);
+  Instruction *loadNonPackedIntConst(Instruction *InsertPt);
 };
 
 // Some instructions force their operands to be constants.
@@ -134,4 +145,4 @@ bool isReplicatedConstantVector(const ConstantVector *Orig,
 } // namespace genx
 } // namespace llvm
 
-#endif // GENX_CONSTANTS_H
+#endif // LIB_GENXCODEGEN_GENXCONSTANTS_H