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