ConstantFolding.h revision 8f73deaa8732a556046bf4ac6207be55972e3b74
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(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