ConstantFolding.h revision 63f3ca5da75a614c603c04757edeaac123879d39 
1//===-- ConstantFolding.h - Fold instructions into constants ----*- C++ -*-===//
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// DataLayout 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 DataLayout;
28  class TargetLibraryInfo;
29  class Function;
30  class Type;
31  template<typename T>
32  class ArrayRef;
33
34/// ConstantFoldInstruction - Try to constant fold the specified instruction.
35/// If successful, the constant result is returned, if not, null is returned.
36/// Note that this fails if not all of the operands are constant.  Otherwise,
37/// this function can only fail when attempting to fold instructions like loads
38/// and stores, which have no constant expression form.
39Constant *ConstantFoldInstruction(Instruction *I, const DataLayout *TD = 0,
40                                  const TargetLibraryInfo *TLI = 0);
41
42/// ConstantFoldConstantExpression - Attempt to fold the constant expression
43/// using the specified DataLayout.  If successful, the constant result is
44/// result is returned, if not, null is returned.
45Constant *ConstantFoldConstantExpression(const ConstantExpr *CE,
46                                         const DataLayout *TD = 0,
47                                         const TargetLibraryInfo *TLI = 0);
48
49/// ConstantFoldInstOperands - Attempt to constant fold an instruction with the
50/// specified operands.  If successful, the constant result is returned, if not,
51/// null is returned.  Note that this function can fail when attempting to
52/// fold instructions like loads and stores, which have no constant expression
53/// form.
54///
55Constant *ConstantFoldInstOperands(unsigned Opcode, Type *DestTy,
56                                   ArrayRef<Constant *> Ops,
57                                   const DataLayout *TD = 0,
58                                   const TargetLibraryInfo *TLI = 0);
59
60/// ConstantFoldCompareInstOperands - Attempt to constant fold a compare
61/// instruction (icmp/fcmp) with the specified operands.  If it fails, it
62/// returns a constant expression of the specified operands.
63///
64Constant *ConstantFoldCompareInstOperands(unsigned Predicate,
65                                          Constant *LHS, Constant *RHS,
66                                          const DataLayout *TD = 0,
67                                          const TargetLibraryInfo *TLI = 0);
68
69/// ConstantFoldInsertValueInstruction - Attempt to constant fold an insertvalue
70/// instruction with the specified operands and indices.  The constant result is
71/// returned if successful; if not, null is returned.
72Constant *ConstantFoldInsertValueInstruction(Constant *Agg, Constant *Val,
73                                             ArrayRef<unsigned> Idxs);
74
75/// ConstantFoldLoadFromConstPtr - Return the value that a load from C would
76/// produce if it is constant and determinable.  If this is not determinable,
77/// return null.
78Constant *ConstantFoldLoadFromConstPtr(Constant *C, const DataLayout *TD = 0);
79
80/// ConstantFoldLoadThroughGEPConstantExpr - Given a constant and a
81/// getelementptr constantexpr, return the constant value being addressed by the
82/// constant expression, or null if something is funny and we can't decide.
83Constant *ConstantFoldLoadThroughGEPConstantExpr(Constant *C, ConstantExpr *CE);
84
85/// ConstantFoldLoadThroughGEPIndices - Given a constant and getelementptr
86/// indices (with an *implied* zero pointer index that is not in the list),
87/// return the constant value being addressed by a virtual load, or null if
88/// something is funny and we can't decide.
89Constant *ConstantFoldLoadThroughGEPIndices(Constant *C,
90                                            ArrayRef<Constant*> Indices);
91
92/// canConstantFoldCallTo - Return true if its even possible to fold a call to
93/// the specified function.
94bool canConstantFoldCallTo(const Function *F);
95
96/// ConstantFoldCall - Attempt to constant fold a call to the specified function
97/// with the specified arguments, returning null if unsuccessful.
98Constant *ConstantFoldCall(Function *F, ArrayRef<Constant *> Operands,
99                           const TargetLibraryInfo *TLI = 0);
100}
101
102#endif
103