llvm / llvm / 751cb63424670a8c53e1dc937691af413eb4d772 / . / include / llvm / Analysis / ConstantFolding.h

//===-- ConstantFolding.h - Fold instructions into constants ----*- C++ -*-===// | |

// | |

// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | |

// See https://llvm.org/LICENSE.txt for license information. | |

// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | |

// | |

//===----------------------------------------------------------------------===// | |

// | |

// This file declares routines for folding instructions into constants when all | |

// operands are constants, for example "sub i32 1, 0" -> "1". | |

// | |

// Also, to supplement the basic VMCore ConstantExpr simplifications, | |

// this file declares some additional folding routines that can make use of | |

// DataLayout information. These functions cannot go in VMCore due to library | |

// dependency issues. | |

// | |

//===----------------------------------------------------------------------===// | |

#ifndef LLVM_ANALYSIS_CONSTANTFOLDING_H | |

#define LLVM_ANALYSIS_CONSTANTFOLDING_H | |

namespace llvm { | |

class APInt; | |

template <typename T> class ArrayRef; | |

class CallBase; | |

class Constant; | |

class ConstantExpr; | |

class ConstantVector; | |

class DataLayout; | |

class Function; | |

class GlobalValue; | |

class Instruction; | |

class TargetLibraryInfo; | |

class Type; | |

/// If this constant is a constant offset from a global, return the global and | |

/// the constant. Because of constantexprs, this function is recursive. | |

bool IsConstantOffsetFromGlobal(Constant *C, GlobalValue *&GV, APInt &Offset, | |

const DataLayout &DL); | |

/// ConstantFoldInstruction - Try to constant fold the specified instruction. | |

/// If successful, the constant result is returned, if not, null is returned. | |

/// Note that this fails if not all of the operands are constant. Otherwise, | |

/// this function can only fail when attempting to fold instructions like loads | |

/// and stores, which have no constant expression form. | |

Constant *ConstantFoldInstruction(Instruction *I, const DataLayout &DL, | |

const TargetLibraryInfo *TLI = nullptr); | |

/// ConstantFoldConstant - Attempt to fold the constant using the | |

/// specified DataLayout. | |

/// If successful, the constant result is returned, if not, null is returned. | |

Constant *ConstantFoldConstant(const Constant *C, const DataLayout &DL, | |

const TargetLibraryInfo *TLI = nullptr); | |

/// ConstantFoldInstOperands - Attempt to constant fold an instruction with the | |

/// specified operands. If successful, the constant result is returned, if not, | |

/// null is returned. Note that this function can fail when attempting to | |

/// fold instructions like loads and stores, which have no constant expression | |

/// form. | |

/// | |

Constant *ConstantFoldInstOperands(Instruction *I, ArrayRef<Constant *> Ops, | |

const DataLayout &DL, | |

const TargetLibraryInfo *TLI = nullptr); | |

/// ConstantFoldCompareInstOperands - Attempt to constant fold a compare | |

/// instruction (icmp/fcmp) with the specified operands. If it fails, it | |

/// returns a constant expression of the specified operands. | |

/// | |

Constant * | |

ConstantFoldCompareInstOperands(unsigned Predicate, Constant *LHS, | |

Constant *RHS, const DataLayout &DL, | |

const TargetLibraryInfo *TLI = nullptr); | |

/// Attempt to constant fold a binary operation with the specified | |

/// operands. If it fails, it returns a constant expression of the specified | |

/// operands. | |

Constant *ConstantFoldBinaryOpOperands(unsigned Opcode, Constant *LHS, | |

Constant *RHS, const DataLayout &DL); | |

/// Attempt to constant fold a select instruction with the specified | |

/// operands. The constant result is returned if successful; if not, null is | |

/// returned. | |

Constant *ConstantFoldSelectInstruction(Constant *Cond, Constant *V1, | |

Constant *V2); | |

/// Attempt to constant fold a cast with the specified operand. If it | |

/// fails, it returns a constant expression of the specified operand. | |

Constant *ConstantFoldCastOperand(unsigned Opcode, Constant *C, Type *DestTy, | |

const DataLayout &DL); | |

/// ConstantFoldInsertValueInstruction - Attempt to constant fold an insertvalue | |

/// instruction with the specified operands and indices. The constant result is | |

/// returned if successful; if not, null is returned. | |

Constant *ConstantFoldInsertValueInstruction(Constant *Agg, Constant *Val, | |

ArrayRef<unsigned> Idxs); | |

/// Attempt to constant fold an extractvalue instruction with the | |

/// specified operands and indices. The constant result is returned if | |

/// successful; if not, null is returned. | |

Constant *ConstantFoldExtractValueInstruction(Constant *Agg, | |

ArrayRef<unsigned> Idxs); | |

/// Attempt to constant fold an insertelement instruction with the | |

/// specified operands and indices. The constant result is returned if | |

/// successful; if not, null is returned. | |

Constant *ConstantFoldInsertElementInstruction(Constant *Val, | |

Constant *Elt, | |

Constant *Idx); | |

/// Attempt to constant fold an extractelement instruction with the | |

/// specified operands and indices. The constant result is returned if | |

/// successful; if not, null is returned. | |

Constant *ConstantFoldExtractElementInstruction(Constant *Val, Constant *Idx); | |

/// Attempt to constant fold a shufflevector instruction with the | |

/// specified operands and indices. The constant result is returned if | |

/// successful; if not, null is returned. | |

Constant *ConstantFoldShuffleVectorInstruction(Constant *V1, Constant *V2, | |

Constant *Mask); | |

/// ConstantFoldLoadFromConstPtr - Return the value that a load from C would | |

/// produce if it is constant and determinable. If this is not determinable, | |

/// return null. | |

Constant *ConstantFoldLoadFromConstPtr(Constant *C, Type *Ty, const DataLayout &DL); | |

/// ConstantFoldLoadThroughGEPConstantExpr - Given a constant and a | |

/// getelementptr constantexpr, return the constant value being addressed by the | |

/// constant expression, or null if something is funny and we can't decide. | |

Constant *ConstantFoldLoadThroughGEPConstantExpr(Constant *C, ConstantExpr *CE); | |

/// ConstantFoldLoadThroughGEPIndices - Given a constant and getelementptr | |

/// indices (with an *implied* zero pointer index that is not in the list), | |

/// return the constant value being addressed by a virtual load, or null if | |

/// something is funny and we can't decide. | |

Constant *ConstantFoldLoadThroughGEPIndices(Constant *C, | |

ArrayRef<Constant *> Indices); | |

/// canConstantFoldCallTo - Return true if its even possible to fold a call to | |

/// the specified function. | |

bool canConstantFoldCallTo(const CallBase *Call, const Function *F); | |

/// ConstantFoldCall - Attempt to constant fold a call to the specified function | |

/// with the specified arguments, returning null if unsuccessful. | |

Constant *ConstantFoldCall(const CallBase *Call, Function *F, | |

ArrayRef<Constant *> Operands, | |

const TargetLibraryInfo *TLI = nullptr); | |

/// ConstantFoldLoadThroughBitcast - try to cast constant to destination type | |

/// returning null if unsuccessful. Can cast pointer to pointer or pointer to | |

/// integer and vice versa if their sizes are equal. | |

Constant *ConstantFoldLoadThroughBitcast(Constant *C, Type *DestTy, | |

const DataLayout &DL); | |

/// Check whether the given call has no side-effects. | |

/// Specifically checks for math routimes which sometimes set errno. | |

bool isMathLibCallNoop(const CallBase *Call, const TargetLibraryInfo *TLI); | |

} | |

#endif |