CombinerHelperCompares.cpp

//===- CombinerHelperCompares.cpp------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file implements CombinerHelper for G_ICMP.
//
//===----------------------------------------------------------------------===//
#include "llvm/CodeGen/GlobalISel/CombinerHelper.h"
#include "llvm/CodeGen/GlobalISel/GenericMachineInstrs.h"
#include "llvm/CodeGen/GlobalISel/LegalizerHelper.h"
#include "llvm/CodeGen/GlobalISel/LegalizerInfo.h"
#include "llvm/CodeGen/GlobalISel/MachineIRBuilder.h"
#include "llvm/CodeGen/GlobalISel/Utils.h"
#include "llvm/CodeGen/LowLevelTypeUtils.h"
#include "llvm/CodeGen/MachineInstr.h"
#include "llvm/CodeGen/MachineOperand.h"
#include "llvm/CodeGen/MachineRegisterInfo.h"
#include "llvm/CodeGen/TargetOpcodes.h"
#include "llvm/IR/Instructions.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/ErrorHandling.h"
#include <cstdlib>

#define DEBUG_TYPE "gi-combiner"

using namespace llvm;

bool CombinerHelper::constantFoldICmp(const GICmp &ICmp,
                                      const GIConstant &LHSCst,
                                      const GIConstant &RHSCst,
                                      BuildFnTy &MatchInfo) {
  if (LHSCst.getKind() != GIConstantKind::Scalar)
    return false;

  Register Dst = ICmp.getReg(0);
  LLT DstTy = MRI.getType(Dst);

  if (!isConstantLegalOrBeforeLegalizer(DstTy))
    return false;

  CmpInst::Predicate Pred = ICmp.getCond();
  APInt LHS = LHSCst.getScalarValue();
  APInt RHS = RHSCst.getScalarValue();

  bool Result = ICmpInst::compare(LHS, RHS, Pred);

  MatchInfo = [=](MachineIRBuilder &B) {
    if (Result)
      B.buildConstant(Dst, getICmpTrueVal(getTargetLowering(),
                                          /*IsVector=*/DstTy.isVector(),
                                          /*IsFP=*/false));
    else
      B.buildConstant(Dst, 0);
  };

  return true;
}

bool CombinerHelper::matchICmp(const MachineInstr &MI, BuildFnTy &MatchInfo) {
  const GICmp *Cmp = cast<GICmp>(&MI);

  Register Dst = Cmp->getReg(0);
  Register LHS = Cmp->getLHSReg();
  Register RHS = Cmp->getRHSReg();

  CmpInst::Predicate Pred = Cmp->getCond();
  assert(CmpInst::isIntPredicate(Pred) && "Not an integer compare!");
  if (auto CLHS = GIConstant::getConstant(LHS, MRI)) {
    if (auto CRHS = GIConstant::getConstant(RHS, MRI))
      return constantFoldICmp(*Cmp, *CLHS, *CRHS, MatchInfo);

    // If we have a constant, make sure it is on the RHS.
    std::swap(LHS, RHS);
    Pred = CmpInst::getSwappedPredicate(Pred);

    MatchInfo = [=](MachineIRBuilder &B) { B.buildICmp(Pred, Dst, LHS, RHS); };
    return true;
  }

  return false;
}

bool CombinerHelper::matchCmpOfZero(const MachineInstr &MI,
                                    BuildFnTy &MatchInfo) {
  const GICmp *Cmp = cast<GICmp>(&MI);

  Register Dst = Cmp->getReg(0);
  LLT DstTy = MRI.getType(Dst);
  Register LHS = Cmp->getLHSReg();
  CmpInst::Predicate Pred = Cmp->getCond();

  if (!isConstantLegalOrBeforeLegalizer(DstTy))
    return false;

  std::optional<bool> Result;

  switch (Pred) {
  default:
    llvm_unreachable("Unkonwn ICmp predicate!");
  case ICmpInst::ICMP_ULT:
    Result = false;
    break;
  case ICmpInst::ICMP_UGE:
    Result = true;
    break;
  case ICmpInst::ICMP_EQ:
  case ICmpInst::ICMP_ULE:
    if (isKnownNonZero(LHS, MRI, KB))
      Result = false;
    break;
  case ICmpInst::ICMP_NE:
  case ICmpInst::ICMP_UGT:
    if (isKnownNonZero(LHS, MRI, KB))
      Result = true;
    break;
  case ICmpInst::ICMP_SLT: {
    KnownBits LHSKnown = KB->getKnownBits(LHS);
    if (LHSKnown.isNegative())
      Result = true;
    if (LHSKnown.isNonNegative())
      Result = false;
    break;
  }
  case ICmpInst::ICMP_SLE: {
    KnownBits LHSKnown = KB->getKnownBits(LHS);
    if (LHSKnown.isNegative())
      Result = true;
    if (LHSKnown.isNonNegative() && isKnownNonZero(LHS, MRI, KB))
      Result = false;
    break;
  }
  case ICmpInst::ICMP_SGE: {
    KnownBits LHSKnown = KB->getKnownBits(LHS);
    if (LHSKnown.isNegative())
      Result = false;
    if (LHSKnown.isNonNegative())
      Result = true;
    break;
  }
  case ICmpInst::ICMP_SGT: {
    KnownBits LHSKnown = KB->getKnownBits(LHS);
    if (LHSKnown.isNegative())
      Result = false;
    if (LHSKnown.isNonNegative() && isKnownNonZero(LHS, MRI, KB))
      Result = true;
    break;
  }
  }

  if (!Result)
    return false;

  MatchInfo = [=](MachineIRBuilder &B) {
    if (*Result)
      B.buildConstant(Dst, getICmpTrueVal(getTargetLowering(),
                                          /*IsVector=*/DstTy.isVector(),
                                          /*IsFP=*/false));
    else
      B.buildConstant(Dst, 0);
  };

  return true;
}