mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-12-17 03:30:28 +00:00
851b04c920
This change, which allows @llvm.assume to be used from within computeKnownBits (and other associated functions in ValueTracking), adds some (optional) parameters to computeKnownBits and friends. These functions now (optionally) take a "context" instruction pointer, an AssumptionTracker pointer, and also a DomTree pointer, and most of the changes are just to pass this new information when it is easily available from InstSimplify, InstCombine, etc. As explained below, the significant conceptual change is that known properties of a value might depend on the control-flow location of the use (because we care that the @llvm.assume dominates the use because assumptions have control-flow dependencies). This means that, when we ask if bits are known in a value, we might get different answers for different uses. The significant changes are all in ValueTracking. Two main changes: First, as with the rest of the code, new parameters need to be passed around. To make this easier, I grouped them into a structure, and I made internal static versions of the relevant functions that take this structure as a parameter. The new code does as you might expect, it looks for @llvm.assume calls that make use of the value we're trying to learn something about (often indirectly), attempts to pattern match that expression, and uses the result if successful. By making use of the AssumptionTracker, the process of finding @llvm.assume calls is not expensive. Part of the structure being passed around inside ValueTracking is a set of already-considered @llvm.assume calls. This is to prevent a query using, for example, the assume(a == b), to recurse on itself. The context and DT params are used to find applicable assumptions. An assumption needs to dominate the context instruction, or come after it deterministically. In this latter case we only handle the specific case where both the assumption and the context instruction are in the same block, and we need to exclude assumptions from being used to simplify their own ephemeral values (those which contribute only to the assumption) because otherwise the assumption would prove its feeding comparison trivial and would be removed. This commit adds the plumbing and the logic for a simple masked-bit propagation (just enough to write a regression test). Future commits add more patterns (and, correspondingly, more regression tests). git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@217342 91177308-0d34-0410-b5e6-96231b3b80d8
341 lines
17 KiB
C++
341 lines
17 KiB
C++
//===-- InstructionSimplify.h - Fold instrs into simpler forms --*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file declares routines for folding instructions into simpler forms
|
|
// that do not require creating new instructions. This does constant folding
|
|
// ("add i32 1, 1" -> "2") but can also handle non-constant operands, either
|
|
// returning a constant ("and i32 %x, 0" -> "0") or an already existing value
|
|
// ("and i32 %x, %x" -> "%x"). If the simplification is also an instruction
|
|
// then it dominates the original instruction.
|
|
//
|
|
// These routines implicitly resolve undef uses. The easiest way to be safe when
|
|
// using these routines to obtain simplified values for existing instructions is
|
|
// to always replace all uses of the instructions with the resulting simplified
|
|
// values. This will prevent other code from seeing the same undef uses and
|
|
// resolving them to different values.
|
|
//
|
|
// These routines are designed to tolerate moderately incomplete IR, such as
|
|
// instructions that are not connected to basic blocks yet. However, they do
|
|
// require that all the IR that they encounter be valid. In particular, they
|
|
// require that all non-constant values be defined in the same function, and the
|
|
// same call context of that function (and not split between caller and callee
|
|
// contexts of a directly recursive call, for example).
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_ANALYSIS_INSTRUCTIONSIMPLIFY_H
|
|
#define LLVM_ANALYSIS_INSTRUCTIONSIMPLIFY_H
|
|
|
|
#include "llvm/IR/User.h"
|
|
|
|
namespace llvm {
|
|
template<typename T>
|
|
class ArrayRef;
|
|
class AssumptionTracker;
|
|
class DominatorTree;
|
|
class Instruction;
|
|
class DataLayout;
|
|
class FastMathFlags;
|
|
class TargetLibraryInfo;
|
|
class Type;
|
|
class Value;
|
|
|
|
/// SimplifyAddInst - Given operands for an Add, see if we can
|
|
/// fold the result. If not, this returns null.
|
|
Value *SimplifyAddInst(Value *LHS, Value *RHS, bool isNSW, bool isNUW,
|
|
const DataLayout *TD = nullptr,
|
|
const TargetLibraryInfo *TLI = nullptr,
|
|
const DominatorTree *DT = nullptr,
|
|
AssumptionTracker *AT = nullptr,
|
|
const Instruction *CxtI = nullptr);
|
|
|
|
/// SimplifySubInst - Given operands for a Sub, see if we can
|
|
/// fold the result. If not, this returns null.
|
|
Value *SimplifySubInst(Value *LHS, Value *RHS, bool isNSW, bool isNUW,
|
|
const DataLayout *TD = nullptr,
|
|
const TargetLibraryInfo *TLI = nullptr,
|
|
const DominatorTree *DT = nullptr,
|
|
AssumptionTracker *AT = nullptr,
|
|
const Instruction *CxtI = nullptr);
|
|
|
|
/// Given operands for an FAdd, see if we can fold the result. If not, this
|
|
/// returns null.
|
|
Value *SimplifyFAddInst(Value *LHS, Value *RHS, FastMathFlags FMF,
|
|
const DataLayout *TD = nullptr,
|
|
const TargetLibraryInfo *TLI = nullptr,
|
|
const DominatorTree *DT = nullptr,
|
|
AssumptionTracker *AT = nullptr,
|
|
const Instruction *CxtI = nullptr);
|
|
|
|
/// Given operands for an FSub, see if we can fold the result. If not, this
|
|
/// returns null.
|
|
Value *SimplifyFSubInst(Value *LHS, Value *RHS, FastMathFlags FMF,
|
|
const DataLayout *TD = nullptr,
|
|
const TargetLibraryInfo *TLI = nullptr,
|
|
const DominatorTree *DT = nullptr,
|
|
AssumptionTracker *AT = nullptr,
|
|
const Instruction *CxtI = nullptr);
|
|
|
|
/// Given operands for an FMul, see if we can fold the result. If not, this
|
|
/// returns null.
|
|
Value *SimplifyFMulInst(Value *LHS, Value *RHS,
|
|
FastMathFlags FMF,
|
|
const DataLayout *TD = nullptr,
|
|
const TargetLibraryInfo *TLI = nullptr,
|
|
const DominatorTree *DT = nullptr,
|
|
AssumptionTracker *AT = nullptr,
|
|
const Instruction *CxtI = nullptr);
|
|
|
|
/// SimplifyMulInst - Given operands for a Mul, see if we can
|
|
/// fold the result. If not, this returns null.
|
|
Value *SimplifyMulInst(Value *LHS, Value *RHS, const DataLayout *TD = nullptr,
|
|
const TargetLibraryInfo *TLI = nullptr,
|
|
const DominatorTree *DT = nullptr,
|
|
AssumptionTracker *AT = nullptr,
|
|
const Instruction *CxtI = nullptr);
|
|
|
|
/// SimplifySDivInst - Given operands for an SDiv, see if we can
|
|
/// fold the result. If not, this returns null.
|
|
Value *SimplifySDivInst(Value *LHS, Value *RHS,
|
|
const DataLayout *TD = nullptr,
|
|
const TargetLibraryInfo *TLI = nullptr,
|
|
const DominatorTree *DT = nullptr,
|
|
AssumptionTracker *AT = nullptr,
|
|
const Instruction *CxtI = nullptr);
|
|
|
|
/// SimplifyUDivInst - Given operands for a UDiv, see if we can
|
|
/// fold the result. If not, this returns null.
|
|
Value *SimplifyUDivInst(Value *LHS, Value *RHS,
|
|
const DataLayout *TD = nullptr,
|
|
const TargetLibraryInfo *TLI = nullptr,
|
|
const DominatorTree *DT = nullptr,
|
|
AssumptionTracker *AT = nullptr,
|
|
const Instruction *CxtI = nullptr);
|
|
|
|
/// SimplifyFDivInst - Given operands for an FDiv, see if we can
|
|
/// fold the result. If not, this returns null.
|
|
Value *SimplifyFDivInst(Value *LHS, Value *RHS,
|
|
const DataLayout *TD = nullptr,
|
|
const TargetLibraryInfo *TLI = nullptr,
|
|
const DominatorTree *DT = nullptr,
|
|
AssumptionTracker *AT = nullptr,
|
|
const Instruction *CxtI = nullptr);
|
|
|
|
/// SimplifySRemInst - Given operands for an SRem, see if we can
|
|
/// fold the result. If not, this returns null.
|
|
Value *SimplifySRemInst(Value *LHS, Value *RHS,
|
|
const DataLayout *TD = nullptr,
|
|
const TargetLibraryInfo *TLI = nullptr,
|
|
const DominatorTree *DT = nullptr,
|
|
AssumptionTracker *AT = nullptr,
|
|
const Instruction *CxtI = nullptr);
|
|
|
|
/// SimplifyURemInst - Given operands for a URem, see if we can
|
|
/// fold the result. If not, this returns null.
|
|
Value *SimplifyURemInst(Value *LHS, Value *RHS,
|
|
const DataLayout *TD = nullptr,
|
|
const TargetLibraryInfo *TLI = nullptr,
|
|
const DominatorTree *DT = nullptr,
|
|
AssumptionTracker *AT = nullptr,
|
|
const Instruction *CxtI = nullptr);
|
|
|
|
/// SimplifyFRemInst - Given operands for an FRem, see if we can
|
|
/// fold the result. If not, this returns null.
|
|
Value *SimplifyFRemInst(Value *LHS, Value *RHS,
|
|
const DataLayout *TD = nullptr,
|
|
const TargetLibraryInfo *TLI = nullptr,
|
|
const DominatorTree *DT = nullptr,
|
|
AssumptionTracker *AT = nullptr,
|
|
const Instruction *CxtI = nullptr);
|
|
|
|
/// SimplifyShlInst - Given operands for a Shl, see if we can
|
|
/// fold the result. If not, this returns null.
|
|
Value *SimplifyShlInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW,
|
|
const DataLayout *TD = nullptr,
|
|
const TargetLibraryInfo *TLI = nullptr,
|
|
const DominatorTree *DT = nullptr,
|
|
AssumptionTracker *AT = nullptr,
|
|
const Instruction *CxtI = nullptr);
|
|
|
|
/// SimplifyLShrInst - Given operands for a LShr, see if we can
|
|
/// fold the result. If not, this returns null.
|
|
Value *SimplifyLShrInst(Value *Op0, Value *Op1, bool isExact,
|
|
const DataLayout *TD = nullptr,
|
|
const TargetLibraryInfo *TLI = nullptr,
|
|
const DominatorTree *DT = nullptr,
|
|
AssumptionTracker *AT = nullptr,
|
|
const Instruction *CxtI = nullptr);
|
|
|
|
/// SimplifyAShrInst - Given operands for a AShr, see if we can
|
|
/// fold the result. If not, this returns null.
|
|
Value *SimplifyAShrInst(Value *Op0, Value *Op1, bool isExact,
|
|
const DataLayout *TD = nullptr,
|
|
const TargetLibraryInfo *TLI = nullptr,
|
|
const DominatorTree *DT = nullptr,
|
|
AssumptionTracker *AT = nullptr,
|
|
const Instruction *CxtI = nullptr);
|
|
|
|
/// SimplifyAndInst - Given operands for an And, see if we can
|
|
/// fold the result. If not, this returns null.
|
|
Value *SimplifyAndInst(Value *LHS, Value *RHS, const DataLayout *TD = nullptr,
|
|
const TargetLibraryInfo *TLI = nullptr,
|
|
const DominatorTree *DT = nullptr,
|
|
AssumptionTracker *AT = nullptr,
|
|
const Instruction *CxtI = nullptr);
|
|
|
|
/// SimplifyOrInst - Given operands for an Or, see if we can
|
|
/// fold the result. If not, this returns null.
|
|
Value *SimplifyOrInst(Value *LHS, Value *RHS, const DataLayout *TD = nullptr,
|
|
const TargetLibraryInfo *TLI = nullptr,
|
|
const DominatorTree *DT = nullptr,
|
|
AssumptionTracker *AT = nullptr,
|
|
const Instruction *CxtI = nullptr);
|
|
|
|
/// SimplifyXorInst - Given operands for a Xor, see if we can
|
|
/// fold the result. If not, this returns null.
|
|
Value *SimplifyXorInst(Value *LHS, Value *RHS, const DataLayout *TD = nullptr,
|
|
const TargetLibraryInfo *TLI = nullptr,
|
|
const DominatorTree *DT = nullptr,
|
|
AssumptionTracker *AT = nullptr,
|
|
const Instruction *CxtI = nullptr);
|
|
|
|
/// SimplifyICmpInst - Given operands for an ICmpInst, see if we can
|
|
/// fold the result. If not, this returns null.
|
|
Value *SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS,
|
|
const DataLayout *TD = nullptr,
|
|
const TargetLibraryInfo *TLI = nullptr,
|
|
const DominatorTree *DT = nullptr,
|
|
AssumptionTracker *AT = nullptr,
|
|
Instruction *CxtI = nullptr);
|
|
|
|
/// SimplifyFCmpInst - Given operands for an FCmpInst, see if we can
|
|
/// fold the result. If not, this returns null.
|
|
Value *SimplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS,
|
|
const DataLayout *TD = nullptr,
|
|
const TargetLibraryInfo *TLI = nullptr,
|
|
const DominatorTree *DT = nullptr,
|
|
AssumptionTracker *AT = nullptr,
|
|
const Instruction *CxtI = nullptr);
|
|
|
|
/// SimplifySelectInst - Given operands for a SelectInst, see if we can fold
|
|
/// the result. If not, this returns null.
|
|
Value *SimplifySelectInst(Value *Cond, Value *TrueVal, Value *FalseVal,
|
|
const DataLayout *TD = nullptr,
|
|
const TargetLibraryInfo *TLI = nullptr,
|
|
const DominatorTree *DT = nullptr,
|
|
AssumptionTracker *AT = nullptr,
|
|
const Instruction *CxtI = nullptr);
|
|
|
|
/// SimplifyGEPInst - Given operands for an GetElementPtrInst, see if we can
|
|
/// fold the result. If not, this returns null.
|
|
Value *SimplifyGEPInst(ArrayRef<Value *> Ops, const DataLayout *TD = nullptr,
|
|
const TargetLibraryInfo *TLI = nullptr,
|
|
const DominatorTree *DT = nullptr,
|
|
AssumptionTracker *AT = nullptr,
|
|
const Instruction *CxtI = nullptr);
|
|
|
|
/// SimplifyInsertValueInst - Given operands for an InsertValueInst, see if we
|
|
/// can fold the result. If not, this returns null.
|
|
Value *SimplifyInsertValueInst(Value *Agg, Value *Val,
|
|
ArrayRef<unsigned> Idxs,
|
|
const DataLayout *TD = nullptr,
|
|
const TargetLibraryInfo *TLI = nullptr,
|
|
const DominatorTree *DT = nullptr,
|
|
AssumptionTracker *AT = nullptr,
|
|
const Instruction *CxtI = nullptr);
|
|
|
|
/// SimplifyTruncInst - Given operands for an TruncInst, see if we can fold
|
|
/// the result. If not, this returns null.
|
|
Value *SimplifyTruncInst(Value *Op, Type *Ty, const DataLayout *TD = nullptr,
|
|
const TargetLibraryInfo *TLI = nullptr,
|
|
const DominatorTree *DT = nullptr,
|
|
AssumptionTracker *AT = nullptr,
|
|
const Instruction *CxtI = nullptr);
|
|
|
|
//=== Helper functions for higher up the class hierarchy.
|
|
|
|
|
|
/// SimplifyCmpInst - Given operands for a CmpInst, see if we can
|
|
/// fold the result. If not, this returns null.
|
|
Value *SimplifyCmpInst(unsigned Predicate, Value *LHS, Value *RHS,
|
|
const DataLayout *TD = nullptr,
|
|
const TargetLibraryInfo *TLI = nullptr,
|
|
const DominatorTree *DT = nullptr,
|
|
AssumptionTracker *AT = nullptr,
|
|
const Instruction *CxtI = nullptr);
|
|
|
|
/// SimplifyBinOp - Given operands for a BinaryOperator, see if we can
|
|
/// fold the result. If not, this returns null.
|
|
Value *SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS,
|
|
const DataLayout *TD = nullptr,
|
|
const TargetLibraryInfo *TLI = nullptr,
|
|
const DominatorTree *DT = nullptr,
|
|
AssumptionTracker *AT = nullptr,
|
|
const Instruction *CxtI = nullptr);
|
|
|
|
/// \brief Given a function and iterators over arguments, see if we can fold
|
|
/// the result.
|
|
///
|
|
/// If this call could not be simplified returns null.
|
|
Value *SimplifyCall(Value *V, User::op_iterator ArgBegin,
|
|
User::op_iterator ArgEnd, const DataLayout *TD = nullptr,
|
|
const TargetLibraryInfo *TLI = nullptr,
|
|
const DominatorTree *DT = nullptr,
|
|
AssumptionTracker *AT = nullptr,
|
|
const Instruction *CxtI = nullptr);
|
|
|
|
/// \brief Given a function and set of arguments, see if we can fold the
|
|
/// result.
|
|
///
|
|
/// If this call could not be simplified returns null.
|
|
Value *SimplifyCall(Value *V, ArrayRef<Value *> Args,
|
|
const DataLayout *TD = nullptr,
|
|
const TargetLibraryInfo *TLI = nullptr,
|
|
const DominatorTree *DT = nullptr,
|
|
AssumptionTracker *AT = nullptr,
|
|
const Instruction *CxtI = nullptr);
|
|
|
|
/// SimplifyInstruction - See if we can compute a simplified version of this
|
|
/// instruction. If not, this returns null.
|
|
Value *SimplifyInstruction(Instruction *I, const DataLayout *TD = nullptr,
|
|
const TargetLibraryInfo *TLI = nullptr,
|
|
const DominatorTree *DT = nullptr,
|
|
AssumptionTracker *AT = nullptr);
|
|
|
|
|
|
/// \brief Replace all uses of 'I' with 'SimpleV' and simplify the uses
|
|
/// recursively.
|
|
///
|
|
/// 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'.
|
|
///
|
|
/// The function returns true if any simplifications were performed.
|
|
bool replaceAndRecursivelySimplify(Instruction *I, Value *SimpleV,
|
|
const DataLayout *TD = nullptr,
|
|
const TargetLibraryInfo *TLI = nullptr,
|
|
const DominatorTree *DT = nullptr,
|
|
AssumptionTracker *AT = nullptr);
|
|
|
|
/// \brief Recursively attempt to simplify an instruction.
|
|
///
|
|
/// This routine uses SimplifyInstruction to simplify 'I', and if successful
|
|
/// replaces uses of 'I' with the simplified value. It then recurses on each
|
|
/// of the users impacted. It returns true if any simplifications were
|
|
/// performed.
|
|
bool recursivelySimplifyInstruction(Instruction *I,
|
|
const DataLayout *TD = nullptr,
|
|
const TargetLibraryInfo *TLI = nullptr,
|
|
const DominatorTree *DT = nullptr,
|
|
AssumptionTracker *AT = nullptr);
|
|
} // end namespace llvm
|
|
|
|
#endif
|
|
|