Using cloneInstWithNewOps instead of switch in GenXVectorCombiner

Author: itetyush-intel

IGC/VectorCompiler/include/vc/Utils/General/Types.h

@@ -32,6 +32,12 @@ llvm::Type *changeAddrSpace(llvm::Type *OrigTy, int AddrSpace);
 // Get addrspace of a pointer or a vector of pointers type.
 int getAddrSpace(llvm::Type *PtrOrPtrVec);
 
+// calculates new return type for cast instructions
+// * trunc
+// * bitcast
+llvm::Type *getNewTypeForCast(llvm::Type *OldOutType, llvm::Type *OldInType,
+                              llvm::Type *NewInType);
+
 // If \p Ty is degenerate vector type <1 x ElTy>,
 // ElTy is returned, otherwise original type \p Ty is returned.
 const llvm::Type &fixDegenerateVectorType(const llvm::Type &Ty);

IGC/VectorCompiler/lib/GenXCodeGen/GenXVectorCombiner.cpp

@@ -27,6 +27,7 @@ SPDX-License-Identifier: MIT
 #include "GenXIntrinsics.h"
 #include "GenXModule.h"
 #include "vc/GenXOpts/Utils/CMRegion.h"
+#include "vc/Utils/General/InstRebuilder.h"
 
 #include "IGC/common/debug/DebugMacros.hpp"
 
@@ -321,9 +322,9 @@ void GenXVectorCombiner::filterWorkList() {
 void GenXVectorCombiner::createNewInstruction(
     Instruction *InsteadOf, Instruction *Operation,
     const SmallVectorImpl<Value *> &Vals) {
-  IGC_ASSERT_MESSAGE(InsteadOf && Operation, "Error: nullptr");
-  IRBuilder<> Builder{InsteadOf};
+  IGC_ASSERT_MESSAGE(InsteadOf && Operation, "Error: nullptr input");
   if (GenXIntrinsic::isGenXIntrinsic(Operation)) {
+    IRBuilder<> Builder{InsteadOf};
     Function *Fn = nullptr;
     GenXIntrinsic::ID IdCode = GenXIntrinsic::getGenXIntrinsicID(Operation);
     Module *M = Operation->getParent()->getParent()->getParent();
@@ -341,26 +342,10 @@ void GenXVectorCombiner::createNewInstruction(
     InsteadOf->replaceAllUsesWith(CI);
     return;
   }
-  unsigned OpCode = Operation->getOpcode();
-  Value *NewInst = nullptr;
-  switch (OpCode) {
-  default:
-    IGC_ASSERT_MESSAGE(false, "get unknown opcode");
-  case Instruction::Add:
-    NewInst = Builder.CreateAdd(Vals[0], Vals[1], VALUE_NAME("widenedAdd"));
-    break;
-  case Instruction::FAdd:
-    NewInst = Builder.CreateFAdd(Vals[0], Vals[1], VALUE_NAME("widenedFAdd"));
-    break;
-  case Instruction::BitCast:
-    NewInst = Builder.CreateBitCast(Vals[0], InsteadOf->getType(),
-                                    VALUE_NAME("widenedBitcast"));
-    break;
-  case Instruction::Trunc:
-    NewInst = Builder.CreateTrunc(Vals[0], InsteadOf->getType(),
-                                  VALUE_NAME("widenedTrunc"));
-    break;
-  }
+  Instruction *NewInst = vc::cloneInstWithNewOps(*Operation, Vals);
+  NewInst->insertBefore(InsteadOf);
+  NewInst->setDebugLoc(InsteadOf->getDebugLoc());
+  NewInst->takeName(Operation);
   InsteadOf->replaceAllUsesWith(NewInst);
 }
 

IGC/VectorCompiler/lib/Utils/General/InstRebuilder.cpp

@@ -14,6 +14,7 @@ SPDX-License-Identifier: MIT
 
 #include <llvm/ADT/ArrayRef.h>
 #include <llvm/IR/InstVisitor.h>
+#include <llvm/IR/Instruction.h>
 #include <llvm/IR/IntrinsicInst.h>
 
 #include <algorithm>
@@ -84,6 +85,13 @@ class cloneInstWithNewOpsImpl
                                      NewOperands.drop_front());
   }
 
