1
//===-- InstructionSimplify.h - Fold instructions into simpler forms ------===//
3
// The LLVM Compiler Infrastructure
5
// This file is distributed under the University of Illinois Open Source
6
// License. See LICENSE.TXT for details.
8
//===----------------------------------------------------------------------===//
10
// This file declares routines for folding instructions into simpler forms that
11
// do not require creating new instructions. For example, this does constant
12
// folding, and can handle identities like (X&0)->0.
14
//===----------------------------------------------------------------------===//
16
#ifndef LLVM_ANALYSIS_INSTRUCTIONSIMPLIFY_H
17
#define LLVM_ANALYSIS_INSTRUCTIONSIMPLIFY_H
24
/// SimplifyAddInst - Given operands for an Add, see if we can
25
/// fold the result. If not, this returns null.
26
Value *SimplifyAddInst(Value *LHS, Value *RHS, bool isNSW, bool isNUW,
27
const TargetData *TD = 0);
29
/// SimplifyAndInst - Given operands for an And, see if we can
30
/// fold the result. If not, this returns null.
31
Value *SimplifyAndInst(Value *LHS, Value *RHS,
32
const TargetData *TD = 0);
34
/// SimplifyOrInst - Given operands for an Or, see if we can
35
/// fold the result. If not, this returns null.
36
Value *SimplifyOrInst(Value *LHS, Value *RHS,
37
const TargetData *TD = 0);
39
/// SimplifyICmpInst - Given operands for an ICmpInst, see if we can
40
/// fold the result. If not, this returns null.
41
Value *SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS,
42
const TargetData *TD = 0);
44
/// SimplifyFCmpInst - Given operands for an FCmpInst, see if we can
45
/// fold the result. If not, this returns null.
46
Value *SimplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS,
47
const TargetData *TD = 0);
50
/// SimplifyGEPInst - Given operands for an GetElementPtrInst, see if we can
51
/// fold the result. If not, this returns null.
52
Value *SimplifyGEPInst(Value * const *Ops, unsigned NumOps,
53
const TargetData *TD = 0);
55
//=== Helper functions for higher up the class hierarchy.
58
/// SimplifyCmpInst - Given operands for a CmpInst, see if we can
59
/// fold the result. If not, this returns null.
60
Value *SimplifyCmpInst(unsigned Predicate, Value *LHS, Value *RHS,
61
const TargetData *TD = 0);
63
/// SimplifyBinOp - Given operands for a BinaryOperator, see if we can
64
/// fold the result. If not, this returns null.
65
Value *SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS,
66
const TargetData *TD = 0);
68
/// SimplifyInstruction - See if we can compute a simplified version of this
69
/// instruction. If not, this returns null.
70
Value *SimplifyInstruction(Instruction *I, const TargetData *TD = 0);
73
/// ReplaceAndSimplifyAllUses - Perform From->replaceAllUsesWith(To) and then
74
/// delete the From instruction. In addition to a basic RAUW, this does a
75
/// recursive simplification of the updated instructions. This catches
76
/// things where one simplification exposes other opportunities. This only
77
/// simplifies and deletes scalar operations, it does not change the CFG.
79
void ReplaceAndSimplifyAllUses(Instruction *From, Value *To,
80
const TargetData *TD = 0);
81
} // end namespace llvm