Commit 892dfd7d authored by Hans Wennborg's avatar Hans Wennborg
Browse files

Merging r370355: 

------------------------------------------------------------------------
r370355 | joerg | 2019-08-29 15:22:30 +0200 (Thu, 29 Aug 2019) | 5 lines

Allow replaceAndRecursivelySimplify to list unsimplified visitees.

This is part of D65280 and split it to avoid ABI changes on the 9.0
release branch.

------------------------------------------------------------------------

llvm-svn: 370447
parent 25f22e70

llvm/include/llvm/Analysis/InstructionSimplify.h

+7 −4
Original line number Diff line number Diff line
@@ -31,6 +31,7 @@ 
#ifndef LLVM_ANALYSIS_INSTRUCTIONSIMPLIFY_H

#define LLVM_ANALYSIS_INSTRUCTIONSIMPLIFY_H



#include "llvm/ADT/SetVector.h"

#include "llvm/IR/Instruction.h"

#include "llvm/IR/Operator.h"

#include "llvm/IR/User.h"
@@ -263,12 +264,14 @@ Value *SimplifyInstruction(Instruction *I, const SimplifyQuery &Q, 
/// This first performs a normal RAUW of I with SimpleV. It then recursively

/// attempts to simplify those users updated by the operation. The 'I'

/// instruction must not be equal to the simplified value 'SimpleV'.

/// If UnsimplifiedUsers is provided, instructions that could not be simplified

/// are added to it.

///

/// The function returns true if any simplifications were performed.

bool replaceAndRecursivelySimplify(Instruction *I, Value *SimpleV,

                                   const TargetLibraryInfo *TLI = nullptr,

                                   const DominatorTree *DT = nullptr,

                                   AssumptionCache *AC = nullptr);

bool replaceAndRecursivelySimplify(

    Instruction *I, Value *SimpleV, const TargetLibraryInfo *TLI = nullptr,

    const DominatorTree *DT = nullptr, AssumptionCache *AC = nullptr,

    SmallSetVector<Instruction *, 8> *UnsimplifiedUsers = nullptr);



/// Recursively attempt to simplify an instruction.

///

llvm/lib/Analysis/InstructionSimplify.cpp

+18 −12
Original line number Diff line number Diff line
@@ -5221,14 +5221,16 @@ Value *llvm::SimplifyInstruction(Instruction *I, const SimplifyQuery &SQ, 
/// If we have a pre-simplified value in 'SimpleV', that is forcibly used to

/// replace the instruction 'I'. Otherwise, we simply add 'I' to the list of

/// instructions to process and attempt to simplify it using

/// InstructionSimplify.

/// InstructionSimplify. Recursively visited users which could not be

/// simplified themselves are to the optional UnsimplifiedUsers set for

/// further processing by the caller.

///

/// This routine returns 'true' only when *it* simplifies something. The passed

/// in simplified value does not count toward this.

static bool replaceAndRecursivelySimplifyImpl(Instruction *I, Value *SimpleV,

                                              const TargetLibraryInfo *TLI,

                                              const DominatorTree *DT,

                                              AssumptionCache *AC) {

static bool replaceAndRecursivelySimplifyImpl(

    Instruction *I, Value *SimpleV, const TargetLibraryInfo *TLI,

    const DominatorTree *DT, AssumptionCache *AC,

    SmallSetVector<Instruction *, 8> *UnsimplifiedUsers = nullptr) {

  bool Simplified = false;

  SmallSetVector<Instruction *, 8> Worklist;

  const DataLayout &DL = I->getModule()->getDataLayout();
@@ -5258,8 +5260,11 @@ static bool replaceAndRecursivelySimplifyImpl(Instruction *I, Value *SimpleV, 


    // See if this instruction simplifies.

    SimpleV = SimplifyInstruction(I, {DL, TLI, DT, AC});

    if (!SimpleV)

    if (!SimpleV) {

      if (UnsimplifiedUsers)

        UnsimplifiedUsers->insert(I);

      continue;

    }



    Simplified = true;
@@ -5285,16 +5290,17 @@ bool llvm::recursivelySimplifyInstruction(Instruction *I, 
                                          const TargetLibraryInfo *TLI,

                                          const DominatorTree *DT,

                                          AssumptionCache *AC) {

  return replaceAndRecursivelySimplifyImpl(I, nullptr, TLI, DT, AC);

  return replaceAndRecursivelySimplifyImpl(I, nullptr, TLI, DT, AC, nullptr);

}



bool llvm::replaceAndRecursivelySimplify(Instruction *I, Value *SimpleV,

                                         const TargetLibraryInfo *TLI,

                                         const DominatorTree *DT,

                                         AssumptionCache *AC) {

bool llvm::replaceAndRecursivelySimplify(

    Instruction *I, Value *SimpleV, const TargetLibraryInfo *TLI,

    const DominatorTree *DT, AssumptionCache *AC,

    SmallSetVector<Instruction *, 8> *UnsimplifiedUsers) {

  assert(I != SimpleV && "replaceAndRecursivelySimplify(X,X) is not valid!");

  assert(SimpleV && "Must provide a simplified value.");

  return replaceAndRecursivelySimplifyImpl(I, SimpleV, TLI, DT, AC);

  return replaceAndRecursivelySimplifyImpl(I, SimpleV, TLI, DT, AC,

                                           UnsimplifiedUsers);

}



namespace llvm {