1 | //===-- ConstantFolding.h - Fold instructions into constants ----*- C++ -*-===// |
2 | // |
3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | // See https://llvm.org/LICENSE.txt for license information. |
5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | // |
7 | //===----------------------------------------------------------------------===// |
8 | // |
9 | // This file declares routines for folding instructions into constants when all |
10 | // operands are constants, for example "sub i32 1, 0" -> "1". |
11 | // |
12 | // Also, to supplement the basic VMCore ConstantExpr simplifications, |
13 | // this file declares some additional folding routines that can make use of |
14 | // DataLayout 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 | |
22 | #include <stdint.h> |
23 | |
24 | namespace llvm { |
25 | class APInt; |
26 | template <typename T> class ArrayRef; |
27 | class CallBase; |
28 | class Constant; |
29 | class DSOLocalEquivalent; |
30 | class DataLayout; |
31 | class Function; |
32 | class GlobalValue; |
33 | class GlobalVariable; |
34 | class Instruction; |
35 | class TargetLibraryInfo; |
36 | class Type; |
37 | |
38 | /// If this constant is a constant offset from a global, return the global and |
39 | /// the constant. Because of constantexprs, this function is recursive. |
40 | /// If the global is part of a dso_local_equivalent constant, return it through |
41 | /// `Equiv` if it is provided. |
42 | bool IsConstantOffsetFromGlobal(Constant *C, GlobalValue *&GV, APInt &Offset, |
43 | const DataLayout &DL, |
44 | DSOLocalEquivalent **DSOEquiv = nullptr); |
45 | |
46 | /// ConstantFoldInstruction - Try to constant fold the specified instruction. |
47 | /// If successful, the constant result is returned, if not, null is returned. |
48 | /// Note that this fails if not all of the operands are constant. Otherwise, |
49 | /// this function can only fail when attempting to fold instructions like loads |
50 | /// and stores, which have no constant expression form. |
51 | Constant *ConstantFoldInstruction(Instruction *I, const DataLayout &DL, |
52 | const TargetLibraryInfo *TLI = nullptr); |
53 | |
54 | /// ConstantFoldConstant - Fold the constant using the specified DataLayout. |
55 | /// This function always returns a non-null constant: Either the folding result, |
56 | /// or the original constant if further folding is not possible. |
57 | Constant *ConstantFoldConstant(const Constant *C, const DataLayout &DL, |
58 | const TargetLibraryInfo *TLI = nullptr); |
59 | |
60 | /// ConstantFoldInstOperands - Attempt to constant fold an instruction with the |
61 | /// specified operands. If successful, the constant result is returned, if not, |
62 | /// null is returned. Note that this function can fail when attempting to |
63 | /// fold instructions like loads and stores, which have no constant expression |
64 | /// form. |
65 | /// |
66 | Constant *ConstantFoldInstOperands(Instruction *I, ArrayRef<Constant *> Ops, |
67 | const DataLayout &DL, |
68 | const TargetLibraryInfo *TLI = nullptr); |
69 | |
70 | /// Attempt to constant fold a compare instruction (icmp/fcmp) with the |
71 | /// specified operands. Returns null or a constant expression of the specified |
72 | /// operands on failure. |
73 | /// Denormal inputs may be flushed based on the denormal handling mode. |
74 | Constant *ConstantFoldCompareInstOperands( |
75 | unsigned Predicate, Constant *LHS, Constant *RHS, const DataLayout &DL, |
76 | const TargetLibraryInfo *TLI = nullptr, const Instruction *I = nullptr); |
77 | |
78 | /// Attempt to constant fold a unary operation with the specified operand. |
79 | /// Returns null on failure. |
80 | Constant *ConstantFoldUnaryOpOperand(unsigned Opcode, Constant *Op, |
81 | const DataLayout &DL); |
82 | |
83 | /// Attempt to constant fold a binary operation with the specified operands. |
84 | /// Returns null or a constant expression of the specified operands on failure. |
85 | Constant *ConstantFoldBinaryOpOperands(unsigned Opcode, Constant *LHS, |
86 | Constant *RHS, const DataLayout &DL); |
87 | |
88 | /// Attempt to constant fold a floating point binary operation with the |
89 | /// specified operands, applying the denormal handling mod to the operands. |
90 | /// Returns null or a constant expression of the specified operands on failure. |
91 | Constant *ConstantFoldFPInstOperands(unsigned Opcode, Constant *LHS, |
92 | Constant *RHS, const DataLayout &DL, |
93 | const Instruction *I); |
94 | |
95 | /// Attempt to flush float point constant according to denormal mode set in the |
96 | /// instruction's parent function attributes. If so, return a zero with the |
97 | /// correct sign, otherwise return the original constant. Inputs and outputs to |
98 | /// floating point instructions can have their mode set separately, so the |
99 | /// direction is also needed. |
100 | /// |
101 | /// If the calling function's "denormal-fp-math" input mode is "dynamic" for the |
102 | /// floating-point type, returns nullptr for denormal inputs. |
103 | Constant *FlushFPConstant(Constant *Operand, const Instruction *I, |
104 | bool IsOutput); |
105 | |
106 | /// Attempt to constant fold a select instruction with the specified |
107 | /// operands. The constant result is returned if successful; if not, null is |
108 | /// returned. |
109 | Constant *ConstantFoldSelectInstruction(Constant *Cond, Constant *V1, |
110 | Constant *V2); |
111 | |
112 | /// Attempt to constant fold a cast with the specified operand. If it |
113 | /// fails, it returns a constant expression of the specified operand. |
114 | Constant *ConstantFoldCastOperand(unsigned Opcode, Constant *C, Type *DestTy, |
115 | const DataLayout &DL); |
116 | |
117 | /// Constant fold a zext, sext or trunc, depending on IsSigned and whether the |
118 | /// DestTy is wider or narrower than C. Returns nullptr on failure. |
119 | Constant *ConstantFoldIntegerCast(Constant *C, Type *DestTy, bool IsSigned, |
120 | const DataLayout &DL); |
121 | |
122 | /// ConstantFoldInsertValueInstruction - Attempt to constant fold an insertvalue |
123 | /// instruction with the specified operands and indices. The constant result is |
124 | /// returned if successful; if not, null is returned. |
125 | Constant *ConstantFoldInsertValueInstruction(Constant *Agg, Constant *Val, |
126 | ArrayRef<unsigned> Idxs); |
127 | |
128 | /// Attempt to constant fold an extractvalue instruction with the |
129 | /// specified operands and indices. The constant result is returned if |
130 | /// successful; if not, null is returned. |
131 | Constant *(Constant *Agg, |
132 | ArrayRef<unsigned> Idxs); |
133 | |
134 | /// Attempt to constant fold an insertelement instruction with the |
135 | /// specified operands and indices. The constant result is returned if |
136 | /// successful; if not, null is returned. |
137 | Constant *ConstantFoldInsertElementInstruction(Constant *Val, |
138 | Constant *Elt, |
139 | Constant *Idx); |
140 | |
141 | /// Attempt to constant fold an extractelement instruction with the |
142 | /// specified operands and indices. The constant result is returned if |
143 | /// successful; if not, null is returned. |
144 | Constant *(Constant *Val, Constant *Idx); |
145 | |
146 | /// Attempt to constant fold a shufflevector instruction with the |
147 | /// specified operands and mask. See class ShuffleVectorInst for a description |
148 | /// of the mask representation. The constant result is returned if successful; |
149 | /// if not, null is returned. |
150 | Constant *ConstantFoldShuffleVectorInstruction(Constant *V1, Constant *V2, |
151 | ArrayRef<int> Mask); |
152 | |
153 | /// Extract value of C at the given Offset reinterpreted as Ty. If bits past |
154 | /// the end of C are accessed, they are assumed to be poison. |
155 | Constant *ConstantFoldLoadFromConst(Constant *C, Type *Ty, const APInt &Offset, |
156 | const DataLayout &DL); |
157 | |
158 | /// Extract value of C reinterpreted as Ty. Same as previous API with zero |
159 | /// offset. |
160 | Constant *ConstantFoldLoadFromConst(Constant *C, Type *Ty, |
161 | const DataLayout &DL); |
162 | |
163 | /// Return the value that a load from C with offset Offset would produce if it |
164 | /// is constant and determinable. If this is not determinable, return null. |
165 | Constant *ConstantFoldLoadFromConstPtr(Constant *C, Type *Ty, APInt Offset, |
166 | const DataLayout &DL); |
167 | |
168 | /// Return the value that a load from C would produce if it is constant and |
169 | /// determinable. If this is not determinable, return null. |
170 | Constant *ConstantFoldLoadFromConstPtr(Constant *C, Type *Ty, |
171 | const DataLayout &DL); |
172 | |
173 | /// If C is a uniform value where all bits are the same (either all zero, all |
174 | /// ones, all undef or all poison), return the corresponding uniform value in |
175 | /// the new type. If the value is not uniform or the result cannot be |
176 | /// represented, return null. |
177 | Constant *ConstantFoldLoadFromUniformValue(Constant *C, Type *Ty); |
178 | |
179 | /// canConstantFoldCallTo - Return true if its even possible to fold a call to |
180 | /// the specified function. |
181 | bool canConstantFoldCallTo(const CallBase *Call, const Function *F); |
182 | |
183 | /// ConstantFoldCall - Attempt to constant fold a call to the specified function |
184 | /// with the specified arguments, returning null if unsuccessful. |
185 | Constant *ConstantFoldCall(const CallBase *Call, Function *F, |
186 | ArrayRef<Constant *> Operands, |
187 | const TargetLibraryInfo *TLI = nullptr); |
188 | |
189 | /// ConstantFoldLoadThroughBitcast - try to cast constant to destination type |
190 | /// returning null if unsuccessful. Can cast pointer to pointer or pointer to |
191 | /// integer and vice versa if their sizes are equal. |
192 | Constant *ConstantFoldLoadThroughBitcast(Constant *C, Type *DestTy, |
193 | const DataLayout &DL); |
194 | |
195 | /// Check whether the given call has no side-effects. |
196 | /// Specifically checks for math routimes which sometimes set errno. |
197 | bool isMathLibCallNoop(const CallBase *Call, const TargetLibraryInfo *TLI); |
198 | |
199 | Constant *ReadByteArrayFromGlobal(const GlobalVariable *GV, uint64_t Offset); |
200 | } |
201 | |
202 | #endif |
203 | |