LLVM 20.0.0git
VectorBuilder.h
Go to the documentation of this file.
1//===- llvm/VectorBuilder.h - Builder for VP Intrinsics ---------*- 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 VectorBuilder class, which is used as a convenient way
10// to create VP intrinsics as if they were LLVM instructions with a consistent
11// and simplified interface.
12//
13//===----------------------------------------------------------------------===//
14
15#ifndef LLVM_IR_VECTORBUILDER_H
16#define LLVM_IR_VECTORBUILDER_H
17
18#include <llvm/IR/IRBuilder.h>
19#include <llvm/IR/InstrTypes.h>
20#include <llvm/IR/Instruction.h>
21#include <llvm/IR/Value.h>
22
23namespace llvm {
24
26public:
27 enum class Behavior {
28 // Abort if the requested VP intrinsic could not be created.
29 // This is useful for strict consistency.
31
32 // Return a default-initialized value if the requested VP intrinsic could
33 // not be created.
34 // This is useful for a defensive fallback to non-VP code.
36 };
37
38private:
39 IRBuilderBase &Builder;
40 Behavior ErrorHandling;
41
42 // Explicit mask parameter.
43 Value *Mask;
44 // Explicit vector length parameter.
45 Value *ExplicitVectorLength;
46 // Compile-time vector length.
47 ElementCount StaticVectorLength;
48
49 // Get mask/evl value handles for the current configuration.
50 Value &requestMask();
51 Value &requestEVL();
52
53 void handleError(const char *ErrorMsg) const;
54 template <typename RetType>
55 RetType returnWithError(const char *ErrorMsg) const {
56 handleError(ErrorMsg);
57 return RetType();
58 }
59
60 /// Helper function for creating VP intrinsic call.
61 Value *createVectorInstructionImpl(Intrinsic::ID VPID, Type *ReturnTy,
62 ArrayRef<Value *> VecOpArray,
63 const Twine &Name = Twine());
64
65public:
67 Behavior ErrorHandling = Behavior::ReportAndAbort)
68 : Builder(Builder), ErrorHandling(ErrorHandling), Mask(nullptr),
69 ExplicitVectorLength(nullptr),
70 StaticVectorLength(ElementCount::getFixed(0)) {}
71
72 Module &getModule() const;
73 LLVMContext &getContext() const { return Builder.getContext(); }
74
75 // All-true mask for the currently configured explicit vector length.
77
79 Mask = NewMask;
80 return *this;
81 }
82 VectorBuilder &setEVL(Value *NewExplicitVectorLength) {
83 ExplicitVectorLength = NewExplicitVectorLength;
84 return *this;
85 }
86 VectorBuilder &setStaticVL(unsigned NewFixedVL) {
87 StaticVectorLength = ElementCount::getFixed(NewFixedVL);
88 return *this;
89 }
90 // TODO: setStaticVL(ElementCount) for scalable types.
91
92 // Emit a VP intrinsic call that mimics a regular instruction.
93 // This operation behaves according to the VectorBuilderBehavior.
94 // \p Opcode The functional instruction opcode of the emitted intrinsic.
95 // \p ReturnTy The return type of the operation.
96 // \p VecOpArray The operand list.
97 Value *createVectorInstruction(unsigned Opcode, Type *ReturnTy,
98 ArrayRef<Value *> VecOpArray,
99 const Twine &Name = Twine());
100
101 /// Emit a VP reduction intrinsic call for recurrence kind.
102 /// \param RdxID The intrinsic ID of llvm.vector.reduce.*
103 /// \param ValTy The type of operand which the reduction operation is
104 /// performed.
105 /// \param VecOpArray The operand list.
107 ArrayRef<Value *> VecOpArray,
108 const Twine &Name = Twine());
109};
110
111} // namespace llvm
112
113#endif // LLVM_IR_VECTORBUILDER_H
std::string Name
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
static constexpr ElementCount getFixed(ScalarTy MinVal)
Definition: TypeSize.h:311
Common base class shared among various IRBuilders.
Definition: IRBuilder.h:91
LLVMContext & getContext() const
Definition: IRBuilder.h:173
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:67
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
LLVM Value Representation.
Definition: Value.h:74
LLVMContext & getContext() const
Definition: VectorBuilder.h:73
VectorBuilder(IRBuilderBase &Builder, Behavior ErrorHandling=Behavior::ReportAndAbort)
Definition: VectorBuilder.h:66
VectorBuilder & setStaticVL(unsigned NewFixedVL)
Definition: VectorBuilder.h:86
VectorBuilder & setEVL(Value *NewExplicitVectorLength)
Definition: VectorBuilder.h:82
Module & getModule() const
VectorBuilder & setMask(Value *NewMask)
Definition: VectorBuilder.h:78
Value * createSimpleTargetReduction(Intrinsic::ID RdxID, Type *ValTy, ArrayRef< Value * > VecOpArray, const Twine &Name=Twine())
Emit a VP reduction intrinsic call for recurrence kind.
Value * createVectorInstruction(unsigned Opcode, Type *ReturnTy, ArrayRef< Value * > VecOpArray, const Twine &Name=Twine())
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18