• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===-- llvm/Instrinsics.h - LLVM Intrinsic Function Handling ---*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file defines a set of enums which allow processing of intrinsic
11 // functions.  Values of these enum types are returned by
12 // Function::getIntrinsicID.
13 //
14 //===----------------------------------------------------------------------===//
15 
16 #ifndef LLVM_IR_INTRINSICS_H
17 #define LLVM_IR_INTRINSICS_H
18 
19 #include "llvm/ADT/ArrayRef.h"
20 #include "llvm/ADT/None.h"
21 #include "llvm/ADT/Optional.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   enum ID : unsigned {
38     not_intrinsic = 0,   // Must be zero
39 
40     // Get the intrinsic enums generated from Intrinsics.td
41 #define GET_INTRINSIC_ENUM_VALUES
42 #include "llvm/IR/IntrinsicEnums.inc"
43 #undef GET_INTRINSIC_ENUM_VALUES
44     , num_intrinsics
45   };
46 
47   /// Return the LLVM name for an intrinsic, such as "llvm.ppc.altivec.lvx".
48   /// Note, this version is for intrinsics with no overloads.  Use the other
49   /// version of getName if overloads are required.
50   StringRef getName(ID id);
51 
52   /// Return the LLVM name for an intrinsic, such as "llvm.ppc.altivec.lvx".
53   /// Note, this version of getName supports overloads, but is less efficient
54   /// than the StringRef version of this function.  If no overloads are
55   /// requried, it is safe to use this version, but better to use the StringRef
56   /// version.
57   std::string getName(ID id, ArrayRef<Type*> Tys);
58 
59   /// Return the function type for an intrinsic.
60   FunctionType *getType(LLVMContext &Context, ID id,
61                         ArrayRef<Type*> Tys = None);
62 
63   /// Returns true if the intrinsic can be overloaded.
64   bool isOverloaded(ID id);
65 
66   /// Returns true if the intrinsic is a leaf, i.e. it does not make any calls
67   /// itself.  Most intrinsics are leafs, the exceptions being the patchpoint
68   /// and statepoint intrinsics. These call (or invoke) their "target" argument.
69   bool isLeaf(ID id);
70 
71   /// Return the attributes for an intrinsic.
72   AttributeList getAttributes(LLVMContext &C, ID id);
73 
74   /// Create or insert an LLVM Function declaration for an intrinsic, and return
75   /// it.
76   ///
77   /// The Tys parameter is for intrinsics with overloaded types (e.g., those
78   /// using iAny, fAny, vAny, or iPTRAny).  For a declaration of an overloaded
79   /// intrinsic, Tys must provide exactly one type for each overloaded type in
80   /// the intrinsic.
81   Function *getDeclaration(Module *M, ID id, ArrayRef<Type*> Tys = None);
82 
83   /// Looks up Name in NameTable via binary search. NameTable must be sorted
84   /// and all entries must start with "llvm.".  If NameTable contains an exact
85   /// match for Name or a prefix of Name followed by a dot, its index in
86   /// NameTable is returned. Otherwise, -1 is returned.
87   int lookupLLVMIntrinsicByName(ArrayRef<const char *> NameTable,
88                                 StringRef Name);
89 
90   /// Map a GCC builtin name to an intrinsic ID.
91   ID getIntrinsicForGCCBuiltin(const char *Prefix, StringRef BuiltinName);
92 
93   /// Map a MS builtin name to an intrinsic ID.
94   ID getIntrinsicForMSBuiltin(const char *Prefix, StringRef BuiltinName);
95 
96   /// This is a type descriptor which explains the type requirements of an
97   /// intrinsic. This is returned by getIntrinsicInfoTableEntries.
98   struct IITDescriptor {
99     enum IITDescriptorKind {
100       Void, VarArg, MMX, Token, Metadata, Half, Float, Double, Quad,
101       Integer, Vector, Pointer, Struct,
102       Argument, ExtendArgument, TruncArgument, HalfVecArgument,
103       SameVecWidthArgument, PtrToArgument, PtrToElt, VecOfAnyPtrsToElt
104     } Kind;
105 
106     union {
107       unsigned Integer_Width;
108       unsigned Float_Width;
109       unsigned Vector_Width;
110       unsigned Pointer_AddressSpace;
111       unsigned Struct_NumElements;
112       unsigned Argument_Info;
113     };
114 
115     enum ArgKind {
116       AK_Any,
117       AK_AnyInteger,
118       AK_AnyFloat,
119       AK_AnyVector,
120       AK_AnyPointer
121     };
122 
getArgumentNumberIITDescriptor123     unsigned getArgumentNumber() const {
124       assert(Kind == Argument || Kind == ExtendArgument ||
125              Kind == TruncArgument || Kind == HalfVecArgument ||
126              Kind == SameVecWidthArgument || Kind == PtrToArgument ||
127              Kind == PtrToElt);
128       return Argument_Info >> 3;
129     }
getArgumentKindIITDescriptor130     ArgKind getArgumentKind() const {
131       assert(Kind == Argument || Kind == ExtendArgument ||
132              Kind == TruncArgument || Kind == HalfVecArgument ||
133              Kind == SameVecWidthArgument || Kind == PtrToArgument);
134       return (ArgKind)(Argument_Info & 7);
135     }
136 
137     // VecOfAnyPtrsToElt uses both an overloaded argument (for address space)
138     // and a reference argument (for matching vector width and element types)
getOverloadArgNumberIITDescriptor139     unsigned getOverloadArgNumber() const {
140       assert(Kind == VecOfAnyPtrsToElt);
141       return Argument_Info >> 16;
142     }
getRefArgNumberIITDescriptor143     unsigned getRefArgNumber() const {
144       assert(Kind == VecOfAnyPtrsToElt);
145       return Argument_Info & 0xFFFF;
146     }
147 
getIITDescriptor148     static IITDescriptor get(IITDescriptorKind K, unsigned Field) {
149       IITDescriptor Result = { K, { Field } };
150       return Result;
151     }
152 
getIITDescriptor153     static IITDescriptor get(IITDescriptorKind K, unsigned short Hi,
154                              unsigned short Lo) {
155       unsigned Field = Hi << 16 | Lo;
156       IITDescriptor Result = {K, {Field}};
157       return Result;
158     }
159   };
160 
161   /// Return the IIT table descriptor for the specified intrinsic into an array
162   /// of IITDescriptors.
163   void getIntrinsicInfoTableEntries(ID id, SmallVectorImpl<IITDescriptor> &T);
164 
165   /// Match the specified type (which comes from an intrinsic argument or return
166   /// value) with the type constraints specified by the .td file. If the given
167   /// type is an overloaded type it is pushed to the ArgTys vector.
168   ///
169   /// Returns false if the given type matches with the constraints, true
170   /// otherwise.
171   bool matchIntrinsicType(Type *Ty, ArrayRef<IITDescriptor> &Infos,
172                           SmallVectorImpl<Type*> &ArgTys);
173 
174   /// Verify if the intrinsic has variable arguments. This method is intended to
175   /// be called after all the fixed arguments have been matched first.
176   ///
177   /// This method returns true on error.
178   bool matchIntrinsicVarArg(bool isVarArg, ArrayRef<IITDescriptor> &Infos);
179 
180   // Checks if the intrinsic name matches with its signature and if not
181   // returns the declaration with the same signature and remangled name.
182   llvm::Optional<Function*> remangleIntrinsicFunction(Function *F);
183 
184 } // End Intrinsic namespace
185 
186 } // End llvm namespace
187 
188 #endif
189