remove non built-in Emulation of int64

int64 emulation was fully moved to BiF
we do not need old emulation anymore

Author: vchernon-intel

IGC/VectorCompiler/lib/GenXCodeGen/GenXEmulate.cpp

@@ -167,14 +167,6 @@ class GenXEmulate : public ModulePass {
 
     Value *buildRightShift(IVSplitter &SplitBuilder, BinaryOperator &Op);
 
-    Value *visitFPToUI(FPToUIInst &);
-    Value *visitFPToSI(FPToSIInst &);
-    Value *visitUIToFP(UIToFPInst &);
-    Value *visitSIToFP(SIToFPInst &);
-    Value *buildUI64ToFloat(UIToFPInst &Op);
-    Value *buildSI64ToFloat(SIToFPInst &Op);
-    Value *buildI64ToHalf(CastInst &Op);
-
     Value *visitZExtInst(ZExtInst &I);
     Value *visitSExtInst(SExtInst &I);
 
@@ -737,191 +729,6 @@ Value *GenXEmulate::Emu64Expander::visitAShr(BinaryOperator &Op) {
   return buildRightShift(SplitBuilder, Op);
 }
 
-Value *GenXEmulate::Emu64Expander::visitFPToUI(FPToUIInst &Op) {
-
-  if (!(Op.getOperand(0)->getType()->getScalarType()->isFloatTy() &&
-        Op.getType()->getScalarType()->isIntegerTy(64)))
-    vc::diagnose(Op.getContext(), "GenXEmulate", &Op,
-                 "unsupported (floating point type) -> UI conversion. "
-                 "Only float->i64 is supported");
-
-  // TODO: try to detect the case where operand is a constant expression
-  // and do the covertion manually
-  auto Builder = getIRBuilder();
-  const bool IsSigned = false;
-  auto *V = buildFPToI64(*Op.getModule(), Builder, SplitBuilder,
-                         Op.getOperand(0), IsSigned);
-  return Builder.CreateBitCast(V, Op.getType(),
-                               Twine(Op.getOpcodeName()) + ".emu");
-}
-Value *GenXEmulate::Emu64Expander::visitFPToSI(FPToSIInst &Op) {
-
-  if (!(Op.getOperand(0)->getType()->getScalarType()->isFloatTy() &&
-        Op.getType()->getScalarType()->isIntegerTy(64)))
-    vc::diagnose(Op.getContext(), "GenXEmulate", &Op,
-                 "unsupported (floating point type) -> UI conversion. "
-                 "Only float->i64 is supported");
-
-  // TODO: try to detect the case where operand is a constant expression
-  // and do the covertion manually
-  auto Builder = getIRBuilder();
-  const bool IsSigned = true;
-  auto *V = buildFPToI64(*Op.getModule(), Builder, SplitBuilder,
-                         Op.getOperand(0), IsSigned);
-  return Builder.CreateBitCast(V, Op.getType(),
-                               Twine(Op.getOpcodeName()) + ".emu");
-}
-Value *GenXEmulate::Emu64Expander::visitUIToFP(UIToFPInst &Op) {
-  auto *STy = Op.getType()->getScalarType();
-
-  if (STy->isHalfTy())
-    return buildI64ToHalf(Op);
-  if (STy->isFloatTy())
-    return buildUI64ToFloat(Op);
-  vc::diagnose(Op.getContext(), "GenXEmulate", &Op,
-               "unsupported UI64 -> (floating point type) conversion. "
-               "Only UI64->float and UI64->half are supported");
-  return nullptr; // to suppress warnings
-}
-Value *GenXEmulate::Emu64Expander::visitSIToFP(SIToFPInst &Op) {
-  auto *STy = Op.getType()->getScalarType();
-
-  if (STy->isHalfTy())
-    return buildI64ToHalf(Op);
-  if (STy->isFloatTy())
-    return buildSI64ToFloat(Op);
-  vc::diagnose(Op.getContext(), "GenXEmulate", &Op,
-               "unsupported SI64 -> (floating point type) conversion. "
-               "Only SI64->float and SI64->half are supported");
-  return nullptr; // to suppress warnings
-}
-Value *GenXEmulate::Emu64Expander::buildUI64ToFloat(UIToFPInst &Op) {
-  IGC_ASSERT_MESSAGE(Op.getType()->getScalarType()->isFloatTy(),
-                     "UI64->fp32 conversion expected");
-
-  auto Builder = getIRBuilder();
-  auto UI64 = SplitBuilder.splitOperandLoHi(0);
-  ConstantEmitter K(UI64.Lo);
-
-  Function *LzdF = GenXIntrinsic::getAnyDeclaration(
-      Op.getModule(), GenXIntrinsic::genx_lzd, {UI64.Hi->getType()});
-  Value *Lz = Builder.CreateCall(LzdF, UI64.Hi, "int_emu.ui2fp.lzd.");
-  // sp: 1|8|23
-  // we need to get that nice first set bit into bit position 23.
-  // thus we shift our nice pair of values by 63 - 23 - clz,
-  // some bits will be dropped by shift thus we'll add 1 bits as R bit.
-  // uint8_t shift = 39 - lz;
-  const unsigned kMaxDroppedMantBits = 39;
-  Value *DroppedBits = Builder.CreateSub(K.getSplat(kMaxDroppedMantBits), Lz);
-  auto SI = constructShiftInfo(Builder, DroppedBits);
-  // mantissa = LoPartOf(shr64(data_h, data_l, shift))
-  Value *Mant = buildPartialRShift(Builder, UI64.Lo, UI64.Hi, SI);
-
-  // bool sticky_h = (data_h & ~mask) & ((1 << (shift - 32)) - 1);
-  auto *TmpShA = Builder.CreateShl(K.getSplat(1), Builder.CreateNeg(SI.Sh32));
-  auto *TmpMask = Builder.CreateSub(TmpShA, K.getSplat(1));
-  auto *StickyH = Builder.CreateAnd(UI64.Hi, Builder.CreateNot(SI.Mask1));
-  StickyH = Builder.CreateAnd(StickyH, TmpMask);
-
-  // bool sticky_l = (data_l & ~mask) || ((data_l & (mask >> shift));
-  auto *SL1 = Builder.CreateAnd(UI64.Lo, Builder.CreateNot(SI.Mask1));
-  auto *SL2 = Builder.CreateAnd(UI64.Lo, Builder.CreateLShr(SI.Mask1, SI.Sh32));
-  auto *StickyL = Builder.CreateOr(SL1, SL2);
-
-  // Calculate RS
-  // bool S = sticky_h | sticky_l;
-  auto *S = Builder.CreateOr(StickyH, StickyL);
-  S = Builder.CreateICmpEQ(S, K.getZero());
-
-  auto *notS = Builder.CreateSelect(S, K.getOnes(), K.getZero());
-
-  // R = Mant & 1
-  auto *R = Builder.CreateAnd(Mant, K.getSplat(1));
-  // mant = (mant + 0x1) >> 1;
-  Mant =
-      Builder.CreateLShr(Builder.CreateAdd(Mant, K.getSplat(1)), K.getSplat(1));
-  // mant &= ~(!S & R); // R is set but no S, round to even.
-  auto *RoundMask = Builder.CreateNot(Builder.CreateAnd(notS, R));
-  Mant = Builder.CreateAnd(Mant, RoundMask);
-  // 0xbd - Lz
-  const unsigned kMaxValueExp = 0xbd;
-  auto *Exp = Builder.CreateSub(K.getSplat(kMaxValueExp), Lz);
-  auto *ResultLarge = Builder.CreateShl(Exp, K.getSplat(23));
-  ResultLarge = Builder.CreateAdd(ResultLarge, Mant);
-
-  // NOTE: at this point ResultLarge is a integer vector
-  // Since we calculate "optimized" route through creating yes another
-  // UIToFP instrucion (on i32) and this shall be a vector operation,
-  // all further calculatoins assume that we always process vectors
-  // The cast to the final type (scalar or vector) shall be done at the end
-  auto *VFPTy = Op.getType();
-  if (!VFPTy->isVectorTy())
-    VFPTy = IGCLLVM::FixedVectorType::get(Builder.getFloatTy(), 1);
-
-  ResultLarge = Builder.CreateBitCast(
-      ResultLarge, VFPTy, Twine("int_emu.ui2f.l.") + Op.getOpcodeName());
-  auto *ResultSmall = Builder.CreateUIToFP(
-      UI64.Lo, VFPTy, Twine("int_emu.ui2f.s.") + Op.getOpcodeName());
-
-  auto *IsSmallPred = Builder.CreateICmpEQ(UI64.Hi, K.getZero());
-  auto *Result = Builder.CreateSelect(IsSmallPred, ResultSmall, ResultLarge);
-  // Final cast to the requested type (usually <1 x float> -> float)
-  if (Op.getType() != VFPTy)
-    Result = Builder.CreateBitCast(
-        Result, Op.getType(), Twine("int_emu.ui2fp.") + Op.getOpcodeName());
-  return Result;
-}
-Value *GenXEmulate::Emu64Expander::buildSI64ToFloat(SIToFPInst &Op) {
-  IGC_ASSERT_MESSAGE(Op.getType()->getScalarType()->isFloatTy(),
-                     "SI64->fp32 conversion expected");
-
-  // NOTE: SIToFP is special, since it does not do the convert by itself,
-  // Instead it just creates a sequence of 64.bit operations which
-  // are then expanded. As such some type convertion trickery is involved.
-  // Namely, we transform all operands to vector types type as early as possible
-  auto Builder = getIRBuilder();
-  auto UI64 = SplitBuilder.splitOperandLoHi(0);
-  ConstantEmitter K(UI64.Hi);
-
-  auto *SignVal = Builder.CreateAnd(UI64.Hi, K.getSplat(1 << 31));
-  auto *PredSigned = Builder.CreateICmpNE(SignVal, K.getZero());
-
-  auto *VOprnd = toVector(Builder, Op.getOperand(0)).V;
-  // This would be a 64-bit operation on a vector types
-  auto *NegatedOpnd = Builder.CreateNeg(VOprnd);
-  NegatedOpnd = ensureEmulated(NegatedOpnd);
-
-  auto *AbsVal = Builder.CreateSelect(PredSigned, NegatedOpnd, VOprnd);
-  AbsVal = ensureEmulated(AbsVal);
-
-  Type *CnvType = Op.getType();
-  if (!Op.getType()->isVectorTy()) {
-    CnvType = IGCLLVM::FixedVectorType::get(Builder.getFloatTy(), 1);
-  }
-  auto *Cnv = Builder.CreateUIToFP(AbsVal, CnvType);
-  Cnv = ensureEmulated(Cnv);
-
-  // we want to set a proper sign, so we cast it to <N x int>,
-  // set sign bit and cast-away to the final result
-  Value *AsInt = Builder.CreateBitCast(Cnv, K.getVTy());
-  auto *Result = Builder.CreateOr(AsInt, SignVal);
-  return Builder.CreateBitCast(Result, Op.getType());
-}
-// Expands both UI64->half and SI64->half
-Value *GenXEmulate::Emu64Expander::buildI64ToHalf(CastInst &Op) {
-  IGC_ASSERT_MESSAGE(Op.getType()->getScalarType()->isHalfTy(),
-                     "UI64->half or SI64->half conversion expected");
-
-  auto Builder = getIRBuilder();
-  auto *FloatTy = Type::getFloatTy(Op.getContext());
-  auto *Conv = cast<Instruction>(
-      Builder.CreateCast(Op.getOpcode(), Op.getOperand(0),
-                         changeScalarType(Op.getType(), FloatTy)));
-  auto *EmulatedConv = Emu64Expander{ST, *Conv}.tryExpand();
-  Conv->eraseFromParent();
-  return Builder.CreateFPTrunc(EmulatedConv, Op.getType(), "int_emu.truncate");
-}
-
 Value *GenXEmulate::Emu64Expander::visitZExtInst(ZExtInst &I) {
   auto Builder = getIRBuilder();
   auto VOp = toVector(Builder, I.getOperand(0));