LLVM  15.0.0git
IRBuilderFolder.h
Go to the documentation of this file.
1 //===- IRBuilderFolder.h - Const folder interface for IRBuilder -*- 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 for constant folding interface used by IRBuilder.
10 // It is implemented by ConstantFolder (default), TargetFolder and NoFoler.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_IR_IRBUILDERFOLDER_H
15 #define LLVM_IR_IRBUILDERFOLDER_H
16 
17 #include "llvm/ADT/ArrayRef.h"
18 #include "llvm/IR/InstrTypes.h"
19 #include "llvm/IR/Instruction.h"
20 
21 namespace llvm {
22 
23 /// IRBuilderFolder - Interface for constant folding in IRBuilder.
25 public:
26  virtual ~IRBuilderFolder();
27 
28  //===--------------------------------------------------------------------===//
29  // Value-based folders.
30  //
31  // Return an existing value or a constant if the operation can be simplified.
32  // Otherwise return nullptr.
33  //===--------------------------------------------------------------------===//
34 
36  Value *RHS) const = 0;
37 
39  Value *RHS, bool IsExact) const = 0;
40 
42  Value *RHS, bool HasNUW,
43  bool HasNSW) const = 0;
44 
46  Value *RHS, FastMathFlags FMF) const = 0;
47 
49  Value *RHS) const = 0;
50 
51  virtual Value *FoldGEP(Type *Ty, Value *Ptr, ArrayRef<Value *> IdxList,
52  bool IsInBounds = false) const = 0;
53 
54  virtual Value *FoldSelect(Value *C, Value *True, Value *False) const = 0;
55 
56  virtual Value *FoldExtractValue(Value *Agg,
57  ArrayRef<unsigned> IdxList) const = 0;
58 
59  virtual Value *FoldInsertValue(Value *Agg, Value *Val,
60  ArrayRef<unsigned> IdxList) const = 0;
61 
62  virtual Value *FoldExtractElement(Value *Vec, Value *Idx) const = 0;
63 
64  virtual Value *FoldInsertElement(Value *Vec, Value *NewElt,
65  Value *Idx) const = 0;
66 
67  virtual Value *FoldShuffleVector(Value *V1, Value *V2,
68  ArrayRef<int> Mask) const = 0;
69 
70  //===--------------------------------------------------------------------===//
71  // Unary Operators
72  //===--------------------------------------------------------------------===//
73 
74  virtual Value *CreateFNeg(Constant *C) const = 0;
75  virtual Value *CreateUnOp(Instruction::UnaryOps Opc, Constant *C) const = 0;
76 
77  //===--------------------------------------------------------------------===//
78  // Cast/Conversion Operators
79  //===--------------------------------------------------------------------===//
80 
82  Type *DestTy) const = 0;
83  virtual Value *CreatePointerCast(Constant *C, Type *DestTy) const = 0;
85  Type *DestTy) const = 0;
86  virtual Value *CreateIntCast(Constant *C, Type *DestTy,
87  bool isSigned) const = 0;
88  virtual Value *CreateFPCast(Constant *C, Type *DestTy) const = 0;
89  virtual Value *CreateBitCast(Constant *C, Type *DestTy) const = 0;
90  virtual Value *CreateIntToPtr(Constant *C, Type *DestTy) const = 0;
91  virtual Value *CreatePtrToInt(Constant *C, Type *DestTy) const = 0;
92  virtual Value *CreateZExtOrBitCast(Constant *C, Type *DestTy) const = 0;
93  virtual Value *CreateSExtOrBitCast(Constant *C, Type *DestTy) const = 0;
94  virtual Value *CreateTruncOrBitCast(Constant *C, Type *DestTy) const = 0;
95 
96  //===--------------------------------------------------------------------===//
97  // Compare Instructions
98  //===--------------------------------------------------------------------===//
99 
101  Constant *RHS) const = 0;
102 };
103 
104 } // end namespace llvm
105 
106 #endif // LLVM_IR_IRBUILDERFOLDER_H
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
llvm::IRBuilderFolder::CreateFCmp
virtual Value * CreateFCmp(CmpInst::Predicate P, Constant *LHS, Constant *RHS) const =0
llvm::Instruction::UnaryOps
UnaryOps
Definition: Instruction.h:779
llvm::IRBuilderFolder::FoldNoWrapBinOp
virtual Value * FoldNoWrapBinOp(Instruction::BinaryOps Opc, Value *LHS, Value *RHS, bool HasNUW, bool HasNSW) const =0
llvm::IRBuilderFolder::CreateBitCast
virtual Value * CreateBitCast(Constant *C, Type *DestTy) const =0
llvm::CmpInst::Predicate
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:719
P
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from P
Definition: README-SSE.txt:411
llvm::IRBuilderFolder
IRBuilderFolder - Interface for constant folding in IRBuilder.
Definition: IRBuilderFolder.h:24
llvm::IRBuilderFolder::FoldBinOp
virtual Value * FoldBinOp(Instruction::BinaryOps Opc, Value *LHS, Value *RHS) const =0
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
llvm::IRBuilderFolder::FoldInsertElement
virtual Value * FoldInsertElement(Value *Vec, Value *NewElt, Value *Idx) const =0
RHS
Value * RHS
Definition: X86PartialReduction.cpp:76
llvm::FastMathFlags
Convenience struct for specifying and reasoning about fast-math flags.
Definition: FMF.h:21
llvm::IRBuilderFolder::CreateIntCast
virtual Value * CreateIntCast(Constant *C, Type *DestTy, bool isSigned) const =0
llvm::BitmaskEnumDetail::Mask
constexpr std::underlying_type_t< E > Mask()
Get a bitmask with 1s in all places up to the high-order bit of E's largest value.
Definition: BitmaskEnum.h:80
Instruction.h
LHS
Value * LHS
Definition: X86PartialReduction.cpp:75
llvm::IRBuilderFolder::CreatePointerBitCastOrAddrSpaceCast
virtual Value * CreatePointerBitCastOrAddrSpaceCast(Constant *C, Type *DestTy) const =0
llvm::IRBuilderFolder::FoldSelect
virtual Value * FoldSelect(Value *C, Value *True, Value *False) const =0
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
InstrTypes.h
llvm::Instruction::CastOps
CastOps
Definition: Instruction.h:800
llvm::IRBuilderFolder::CreateCast
virtual Value * CreateCast(Instruction::CastOps Op, Constant *C, Type *DestTy) const =0
llvm::IRBuilderFolder::CreateZExtOrBitCast
virtual Value * CreateZExtOrBitCast(Constant *C, Type *DestTy) const =0
llvm::IRBuilderFolder::CreateFPCast
virtual Value * CreateFPCast(Constant *C, Type *DestTy) const =0
llvm::Constant
This is an important base class in LLVM.
Definition: Constant.h:41
llvm::IRBuilderFolder::CreateTruncOrBitCast
virtual Value * CreateTruncOrBitCast(Constant *C, Type *DestTy) const =0
llvm::IRBuilderFolder::FoldExtractValue
virtual Value * FoldExtractValue(Value *Agg, ArrayRef< unsigned > IdxList) const =0
llvm::IRBuilderFolder::CreateIntToPtr
virtual Value * CreateIntToPtr(Constant *C, Type *DestTy) const =0
llvm::IRBuilderFolder::FoldShuffleVector
virtual Value * FoldShuffleVector(Value *V1, Value *V2, ArrayRef< int > Mask) const =0
ArrayRef.h
llvm::IRBuilderFolder::FoldICmp
virtual Value * FoldICmp(CmpInst::Predicate P, Value *LHS, Value *RHS) const =0
llvm::IRBuilderFolder::CreatePtrToInt
virtual Value * CreatePtrToInt(Constant *C, Type *DestTy) const =0
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: APInt.h:32
llvm::IRBuilderFolder::CreatePointerCast
virtual Value * CreatePointerCast(Constant *C, Type *DestTy) const =0
llvm::IRBuilderFolder::CreateSExtOrBitCast
virtual Value * CreateSExtOrBitCast(Constant *C, Type *DestTy) const =0
llvm::NVPTX::PTXLdStInstCode::V2
@ V2
Definition: NVPTX.h:123
llvm::IRBuilderFolder::CreateFNeg
virtual Value * CreateFNeg(Constant *C) const =0
llvm::AMDGPU::SendMsg::Op
Op
Definition: SIDefines.h:348
llvm::IRBuilderFolder::FoldBinOpFMF
virtual Value * FoldBinOpFMF(Instruction::BinaryOps Opc, Value *LHS, Value *RHS, FastMathFlags FMF) const =0
llvm::IRBuilderFolder::~IRBuilderFolder
virtual ~IRBuilderFolder()
llvm::IRBuilderFolder::FoldInsertValue
virtual Value * FoldInsertValue(Value *Agg, Value *Val, ArrayRef< unsigned > IdxList) const =0
llvm::Instruction::BinaryOps
BinaryOps
Definition: Instruction.h:786
llvm::IRBuilderFolder::FoldGEP
virtual Value * FoldGEP(Type *Ty, Value *Ptr, ArrayRef< Value * > IdxList, bool IsInBounds=false) const =0
llvm::IRBuilderFolder::CreateUnOp
virtual Value * CreateUnOp(Instruction::UnaryOps Opc, Constant *C) const =0
llvm::IRBuilderFolder::FoldExactBinOp
virtual Value * FoldExactBinOp(Instruction::BinaryOps Opc, Value *LHS, Value *RHS, bool IsExact) const =0
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
llvm::IRBuilderFolder::FoldExtractElement
virtual Value * FoldExtractElement(Value *Vec, Value *Idx) const =0