1 //===- Intrinsics.h - LLVM Intrinsic Function Handling ----------*- 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 a set of enums which allow processing of intrinsic
10 // functions.  Values of these enum types are returned by
11 // Function::getIntrinsicID.
12 //
13 //===----------------------------------------------------------------------===//
14 
15 #ifndef LLVM_IR_INTRINSICS_H
16 #define LLVM_IR_INTRINSICS_H
17 
18 #include "llvm/ADT/ArrayRef.h"
19 #include "llvm/ADT/None.h"
20 #include "llvm/ADT/Optional.h"
21 #include "llvm/Support/TypeSize.h"
22 #include <string>
23 
24 namespace llvm {
25 
26 class Type;
27 class FunctionType;
28 class Function;
29 class LLVMContext;
30 class Module;
31 class AttributeList;
32 
33 /// This namespace contains an enum with a value for every intrinsic/builtin
34 /// function known by LLVM. The enum values are returned by
35 /// Function::getIntrinsicID().
36 namespace Intrinsic {
37   // Abstraction for the arguments of the noalias intrinsics
38   static const int NoAliasScopeDeclScopeArg = 0;
39 
40   // Intrinsic ID type. This is an opaque typedef to facilitate splitting up
41   // the enum into target-specific enums.
42   typedef unsigned ID;
43 
44   enum IndependentIntrinsics : unsigned {
45     not_intrinsic = 0, // Must be zero
46 
47   // Get the intrinsic enums generated from Intrinsics.td
48 #define GET_INTRINSIC_ENUM_VALUES
49 #include "llvm/IR/IntrinsicEnums.inc"
50 #undef GET_INTRINSIC_ENUM_VALUES
51   };
52 
53   /// Return the LLVM name for an intrinsic, such as "llvm.ppc.altivec.lvx".
54   /// Note, this version is for intrinsics with no overloads.  Use the other
55   /// version of getName if overloads are required.
56   StringRef getName(ID id);
57 
58   /// Return the LLVM name for an intrinsic, without encoded types for
59   /// overloading, such as "llvm.ssa.copy".
60   StringRef getBaseName(ID id);
61 
62   /// Return the LLVM name for an intrinsic, such as "llvm.ppc.altivec.lvx" or
63   /// "llvm.ssa.copy.p0s_s.1". Note, this version of getName supports overloads.
64   /// This is less efficient than the StringRef version of this function.  If no
65   /// overloads are required, it is safe to use this version, but better to use
66   /// the StringRef version. If one of the types is based on an unnamed type, a
67   /// function type will be computed. Providing FT will avoid this computation.
68   std::string getName(ID Id, ArrayRef<Type *> Tys, Module *M,
69                       FunctionType *FT = nullptr);
70 
71   /// Return the LLVM name for an intrinsic. This is a special version only to
72   /// be used by LLVMIntrinsicCopyOverloadedName. It only supports overloads
73   /// based on named types.
74   std::string getNameNoUnnamedTypes(ID Id, ArrayRef<Type *> Tys);
75 
76   /// Return the function type for an intrinsic.
77   FunctionType *getType(LLVMContext &Context, ID id,
78                         ArrayRef<Type*> Tys = None);
79 
80   /// Returns true if the intrinsic can be overloaded.
81   bool isOverloaded(ID id);
82 
83   /// Returns true if the intrinsic is a leaf, i.e. it does not make any calls
84   /// itself.  Most intrinsics are leafs, the exceptions being the patchpoint
85   /// and statepoint intrinsics. These call (or invoke) their "target" argument.
86   bool isLeaf(ID id);
87 
88   /// Return the attributes for an intrinsic.
89   AttributeList getAttributes(LLVMContext &C, ID id);
90 
91   /// Create or insert an LLVM Function declaration for an intrinsic, and return
92   /// it.
93   ///
94   /// The Tys parameter is for intrinsics with overloaded types (e.g., those
95   /// using iAny, fAny, vAny, or iPTRAny).  For a declaration of an overloaded
96   /// intrinsic, Tys must provide exactly one type for each overloaded type in
97   /// the intrinsic.
98   Function *getDeclaration(Module *M, ID id, ArrayRef<Type*> Tys = None);
99 
100   /// Looks up Name in NameTable via binary search. NameTable must be sorted
101   /// and all entries must start with "llvm.".  If NameTable contains an exact
102   /// match for Name or a prefix of Name followed by a dot, its index in
103   /// NameTable is returned. Otherwise, -1 is returned.
104   int lookupLLVMIntrinsicByName(ArrayRef<const char *> NameTable,
105                                 StringRef Name);
106 
107   /// Map a Clang builtin name to an intrinsic ID.
108   ID getIntrinsicForClangBuiltin(const char *Prefix, StringRef BuiltinName);
109 
110   /// Map a MS builtin name to an intrinsic ID.
111   ID getIntrinsicForMSBuiltin(const char *Prefix, StringRef BuiltinName);
112 
113   /// This is a type descriptor which explains the type requirements of an
114   /// intrinsic. This is returned by getIntrinsicInfoTableEntries.
115   struct IITDescriptor {
116     enum IITDescriptorKind {
117       Void,
118       VarArg,
119       MMX,
120       Token,
121       Metadata,
122       Half,
123       BFloat,
124       Float,
125       Double,
126       Quad,
127       Integer,
128       Vector,
129       Pointer,
130       Struct,
131       Argument,
132       ExtendArgument,
133       TruncArgument,
134       HalfVecArgument,
135       SameVecWidthArgument,
136       PtrToArgument,
137       PtrToElt,
138       VecOfAnyPtrsToElt,
139       VecElementArgument,
140       Subdivide2Argument,
141       Subdivide4Argument,
142       VecOfBitcastsToInt,
143       AMX,
144       PPCQuad,
145       AnyPtrToElt,
146     } Kind;
147 
148     union {
149       unsigned Integer_Width;
150       unsigned Float_Width;
151       unsigned Pointer_AddressSpace;
152       unsigned Struct_NumElements;
153       unsigned Argument_Info;
154       ElementCount Vector_Width;
155     };
156 
157     enum ArgKind {
158       AK_Any,
159       AK_AnyInteger,
160       AK_AnyFloat,
161       AK_AnyVector,
162       AK_AnyPointer,
163       AK_MatchType = 7
164     };
165 
166     unsigned getArgumentNumber() const {
167       assert(Kind == Argument || Kind == ExtendArgument ||
168              Kind == TruncArgument || Kind == HalfVecArgument ||
169              Kind == SameVecWidthArgument || Kind == PtrToArgument ||
170              Kind == PtrToElt || Kind == VecElementArgument ||
171              Kind == Subdivide2Argument || Kind == Subdivide4Argument ||
172              Kind == VecOfBitcastsToInt);
173       return Argument_Info >> 3;
174     }
175     ArgKind getArgumentKind() const {
176       assert(Kind == Argument || Kind == ExtendArgument ||
177              Kind == TruncArgument || Kind == HalfVecArgument ||
178              Kind == SameVecWidthArgument || Kind == PtrToArgument ||
179              Kind == VecElementArgument || Kind == Subdivide2Argument ||
180              Kind == Subdivide4Argument || Kind == VecOfBitcastsToInt);
181       return (ArgKind)(Argument_Info & 7);
182     }
183 
184     // VecOfAnyPtrsToElt and AnyPtrToElt uses both an overloaded argument (for
185     // address space) and a reference argument (for matching vector width and
186     // element types)
187     unsigned getOverloadArgNumber() const {
188       assert(Kind == VecOfAnyPtrsToElt || Kind == AnyPtrToElt);
189       return Argument_Info >> 16;
190     }
191     unsigned getRefArgNumber() const {
192       assert(Kind == VecOfAnyPtrsToElt || Kind == AnyPtrToElt);
193       return Argument_Info & 0xFFFF;
194     }
195 
196     static IITDescriptor get(IITDescriptorKind K, unsigned Field) {
197       IITDescriptor Result = { K, { Field } };
198       return Result;
199     }
200 
201     static IITDescriptor get(IITDescriptorKind K, unsigned short Hi,
202                              unsigned short Lo) {
203       unsigned Field = Hi << 16 | Lo;
204       IITDescriptor Result = {K, {Field}};
205       return Result;
206     }
207 
208     static IITDescriptor getVector(unsigned Width, bool IsScalable) {
209       IITDescriptor Result = {Vector, {0}};
210       Result.Vector_Width = ElementCount::get(Width, IsScalable);
211       return Result;
212     }
213   };
214 
215   /// Return the IIT table descriptor for the specified intrinsic into an array
216   /// of IITDescriptors.
217   void getIntrinsicInfoTableEntries(ID id, SmallVectorImpl<IITDescriptor> &T);
218 
219   enum MatchIntrinsicTypesResult {
220     MatchIntrinsicTypes_Match = 0,
221     MatchIntrinsicTypes_NoMatchRet = 1,
222     MatchIntrinsicTypes_NoMatchArg = 2,
223   };
224 
225   /// Match the specified function type with the type constraints specified by
226   /// the .td file. If the given type is an overloaded type it is pushed to the
227   /// ArgTys vector.
228   ///
229   /// Returns false if the given type matches with the constraints, true
230   /// otherwise.
231   MatchIntrinsicTypesResult
232   matchIntrinsicSignature(FunctionType *FTy, ArrayRef<IITDescriptor> &Infos,
233                           SmallVectorImpl<Type *> &ArgTys);
234 
235   /// Verify if the intrinsic has variable arguments. This method is intended to
236   /// be called after all the fixed arguments have been matched first.
237   ///
238   /// This method returns true on error.
239   bool matchIntrinsicVarArg(bool isVarArg, ArrayRef<IITDescriptor> &Infos);
240 
241   /// Gets the type arguments of an intrinsic call by matching type contraints
242   /// specified by the .td file. The overloaded types are pushed into the
243   /// AgTys vector.
244   ///
245   /// Returns false if the given function is not a valid intrinsic call.
246   bool getIntrinsicSignature(Function *F, SmallVectorImpl<Type *> &ArgTys);
247 
248   // Checks if the intrinsic name matches with its signature and if not
249   // returns the declaration with the same signature and remangled name.
250   // An existing GlobalValue with the wanted name but with a wrong prototype
251   // or of the wrong kind will be renamed by adding ".renamed" to the name.
252   llvm::Optional<Function*> remangleIntrinsicFunction(Function *F);
253 
254 } // End Intrinsic namespace
255 
256 } // End llvm namespace
257 
258 #endif
259