Details | Last modification | View Log | RSS feed
| Rev | Author | Line No. | Line |
|---|---|---|---|
| 14 | pmbaty | 1 | //===- NoFolder.h - Constant folding helper ---------------------*- 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 defines the NoFolder class, a helper for IRBuilder. It provides |
||
| 10 | // IRBuilder with a set of methods for creating unfolded constants. This is |
||
| 11 | // useful for learners trying to understand how LLVM IR works, and who don't |
||
| 12 | // want details to be hidden by the constant folder. For general constant |
||
| 13 | // creation and folding, use ConstantExpr and the routines in |
||
| 14 | // llvm/Analysis/ConstantFolding.h. |
||
| 15 | // |
||
| 16 | // Note: since it is not actually possible to create unfolded constants, this |
||
| 17 | // class returns instructions rather than constants. |
||
| 18 | // |
||
| 19 | //===----------------------------------------------------------------------===// |
||
| 20 | |||
| 21 | #ifndef LLVM_IR_NOFOLDER_H |
||
| 22 | #define LLVM_IR_NOFOLDER_H |
||
| 23 | |||
| 24 | #include "llvm/ADT/ArrayRef.h" |
||
| 25 | #include "llvm/IR/Constants.h" |
||
| 26 | #include "llvm/IR/FMF.h" |
||
| 27 | #include "llvm/IR/IRBuilderFolder.h" |
||
| 28 | #include "llvm/IR/InstrTypes.h" |
||
| 29 | #include "llvm/IR/Instruction.h" |
||
| 30 | #include "llvm/IR/Instructions.h" |
||
| 31 | |||
| 32 | namespace llvm { |
||
| 33 | |||
| 34 | /// NoFolder - Create "constants" (actually, instructions) with no folding. |
||
| 35 | class NoFolder final : public IRBuilderFolder { |
||
| 36 | virtual void anchor(); |
||
| 37 | |||
| 38 | public: |
||
| 39 | explicit NoFolder() = default; |
||
| 40 | |||
| 41 | //===--------------------------------------------------------------------===// |
||
| 42 | // Value-based folders. |
||
| 43 | // |
||
| 44 | // Return an existing value or a constant if the operation can be simplified. |
||
| 45 | // Otherwise return nullptr. |
||
| 46 | //===--------------------------------------------------------------------===// |
||
| 47 | |||
| 48 | Value *FoldBinOp(Instruction::BinaryOps Opc, Value *LHS, |
||
| 49 | Value *RHS) const override { |
||
| 50 | return nullptr; |
||
| 51 | } |
||
| 52 | |||
| 53 | Value *FoldExactBinOp(Instruction::BinaryOps Opc, Value *LHS, Value *RHS, |
||
| 54 | bool IsExact) const override { |
||
| 55 | return nullptr; |
||
| 56 | } |
||
| 57 | |||
| 58 | Value *FoldNoWrapBinOp(Instruction::BinaryOps Opc, Value *LHS, Value *RHS, |
||
| 59 | bool HasNUW, bool HasNSW) const override { |
||
| 60 | return nullptr; |
||
| 61 | } |
||
| 62 | |||
| 63 | Value *FoldBinOpFMF(Instruction::BinaryOps Opc, Value *LHS, Value *RHS, |
||
| 64 | FastMathFlags FMF) const override { |
||
| 65 | return nullptr; |
||
| 66 | } |
||
| 67 | |||
| 68 | Value *FoldUnOpFMF(Instruction::UnaryOps Opc, Value *V, |
||
| 69 | FastMathFlags FMF) const override { |
||
| 70 | return nullptr; |
||
| 71 | } |
||
| 72 | |||
| 73 | Value *FoldICmp(CmpInst::Predicate P, Value *LHS, Value *RHS) const override { |
||
| 74 | return nullptr; |
||
| 75 | } |
||
| 76 | |||
| 77 | Value *FoldGEP(Type *Ty, Value *Ptr, ArrayRef<Value *> IdxList, |
||
| 78 | bool IsInBounds = false) const override { |
||
| 79 | return nullptr; |
||
| 80 | } |
||
| 81 | |||
| 82 | Value *FoldSelect(Value *C, Value *True, Value *False) const override { |
||
| 83 | return nullptr; |
||
| 84 | } |
||
| 85 | |||
| 86 | Value *FoldExtractValue(Value *Agg, |
||
| 87 | ArrayRef<unsigned> IdxList) const override { |
||
| 88 | return nullptr; |
||
| 89 | } |
||
| 90 | |||
| 91 | Value *FoldInsertValue(Value *Agg, Value *Val, |
||
| 92 | ArrayRef<unsigned> IdxList) const override { |
||
| 93 | return nullptr; |
||
| 94 | } |
||
| 95 | |||
| 96 | Value *FoldExtractElement(Value *Vec, Value *Idx) const override { |
||
| 97 | return nullptr; |
||
| 98 | } |
||
| 99 | |||
| 100 | Value *FoldInsertElement(Value *Vec, Value *NewElt, |
||
| 101 | Value *Idx) const override { |
||
| 102 | return nullptr; |
||
| 103 | } |
||
| 104 | |||
| 105 | Value *FoldShuffleVector(Value *V1, Value *V2, |
||
| 106 | ArrayRef<int> Mask) const override { |
||
| 107 | return nullptr; |
||
| 108 | } |
||
| 109 | |||
| 110 | //===--------------------------------------------------------------------===// |
||
| 111 | // Cast/Conversion Operators |
||
| 112 | //===--------------------------------------------------------------------===// |
||
| 113 | |||
| 114 | Instruction *CreateCast(Instruction::CastOps Op, Constant *C, |
||
| 115 | Type *DestTy) const override { |
||
| 116 | return CastInst::Create(Op, C, DestTy); |
||
| 117 | } |
||
| 118 | |||
| 119 | Instruction *CreatePointerCast(Constant *C, Type *DestTy) const override { |
||
| 120 | return CastInst::CreatePointerCast(C, DestTy); |
||
| 121 | } |
||
| 122 | |||
| 123 | Instruction *CreatePointerBitCastOrAddrSpaceCast( |
||
| 124 | Constant *C, Type *DestTy) const override { |
||
| 125 | return CastInst::CreatePointerBitCastOrAddrSpaceCast(C, DestTy); |
||
| 126 | } |
||
| 127 | |||
| 128 | Instruction *CreateIntCast(Constant *C, Type *DestTy, |
||
| 129 | bool isSigned) const override { |
||
| 130 | return CastInst::CreateIntegerCast(C, DestTy, isSigned); |
||
| 131 | } |
||
| 132 | |||
| 133 | Instruction *CreateFPCast(Constant *C, Type *DestTy) const override { |
||
| 134 | return CastInst::CreateFPCast(C, DestTy); |
||
| 135 | } |
||
| 136 | |||
| 137 | Instruction *CreateBitCast(Constant *C, Type *DestTy) const override { |
||
| 138 | return CreateCast(Instruction::BitCast, C, DestTy); |
||
| 139 | } |
||
| 140 | |||
| 141 | Instruction *CreateIntToPtr(Constant *C, Type *DestTy) const override { |
||
| 142 | return CreateCast(Instruction::IntToPtr, C, DestTy); |
||
| 143 | } |
||
| 144 | |||
| 145 | Instruction *CreatePtrToInt(Constant *C, Type *DestTy) const override { |
||
| 146 | return CreateCast(Instruction::PtrToInt, C, DestTy); |
||
| 147 | } |
||
| 148 | |||
| 149 | Instruction *CreateZExtOrBitCast(Constant *C, Type *DestTy) const override { |
||
| 150 | return CastInst::CreateZExtOrBitCast(C, DestTy); |
||
| 151 | } |
||
| 152 | |||
| 153 | Instruction *CreateSExtOrBitCast(Constant *C, Type *DestTy) const override { |
||
| 154 | return CastInst::CreateSExtOrBitCast(C, DestTy); |
||
| 155 | } |
||
| 156 | |||
| 157 | Instruction *CreateTruncOrBitCast(Constant *C, Type *DestTy) const override { |
||
| 158 | return CastInst::CreateTruncOrBitCast(C, DestTy); |
||
| 159 | } |
||
| 160 | |||
| 161 | //===--------------------------------------------------------------------===// |
||
| 162 | // Compare Instructions |
||
| 163 | //===--------------------------------------------------------------------===// |
||
| 164 | |||
| 165 | Instruction *CreateFCmp(CmpInst::Predicate P, |
||
| 166 | Constant *LHS, Constant *RHS) const override { |
||
| 167 | return new FCmpInst(P, LHS, RHS); |
||
| 168 | } |
||
| 169 | }; |
||
| 170 | |||
| 171 | } // end namespace llvm |
||
| 172 | |||
| 173 | #endif // LLVM_IR_NOFOLDER_H |