+  Instruction *visitTrunc(TruncInst &Trunc) {
+    Value &NewOp = getSingleNewOperand();
+    Type *NewOutType = vc::getNewTypeForCast(
+        Trunc.getType(), Trunc.getOperand(0)->getType(), NewOp.getType());
+    return new TruncInst{&NewOp, NewOutType};
+  }
+
   Instruction *visitLoadInst(LoadInst &OrigLoad) {
     Value &Ptr = getSingleNewOperand();
     auto *NewLoad =
@@ -108,17 +116,9 @@ class cloneInstWithNewOpsImpl
   // type addrspace corresponds with this operand.
   CastInst *visitBitCastInst(BitCastInst &OrigCast) {
     Value &NewOp = getSingleNewOperand();
-    // If the operand changed addrspace the bitcast type should change it too.
-    if (OrigCast.getType()->isPtrOrPtrVectorTy())
-      return visitPtrOrPtrVectorBitCastInst(OrigCast);
-    return new BitCastInst{&NewOp, OrigCast.getType()};
-  }
-
-  CastInst *visitPtrOrPtrVectorBitCastInst(BitCastInst &OrigCast) {
-    Value &NewOp = getSingleNewOperand();
-    auto NewOpAS = getAddrSpace(NewOp.getType());
-    return new BitCastInst{&NewOp,
-                           changeAddrSpace(OrigCast.getType(), NewOpAS)};
+    Type *NewOutType = vc::getNewTypeForCast(
+        OrigCast.getType(), OrigCast.getOperand(0)->getType(), NewOp.getType());
+    return new BitCastInst{&NewOp, NewOutType};
   }
 
   CastInst *visitAddrSpaceCastInst(AddrSpaceCastInst &OrigCast) {

IGC/VectorCompiler/lib/Utils/General/Types.cpp

@@ -7,6 +7,7 @@ SPDX-License-Identifier: MIT
 ============================= end_copyright_notice ===========================*/
 
 #include "vc/Utils/General/Types.h"
+#include "llvmWrapper/Support/TypeSize.h"
 
 #include "Probe/Assertion.h"
 
@@ -57,3 +58,63 @@ Type &vc::fixDegenerateVectorType(Type &Ty) {
   return const_cast<Type &>(
       fixDegenerateVectorType(static_cast<const Type &>(Ty)));
 }
+
+// calculates new return type for cast instructions
+// * trunc
+// * bitcast
+// Expect that scalar type of instruction not changed and previous
+// combination of OldOutType & OldInType is valid
+Type *vc::getNewTypeForCast(Type *OldOutType, Type *OldInType,
+                            Type *NewInType) {
+  IGC_ASSERT_MESSAGE(OldOutType && NewInType && OldInType,
+                     "Error: nullptr input");
+
+  bool NewInIsVec = isa<IGCLLVM::FixedVectorType>(NewInType);
+  bool OldOutIsVec = isa<IGCLLVM::FixedVectorType>(OldOutType);
+  bool OldInIsVec = isa<IGCLLVM::FixedVectorType>(OldInType);
+
+  bool NewInIsPtrOrVecPtr = NewInType->isPtrOrPtrVectorTy();
+  bool OldOutIsPtrOrVecPtr = OldOutType->isPtrOrPtrVectorTy();
+  bool OldInIsPtrOrVecPtr = OldInType->isPtrOrPtrVectorTy();
+
+  // only  pointer to pointer
+  IGC_ASSERT(NewInIsPtrOrVecPtr == OldOutIsPtrOrVecPtr &&
+             NewInIsPtrOrVecPtr == OldInIsPtrOrVecPtr);
+  // <2 x char> -> int : < 4 x char> -> ? forbidden
+  IGC_ASSERT(OldOutIsVec == OldInIsVec && OldOutIsVec == NewInIsVec);
+  Type *NewOutType = OldOutType;
+  if (OldOutIsVec) {
+    // <4 x char> -> <2 x int> : <8 x char> -> <4 x int>
+    // <4 x char> -> <2 x int> : <2 x char> -> <1 x int>
+    auto NewInEC = cast<IGCLLVM::FixedVectorType>(NewInType)->getNumElements();
+    auto OldOutEC =
+        cast<IGCLLVM::FixedVectorType>(OldOutType)->getNumElements();
+    auto OldInEC = cast<IGCLLVM::FixedVectorType>(OldInType)->getNumElements();
+    auto NewOutEC = OldOutEC * NewInEC / OldInEC;
+    // <4 x char> -> <2 x int> : <5 x char> -> ? forbidden
+    IGC_ASSERT_MESSAGE((OldOutEC * NewInEC) % OldInEC == 0,
+                       "Error: wrong combination of input/output");
+    // element count changed, scalar type as previous
+    NewOutType = IGCLLVM::FixedVectorType::get(
+        OldOutType->getVectorElementType(), IGCLLVM::getElementCount(NewOutEC));
+  }
+
+  IGC_ASSERT(NewOutType);
+
+  if (NewInIsPtrOrVecPtr) {
+    // <4 x char*> -> <2 x half*> : < 2 x int*> - ? forbidden
+    // char* -> half* : int* -> ? forbidden
+    IGC_ASSERT_MESSAGE(OldInType->getScalarType()->getPointerElementType() ==
+                           NewInType->getScalarType()->getPointerElementType(),
+                       "Error: unexpected type change");
+    // address space from new
+    // element count calculated as for vector
+    // element type expect address space similar
+    auto AddressSpace = getAddrSpace(NewInType);
+    return changeAddrSpace(NewOutType, AddressSpace);
+  }
+  // <4 x char> -> <2 x half> : < 2 x int> - ? forbiddeb
+  IGC_ASSERT_MESSAGE(OldInType->getScalarType() == NewInType->getScalarType(),
+                     "Error: unexpected type change");
+  return NewOutType;
+}