ConstantFolding.h revision db125cfaf57cc83e7dd7453de2d509bc8efd0e5e 
1//===-- ConstantFolding.h - Fold instructions into constants --------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This file declares routines for folding instructions into constants when all
11// operands are constants, for example "sub i32 1, 0" -> "1".
12//
13// Also, to supplement the basic VMCore ConstantExpr simplifications,
14// this file declares some additional folding routines that can make use of
15// TargetData information. These functions cannot go in VMCore due to library
16// dependency issues.
17//
18//===----------------------------------------------------------------------===//
19
20#ifndef LLVM_ANALYSIS_CONSTANTFOLDING_H
21#define LLVM_ANALYSIS_CONSTANTFOLDING_H
22
23namespace llvm {
24  class Constant;
25  class ConstantExpr;
26  class Instruction;
27  class TargetData;
28  class Function;
29  class Type;
30
31/// ConstantFoldInstruction - Try to constant fold the specified instruction.
32/// If successful, the constant result is returned, if not, null is returned.
33/// Note that this fails if not all of the operands are constant.  Otherwise,
34/// this function can only fail when attempting to fold instructions like loads
35/// and stores, which have no constant expression form.
36Constant *ConstantFoldInstruction(Instruction *I, const TargetData *TD = 0);
37
38/// ConstantFoldConstantExpression - Attempt to fold the constant expression
39/// using the specified TargetData.  If successful, the constant result is
40/// result is returned, if not, null is returned.
41Constant *ConstantFoldConstantExpression(const ConstantExpr *CE,
42                                         const TargetData *TD = 0);
43
44/// ConstantFoldInstOperands - Attempt to constant fold an instruction with the
45/// specified operands.  If successful, the constant result is returned, if not,
46/// null is returned.  Note that this function can fail when attempting to
47/// fold instructions like loads and stores, which have no constant expression
48/// form.
49///
50Constant *ConstantFoldInstOperands(unsigned Opcode, Type *DestTy,
51                                   Constant *const *Ops, unsigned NumOps,
52                                   const TargetData *TD = 0);
53
54/// ConstantFoldCompareInstOperands - Attempt to constant fold a compare
55/// instruction (icmp/fcmp) with the specified operands.  If it fails, it
56/// returns a constant expression of the specified operands.
57///
58Constant *ConstantFoldCompareInstOperands(unsigned Predicate,
59                                          Constant *LHS, Constant *RHS,
60                                          const TargetData *TD = 0);
61
62/// ConstantFoldLoadFromConstPtr - Return the value that a load from C would
63/// produce if it is constant and determinable.  If this is not determinable,
64/// return null.
65Constant *ConstantFoldLoadFromConstPtr(Constant *C, const TargetData *TD = 0);
66
67/// ConstantFoldLoadThroughGEPConstantExpr - Given a constant and a
68/// getelementptr constantexpr, return the constant value being addressed by the
69/// constant expression, or null if something is funny and we can't decide.
70Constant *ConstantFoldLoadThroughGEPConstantExpr(Constant *C, ConstantExpr *CE);
71
72/// canConstantFoldCallTo - Return true if its even possible to fold a call to
73/// the specified function.
74bool canConstantFoldCallTo(const Function *F);
75
76/// ConstantFoldCall - Attempt to constant fold a call to the specified function
77/// with the specified arguments, returning null if unsuccessful.
78Constant *
79ConstantFoldCall(Function *F, Constant *const *Operands, unsigned NumOperands);
80}
81
82#endif
83