Refactor operand alignment check

Author: weiyu-chen

visa/BuildIR.h

@@ -588,11 +588,11 @@ class IR_Builder
 
     //
     // Check if opnd is or can be made "alignByte"-byte aligned.
-    // These functions will change the underlying variable's alignment
-    // (e.g., make a scalar variable GRF-aligned) when possible to satisfy
-    // the alignment
+    // It will change the underlying variable's alignment
+    // (e.g., make a scalar variable GRF-aligned) when possible to satisfy the alignment
     bool isOpndAligned(G4_Operand* opnd, int alignByte) const;
-    bool isOpndAligned(G4_Operand *opnd, unsigned short &offset, int align_byte) const;
+    // Use this version if you want to know the fixed subreg offset for the operand even if it's not aligned.
+    std::tuple<bool, uint16_t> isOpndAlignedTo(G4_Operand *opnd, int align_byte) const;
 
     void setIsKernel(bool value) { isKernel = value; }
     bool getIsKernel() const { return isKernel; }

visa/BuildIRImpl.cpp

@@ -164,10 +164,10 @@ void IR_Builder::bindInputDecl(G4_Declare* dcl, int offset)
 }
 
 // check if an operand is aligned to <align_byte>
-bool IR_Builder::isOpndAligned(
-    G4_Operand *opnd, unsigned short &offset, int align_byte) const
+std::tuple<bool, uint16_t> IR_Builder::isOpndAlignedTo(
+    G4_Operand *opnd, int align_byte) const
 {
-    offset = 0;
+    uint16_t offset = 0;
     bool isAligned = true;
 
     switch (opnd->getKind())
@@ -209,7 +209,7 @@ bool IR_Builder::isOpndAligned(
         }
         if (!isAligned)
         {
-            return isAligned;
+            return std::make_tuple(isAligned, offset);
         }
 
         if (opnd->isDstRegRegion())
@@ -230,7 +230,7 @@ bool IR_Builder::isOpndAligned(
         }
         if (offset % align_byte != 0)
         {
-            return false;
+            return std::make_tuple(false, offset);
         }
         // Only alignment of the top dcl can be changed.
         if (dcl && dcl->getRegFile() == G4_GRF)
@@ -355,14 +355,14 @@ bool IR_Builder::isOpndAligned(
     default:
         break;
     }
-    return isAligned;
+    return std::make_tuple(isAligned, offset);
 }
 
 
 bool IR_Builder::isOpndAligned(G4_Operand* opnd, int alignByte) const
 {
-    uint16_t offset = 0; // ignored
-    return isOpndAligned(opnd, offset, alignByte);
+    auto [isAligned, offset] = isOpndAlignedTo(opnd, alignByte);
+    return isAligned;
 }
 
 

visa/HWConformity.cpp

@@ -1591,8 +1591,8 @@ bool HWConformity::fixDstAlignment(INST_LIST_ITER i, G4_BB* bb, G4_Type extype,
     bool dstHFMixModeInst = inst->getDst()->getType() == builder.getMixModeType() && extype == Type_F;
     bool dstNotAlignedToExecType = exec_size > 1 && (dst_elsize * h_stride) < extypesize &&
         !(builder.hasMixMode() && dstHFMixModeInst);
-    unsigned short dst_byte_offset;
-    builder.isOpndAligned(dst, dst_byte_offset, extypesize);
+
+    auto [isAligned, dst_byte_offset] = builder.isOpndAlignedTo(dst, extypesize);
     if (!((dst_byte_offset % extypesize == 0) ||
         (byteDst &&
         (dst_byte_offset % extypesize == 1))
@@ -4736,8 +4736,7 @@ void HWConformity::fixSendInst(G4_BB* bb)
             }
         }
 
-        uint16_t offset = 0;
-        if (!builder.isOpndAligned(inst->getDst(), offset, numEltPerGRF(Type_UB)))
+        if (!builder.isOpndAligned(inst->getDst(), numEltPerGRF(Type_UB)))
         {
             replaceDst(i, inst->getDst()->getType(), GRFALIGN);
         }

visa/ReduceExecSize.cpp

@@ -452,10 +452,8 @@ bool HWConformity::reduceExecSize(INST_LIST_ITER iter, G4_BB* bb)
                             if (dstRegionSize <= 16)
                             {
                                 // see if we can make the dst fit in one oword
-                                unsigned short dstOffset = 0;
-                                bool dstOwordAligned = false;
                                 int dstAlign = Round_Up_Pow2(dstRegionSize);
-                                dstOwordAligned = builder.isOpndAligned(dst, dstOffset, dstAlign);
+                                auto [dstOwordAligned, dstOffset] = builder.isOpndAlignedTo(dst, dstAlign);
                                 if (!dstOwordAligned)
                                 {
                                     // If we can align dst to its size, it must fit in one OWord
@@ -467,7 +465,7 @@ bool HWConformity::reduceExecSize(INST_LIST_ITER iter, G4_BB* bb)
                                         // technically if dst and src are both evenly split the instruction is
                                         // still ok, but this case should be rare so we ignore it
                                         G4_DstRegRegion* newDst = insertMovAfter(iter, dst, dst->getType(), bb);
-                                        bool alignTmpDst = builder.isOpndAligned(newDst, dstOffset, 16);
+                                        bool alignTmpDst = builder.isOpndAligned(newDst, 16);
                                         MUST_BE_TRUE(alignTmpDst, "must be able to oword align tmp dst");
                                         inst->setDest(newDst);
                                         return true;