As a rotate is matched in a pass via llvm funnel shift, the matchRotate()

in PatternMatch is no longer needed.

This change remove matchRotate() from PatternMatch not should not have
any functional change.

Author: jgu222

IGC/Compiler/CISACodeGen/PatternMatchPass.cpp

@@ -846,9 +846,7 @@ namespace IGC
         }
         else if (I.getOpcode() == Instruction::Trunc)
         {
-            match =
-                MatchRotate(I) ||
-                MatchModifier(I);
+            match = MatchModifier(I);
         }
         else
         {
@@ -1025,7 +1023,6 @@ namespace IGC
         case Instruction::Or:
             match =
                 MatchBoolOp(I) ||
-                MatchRotate(I) ||
                 MatchLogicAlu(I);
             break;
         case Instruction::Xor:
@@ -3542,231 +3539,6 @@ namespace IGC
         return found;
     }
 
-    //
-    //  Assume that V is of type T (integer) with N bits;
-    //  and amt is of integer type too.
-    //
-    //  rol (V, amt) =  (V << amt) | ((unsigned(V) >> (N - amt))
-    //    The function first finds the following generic pattern, note that
-    //    [insts] denotes that "insts" are optional.
-    //          [amt = and amt, N-1]
-    //          high = shl V0, amt
-    //          [amt0 = sub 0, amt  || amt0 = sub N, amt]
-    //                ; if amt is constant && amt + amt0 == N, this is unneeded
-    //          [amt0 = and amt0, N-1]
-    //          low = lshr V1, amt0
-    //          R = or high, low
-    //
-    //      case 0: [ likely, V is i32 or i64]
-    //          V0 == V1 (V == V0 == V1)
-    //
-    //      case 1:  [ likely V is i16 or i8]
-    //          V0 = sext V || zext V
-    //          V1 = zext V
-    //          Res = trunc R
-    //
-    //          Res's type == V's type
-    //
-    //  ror can be handled similarly. Note that
-    //    ror (x, amt) = ((unsigned)x >> amt) | ( x << (N - amt))
-    //                 = rol (x, N - amt);
-    //
-    bool CodeGenPatternMatch::MatchRotate(llvm::Instruction& I)
-    {
-        using namespace llvm::PatternMatch;
-
-        struct RotatePattern : public Pattern
-        {
-            SSource sources[2];
-            e_opcode rotateOPCode;
-            llvm::Instruction* instruction;
-            virtual void Emit(EmitPass* pass, const DstModifier& modifier)
-            {
-                pass->Binary(rotateOPCode, sources, modifier);
-            }
-        };
-
-        if (!m_Platform.supportRotateInstruction())
-        {
-            return false;
-        }
-
-        // Sanity check:
-        //   make sure that rotate is supported and "I" is a scalar "or" instruction
-        IGC_ASSERT_MESSAGE(false == I.getType()->isVectorTy(), "Vector type not expected here");
-
-        uint64_t typeWidth = I.getType()->getScalarSizeInBits();
-        Instruction* OrInst = nullptr;
-        if (I.getOpcode() == Instruction::Trunc)
-        {
-            if (BinaryOperator * tmp = dyn_cast<BinaryOperator>(I.getOperand(0)))
-            {
-                if (tmp->getOpcode() != Instruction::Or)
-                {
-                    return false;
-                }
-                OrInst = tmp;
-            }
-            else
-            {
-                return false;
-            }
-        }
-        else if (I.getOpcode() == Instruction::Or)
-        {
-            OrInst = cast<BinaryOperator>(&I);
-        }
-        else
-        {
-            IGC_ASSERT_MESSAGE(0, "Should be invoked with Or/Trunc instruction");
-        }
-
-        // Do rotate only if
-        //   1) type is W/DW (HW only supports W/DW); and
-        //   2) both operands are instructions.
-        Instruction* LHS = dyn_cast<Instruction>(OrInst->getOperand(0));
-        Instruction* RHS = dyn_cast<Instruction>(OrInst->getOperand(1));
-        bool typeWidthSupported = typeWidth == 16 || typeWidth == 32;
-
-        if (!LHS || !RHS || !typeWidthSupported)
-        {
-            return false;
-        }
-
-        // Make adjustment so that LHS is shl.
-        if (LHS->getOpcode() == Instruction::LShr)
-        {
-            Instruction* t = LHS;
-            LHS = RHS;
-            RHS = t;
-        }
-        if (LHS->getOpcode() != Instruction::Shl ||
-            RHS->getOpcode() != Instruction::LShr)
-        {
-            return false;
-        }
-
-        // first: find V
-        Value* V0 = LHS->getOperand(0);
-        Value* V1 = RHS->getOperand(0);
-        Value* V = nullptr;
-        if (I.getOpcode() == Instruction::Or)
-        {
-            if (V0 == V1)
-            {
-                V = V0;
-            }
-        }
-        else
-        {
-            Value* X0, * X1;
-            if ((match(V0, m_ZExt(m_Value(X0))) || match(V0, m_SExt(m_Value(X0)))) &&
-                match(V1, m_ZExt(m_Value(X1))))
-            {
-                if (X0 == X1 && X0->getType()->getScalarSizeInBits() == typeWidth)
-                {
-                    V = X0;
-                }
-            }
-        }
-
-        if (!V)
-        {
-            return false;
-        }
-
-        // Second: find amt
-        uint64_t typeMask = typeWidth - 1;
-        Value* LAmt = LHS->getOperand(1);
-        Value* RAmt = RHS->getOperand(1);
-        ConstantInt* C_LAmt = dyn_cast<ConstantInt>(LAmt);
-        ConstantInt* C_RAmt = dyn_cast<ConstantInt>(RAmt);
-        Value* X0, * X1;
-        Value* Amt = nullptr;
-        bool isROL = true;
-        if (C_LAmt || C_RAmt)
-        {
-            // If only one of shift-amounts is constant, it cannot be rotate.
-            if (C_LAmt && C_RAmt)
-            {
-                // For shift amount that is beyond the typewidth, the result is
-                // undefined. Here, we just use the LSB.
-                uint64_t c0 = C_LAmt->getZExtValue() & typeMask;
-                uint64_t c1 = C_RAmt->getZExtValue() & typeMask;
-                if ((c0 + c1) == typeWidth)
-                {
-                    Amt = LAmt;
-                    isROL = true;
-                }
-            }
-        }
-        else
-        {
-            if (match(RAmt, m_And(m_Sub(m_Zero(), m_Value(X1)), m_SpecificInt(typeMask))) ||
-                match(RAmt, m_And(m_Sub(m_SpecificInt(typeWidth), m_Value(X1)), m_SpecificInt(typeMask))) ||
-                match(RAmt, m_Sub(m_Zero(), m_Value(X1))) ||
-                match(RAmt, m_Sub(m_SpecificInt(typeWidth), m_Value(X1))))
-            {
-                if (LAmt == X1 ||
-                    (match(LAmt, m_And(m_Value(X0), m_SpecificInt(typeMask))) && (X1 == X0)))
-                {
-                    Amt = X1;
-                    isROL = true;
-                }
-            }
-            if (!Amt &&
-                (match(LAmt, m_And(m_Sub(m_Zero(), m_Value(X1)), m_SpecificInt(typeMask))) ||
-                    match(LAmt, m_And(m_Sub(m_SpecificInt(typeWidth), m_Value(X1)), m_SpecificInt(typeMask))) ||
-                    match(LAmt, m_Sub(m_Zero(), m_Value(X1))) ||
-                    match(LAmt, m_Sub(m_SpecificInt(typeWidth), m_Value(X1)))))
-            {
-                if (RAmt == X1 ||
-                    (match(RAmt, m_And(m_Value(X0), m_SpecificInt(typeMask))) && (X1 == X0)))
-                {
-                    Amt = X1;
-                    isROL = false;
-                }
-            }
-
-            if (Amt)
-            {
-                Value* X0, * X1, * X2;
-                // 1) simple case: amt = 32 - X0;   use amt1 as shift amount.
-                bool isReverse = match(Amt, m_Sub(m_SpecificInt(typeWidth), m_Value(X0)));
-
-                // 2)   t = 16 - X0 | t = 0 - X0   ; for example,  t is i16/i8, etc
-                //      t1 = t & 15
-                //      amt = zext t1, i32
-                isReverse = isReverse ||
-                    (match(Amt, m_ZExt(m_Value(X1))) &&
-                        match(X1, m_And(m_Value(X2), m_SpecificInt(typeMask))) &&
-                        (match(X2, m_Sub(m_SpecificInt(typeWidth), m_Value(X0))) ||
-                            match(X2, m_Sub(m_Zero(), m_Value(X0)))));
-
-                if (isReverse)
-                {
-                    Amt = X0;
-                    isROL = !isROL;
-                }
-            }
-        }
-
-        if (!Amt)
-        {
-            return false;
-        }
-
-        // Found the pattern.
-        RotatePattern* pattern = new (m_allocator) RotatePattern();
-        pattern->instruction = &I;
-        pattern->sources[0] = GetSource(V, true, false);
-        pattern->sources[1] = GetSource(Amt, true, false);
-        pattern->rotateOPCode = isROL ? EOPCODE_ROL : EOPCODE_ROR;
-
-        AddPattern(pattern);
-        return true;
-    }
-
     bool CodeGenPatternMatch::MatchFunnelShiftRotate(llvm::IntrinsicInst& I)
     {
         // Hanlde only funnel shift that can be turned into rotate.

IGC/Compiler/CISACodeGen/PatternMatchPass.hpp

@@ -211,7 +211,6 @@ namespace IGC
         bool MatchPow(llvm::IntrinsicInst& I);
         bool MatchCondModifier(llvm::CmpInst& I);
         bool MatchBoolOp(llvm::BinaryOperator& I);
-        bool MatchRotate(llvm::Instruction& I);
         bool MatchFunnelShiftRotate(llvm::IntrinsicInst& I);
         bool MatchDp4a(llvm::GenIntrinsicInst& I);
         bool MatchLogicAlu(llvm::BinaryOperator& I);