Intrinsics.h revision 355940
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 <string> 22 23namespace llvm { 24 25class Type; 26class FunctionType; 27class Function; 28class LLVMContext; 29class Module; 30class AttributeList; 31 32/// This namespace contains an enum with a value for every intrinsic/builtin 33/// function known by LLVM. The enum values are returned by 34/// Function::getIntrinsicID(). 35namespace Intrinsic { 36 enum ID : unsigned { 37 not_intrinsic = 0, // Must be zero 38 39 // Get the intrinsic enums generated from Intrinsics.td 40#define GET_INTRINSIC_ENUM_VALUES 41#include "llvm/IR/IntrinsicEnums.inc" 42#undef GET_INTRINSIC_ENUM_VALUES 43 , num_intrinsics 44 }; 45 46 /// Return the LLVM name for an intrinsic, such as "llvm.ppc.altivec.lvx". 47 /// Note, this version is for intrinsics with no overloads. Use the other 48 /// version of getName if overloads are required. 49 StringRef getName(ID id); 50 51 /// Return the LLVM name for an intrinsic, such as "llvm.ppc.altivec.lvx". 52 /// Note, this version of getName supports overloads, but is less efficient 53 /// than the StringRef version of this function. If no overloads are 54 /// requried, it is safe to use this version, but better to use the StringRef 55 /// version. 56 std::string getName(ID id, ArrayRef<Type*> Tys); 57 58 /// Return the function type for an intrinsic. 59 FunctionType *getType(LLVMContext &Context, ID id, 60 ArrayRef<Type*> Tys = None); 61 62 /// Returns true if the intrinsic can be overloaded. 63 bool isOverloaded(ID id); 64 65 /// Returns true if the intrinsic is a leaf, i.e. it does not make any calls 66 /// itself. Most intrinsics are leafs, the exceptions being the patchpoint 67 /// and statepoint intrinsics. These call (or invoke) their "target" argument. 68 bool isLeaf(ID id); 69 70 /// Return the attributes for an intrinsic. 71 AttributeList getAttributes(LLVMContext &C, ID id); 72 73 /// Create or insert an LLVM Function declaration for an intrinsic, and return 74 /// it. 75 /// 76 /// The Tys parameter is for intrinsics with overloaded types (e.g., those 77 /// using iAny, fAny, vAny, or iPTRAny). For a declaration of an overloaded 78 /// intrinsic, Tys must provide exactly one type for each overloaded type in 79 /// the intrinsic. 80 Function *getDeclaration(Module *M, ID id, ArrayRef<Type*> Tys = None); 81 82 /// Looks up Name in NameTable via binary search. NameTable must be sorted 83 /// and all entries must start with "llvm.". If NameTable contains an exact 84 /// match for Name or a prefix of Name followed by a dot, its index in 85 /// NameTable is returned. Otherwise, -1 is returned. 86 int lookupLLVMIntrinsicByName(ArrayRef<const char *> NameTable, 87 StringRef Name); 88 89 /// Map a GCC builtin name to an intrinsic ID. 90 ID getIntrinsicForGCCBuiltin(const char *Prefix, StringRef BuiltinName); 91 92 /// Map a MS builtin name to an intrinsic ID. 93 ID getIntrinsicForMSBuiltin(const char *Prefix, StringRef BuiltinName); 94 95 /// This is a type descriptor which explains the type requirements of an 96 /// intrinsic. This is returned by getIntrinsicInfoTableEntries. 97 struct IITDescriptor { 98 enum IITDescriptorKind { 99 Void, VarArg, MMX, Token, Metadata, Half, Float, Double, Quad, 100 Integer, Vector, Pointer, Struct, 101 Argument, ExtendArgument, TruncArgument, HalfVecArgument, 102 SameVecWidthArgument, PtrToArgument, PtrToElt, VecOfAnyPtrsToElt, 103 VecElementArgument 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 AK_MatchType = 7 122 }; 123 124 unsigned getArgumentNumber() const { 125 assert(Kind == Argument || Kind == ExtendArgument || 126 Kind == TruncArgument || Kind == HalfVecArgument || 127 Kind == SameVecWidthArgument || Kind == PtrToArgument || 128 Kind == PtrToElt || Kind == VecElementArgument); 129 return Argument_Info >> 3; 130 } 131 ArgKind getArgumentKind() const { 132 assert(Kind == Argument || Kind == ExtendArgument || 133 Kind == TruncArgument || Kind == HalfVecArgument || 134 Kind == SameVecWidthArgument || Kind == PtrToArgument || 135 Kind == VecElementArgument); 136 return (ArgKind)(Argument_Info & 7); 137 } 138 139 // VecOfAnyPtrsToElt uses both an overloaded argument (for address space) 140 // and a reference argument (for matching vector width and element types) 141 unsigned getOverloadArgNumber() const { 142 assert(Kind == VecOfAnyPtrsToElt); 143 return Argument_Info >> 16; 144 } 145 unsigned getRefArgNumber() const { 146 assert(Kind == VecOfAnyPtrsToElt); 147 return Argument_Info & 0xFFFF; 148 } 149 150 static IITDescriptor get(IITDescriptorKind K, unsigned Field) { 151 IITDescriptor Result = { K, { Field } }; 152 return Result; 153 } 154 155 static IITDescriptor get(IITDescriptorKind K, unsigned short Hi, 156 unsigned short Lo) { 157 unsigned Field = Hi << 16 | Lo; 158 IITDescriptor Result = {K, {Field}}; 159 return Result; 160 } 161 }; 162 163 /// Return the IIT table descriptor for the specified intrinsic into an array 164 /// of IITDescriptors. 165 void getIntrinsicInfoTableEntries(ID id, SmallVectorImpl<IITDescriptor> &T); 166 167 enum MatchIntrinsicTypesResult { 168 MatchIntrinsicTypes_Match = 0, 169 MatchIntrinsicTypes_NoMatchRet = 1, 170 MatchIntrinsicTypes_NoMatchArg = 2, 171 }; 172 173 /// Match the specified function type with the type constraints specified by 174 /// the .td file. If the given type is an overloaded type it is pushed to the 175 /// ArgTys vector. 176 /// 177 /// Returns false if the given type matches with the constraints, true 178 /// otherwise. 179 MatchIntrinsicTypesResult 180 matchIntrinsicSignature(FunctionType *FTy, ArrayRef<IITDescriptor> &Infos, 181 SmallVectorImpl<Type *> &ArgTys); 182 183 /// Verify if the intrinsic has variable arguments. This method is intended to 184 /// be called after all the fixed arguments have been matched first. 185 /// 186 /// This method returns true on error. 187 bool matchIntrinsicVarArg(bool isVarArg, ArrayRef<IITDescriptor> &Infos); 188 189 // Checks if the intrinsic name matches with its signature and if not 190 // returns the declaration with the same signature and remangled name. 191 llvm::Optional<Function*> remangleIntrinsicFunction(Function *F); 192 193} // End Intrinsic namespace 194 195} // End llvm namespace 196 197#endif 198