Commit 6e3e21d2 authored by Nikita Popov's avatar Nikita Popov
Browse files

[InstCombine] Remove unnecessary removeBitcastsFromLoadStoreOnMinMax() fold (NFCI) 

This optimizes a very specific pointer bitcast pattern, and as
such is no longer relevant with opaque pointers.
parent 8d307f59

llvm/lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp

+0 −78
Original line number Diff line number Diff line
@@ -648,29 +648,6 @@ static StoreInst *combineStoreToNewValue(InstCombinerImpl &IC, StoreInst &SI, 
  return NewStore;

}



/// Returns true if instruction represent minmax pattern like:

///   select ((cmp load V1, load V2), V1, V2).

static bool isMinMaxWithLoads(Value *V, Type *&LoadTy) {

  assert(V->getType()->isPointerTy() && "Expected pointer type.");

  // Ignore possible ty* to ixx* bitcast.

  V = InstCombiner::peekThroughBitcast(V);

  // Check that select is select ((cmp load V1, load V2), V1, V2) - minmax

  // pattern.

  CmpInst::Predicate Pred;

  Instruction *L1;

  Instruction *L2;

  Value *LHS;

  Value *RHS;

  if (!match(V, m_Select(m_Cmp(Pred, m_Instruction(L1), m_Instruction(L2)),

                         m_Value(LHS), m_Value(RHS))))

    return false;

  LoadTy = L1->getType();

  return (match(L1, m_Load(m_Specific(LHS))) &&

          match(L2, m_Load(m_Specific(RHS)))) ||

         (match(L1, m_Load(m_Specific(RHS))) &&

          match(L2, m_Load(m_Specific(LHS))));

}



/// Combine loads to match the type of their uses' value after looking

/// through intervening bitcasts.

///
@@ -1394,58 +1371,6 @@ static bool equivalentAddressValues(Value *A, Value *B) { 
  return false;

}



/// Converts store (bitcast (load (bitcast (select ...)))) to

/// store (load (select ...)), where select is minmax:

/// select ((cmp load V1, load V2), V1, V2).

static bool removeBitcastsFromLoadStoreOnMinMax(InstCombinerImpl &IC,

                                                StoreInst &SI) {

  // bitcast?

  if (!match(SI.getPointerOperand(), m_BitCast(m_Value())))

    return false;

  // load? integer?

  Value *LoadAddr;

  if (!match(SI.getValueOperand(), m_Load(m_BitCast(m_Value(LoadAddr)))))

    return false;

  auto *LI = cast<LoadInst>(SI.getValueOperand());

  if (!LI->getType()->isIntegerTy())

    return false;

  Type *CmpLoadTy;

  if (!isMinMaxWithLoads(LoadAddr, CmpLoadTy))

    return false;



  // Make sure the type would actually change.

  // This condition can be hit with chains of bitcasts.

  if (LI->getType() == CmpLoadTy)

    return false;



  // Make sure we're not changing the size of the load/store.

  const auto &DL = IC.getDataLayout();

  if (DL.getTypeStoreSizeInBits(LI->getType()) !=

      DL.getTypeStoreSizeInBits(CmpLoadTy))

    return false;



  if (!all_of(LI->users(), [LI, LoadAddr](User *U) {

        auto *SI = dyn_cast<StoreInst>(U);

        return SI && SI->getPointerOperand() != LI &&

               InstCombiner::peekThroughBitcast(SI->getPointerOperand()) !=

                   LoadAddr &&

               !SI->getPointerOperand()->isSwiftError();

      }))

    return false;



  IC.Builder.SetInsertPoint(LI);

  LoadInst *NewLI = IC.combineLoadToNewType(*LI, CmpLoadTy);

  // Replace all the stores with stores of the newly loaded value.

  for (auto *UI : LI->users()) {

    auto *USI = cast<StoreInst>(UI);

    IC.Builder.SetInsertPoint(USI);

    combineStoreToNewValue(IC, *USI, NewLI);

  }

  IC.replaceInstUsesWith(*LI, PoisonValue::get(LI->getType()));

  IC.eraseInstFromFunction(*LI);

  return true;

}



Instruction *InstCombinerImpl::visitStoreInst(StoreInst &SI) {

  Value *Val = SI.getOperand(0);

  Value *Ptr = SI.getOperand(1);
@@ -1466,9 +1391,6 @@ Instruction *InstCombinerImpl::visitStoreInst(StoreInst &SI) { 
  if (unpackStoreToAggregate(*this, SI))

    return eraseInstFromFunction(SI);



  if (removeBitcastsFromLoadStoreOnMinMax(*this, SI))

    return eraseInstFromFunction(SI);



  // Replace GEP indices if possible.

  if (Instruction *NewGEPI = replaceGEPIdxWithZero(*this, Ptr, SI))

    return replaceOperand(SI, 1, NewGEPI);