LLVM  6.0.0svn
AMDGPUIntrinsicInfo.cpp
Go to the documentation of this file.
1 //===- AMDGPUIntrinsicInfo.cpp - AMDGPU Intrinsic Information ---*- 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 /// \file
11 /// \brief AMDGPU Implementation of the IntrinsicInfo class.
12 //
13 //===-----------------------------------------------------------------------===//
14 
15 #include "AMDGPUIntrinsicInfo.h"
16 #include "AMDGPUSubtarget.h"
17 #include "llvm/IR/DerivedTypes.h"
18 #include "llvm/IR/Intrinsics.h"
19 #include "llvm/IR/Module.h"
20 
21 using namespace llvm;
22 
24  : TargetIntrinsicInfo() {}
25 
26 static const char *const IntrinsicNameTable[] = {
27 #define GET_INTRINSIC_NAME_TABLE
28 #include "AMDGPUGenIntrinsics.inc"
29 #undef GET_INTRINSIC_NAME_TABLE
30 };
31 
32 namespace {
33 #define GET_INTRINSIC_ATTRIBUTES
34 #include "AMDGPUGenIntrinsics.inc"
35 #undef GET_INTRINSIC_ATTRIBUTES
36 }
37 
39  ArrayRef<Type *> Tys) const {
40  if (IntrID < Intrinsic::num_intrinsics)
41  return StringRef();
42 
44  "Invalid intrinsic ID");
45 
46  return IntrinsicNameTable[IntrID - Intrinsic::num_intrinsics];
47 }
48 
49 std::string AMDGPUIntrinsicInfo::getName(unsigned IntrID, Type **Tys,
50  unsigned NumTys) const {
51  return getName(IntrID, makeArrayRef(Tys, NumTys)).str();
52 }
53 
55  ArrayRef<Type*> Tys) const {
56  // FIXME: Re-use Intrinsic::getType machinery
57  llvm_unreachable("unhandled intrinsic");
58 }
59 
60 unsigned AMDGPUIntrinsicInfo::lookupName(const char *NameData,
61  unsigned Len) const {
62  StringRef Name(NameData, Len);
63  if (!Name.startswith("llvm."))
64  return 0; // All intrinsics start with 'llvm.'
65 
66  // Look for a name match in our table. If the intrinsic is not overloaded,
67  // require an exact match. If it is overloaded, require a prefix match. The
68  // AMDGPU enum enum starts at Intrinsic::num_intrinsics.
69  int Idx = Intrinsic::lookupLLVMIntrinsicByName(IntrinsicNameTable, Name);
70  if (Idx >= 0) {
71  bool IsPrefixMatch = Name.size() > strlen(IntrinsicNameTable[Idx]);
72  return IsPrefixMatch == isOverloaded(Idx + 1)
74  : 0;
75  }
76 
77  return 0;
78 }
79 
80 bool AMDGPUIntrinsicInfo::isOverloaded(unsigned id) const {
81 // Overload Table
82 #define GET_INTRINSIC_OVERLOAD_TABLE
83 #include "AMDGPUGenIntrinsics.inc"
84 #undef GET_INTRINSIC_OVERLOAD_TABLE
85 }
86 
88  ArrayRef<Type *> Tys) const {
89  FunctionType *FTy = getType(M->getContext(), IntrID, Tys);
90  Function *F
91  = cast<Function>(M->getOrInsertFunction(getName(IntrID, Tys), FTy));
92 
94  getAttributes(M->getContext(), static_cast<AMDGPUIntrinsic::ID>(IntrID));
95  F->setAttributes(AS);
96  return F;
97 }
98 
100  Type **Tys,
101  unsigned NumTys) const {
102  return getDeclaration(M, IntrID, makeArrayRef(Tys, NumTys));
103 }
LLVM_NODISCARD std::string str() const
str - Get the contents as an std::string.
Definition: StringRef.h:228
LLVMContext & Context
AMDGPU specific subclass of TargetSubtarget.
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
Constant * getOrInsertFunction(StringRef Name, FunctionType *T, AttributeList AttributeList)
Look up the specified function in the module symbol table.
Definition: Module.cpp:142
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:63
unsigned lookupName(const char *Name, unsigned Len) const override
Look up target intrinsic by name.
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t size() const
size - Get the string size.
Definition: StringRef.h:138
bool isOverloaded(unsigned IID) const override
Returns true if the intrinsic can be overloaded.
F(f)
StringRef getName(unsigned IntrId, ArrayRef< Type *> Tys=None) const
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:451
LLVMContext & getContext() const
Get the global data context.
Definition: Module.h:237
AttributeList getAttributes(LLVMContext &C, ID id)
Return the attributes for an intrinsic.
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool startswith(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:267
Class to represent function types.
Definition: DerivedTypes.h:103
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
FunctionType * getType(LLVMContext &Context, unsigned ID, ArrayRef< Type *> Tys=None) const
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:69
Function * getDeclaration(Module *M, unsigned ID, Type **Tys=nullptr, unsigned NumTys=0) const override
Create or insert an LLVM Function declaration for an intrinsic, and return it.
const AMDGPUAS & AS
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
TargetIntrinsicInfo - Interface to description of machine instruction set.
static const char *const IntrinsicNameTable[]
Module.h This file contains the declarations for the Module class.
Interface for the AMDGPU Implementation of the Intrinsic Info class.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
int lookupLLVMIntrinsicByName(ArrayRef< const char *> NameTable, StringRef Name)
Looks up Name in NameTable via binary search.