LLVM  4.0.0
IntrinsicInst.cpp
Go to the documentation of this file.
1 //===-- InstrinsicInst.cpp - Intrinsic Instruction Wrappers ---------------===//
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 implements methods that make it really easy to deal with intrinsic
11 // functions.
12 //
13 // All intrinsic function calls are instances of the call instruction, so these
14 // are all subclasses of the CallInst class. Note that none of these classes
15 // has state or virtual methods, which is an important part of this gross/neat
16 // hack working.
17 //
18 // In some cases, arguments to intrinsics need to be generic and are defined as
19 // type pointer to empty struct { }*. To access the real item of interest the
20 // cast instruction needs to be stripped away.
21 //
22 //===----------------------------------------------------------------------===//
23 
24 #include "llvm/IR/IntrinsicInst.h"
25 #include "llvm/IR/Constants.h"
26 #include "llvm/IR/GlobalVariable.h"
27 #include "llvm/IR/Metadata.h"
28 #include "llvm/IR/Module.h"
30 using namespace llvm;
31 
32 //===----------------------------------------------------------------------===//
33 /// DbgInfoIntrinsic - This is the common base class for debug info intrinsics
34 ///
35 
36 Value *DbgInfoIntrinsic::getVariableLocation(bool AllowNullOp) const {
37  Value *Op = getArgOperand(0);
38  if (AllowNullOp && !Op)
39  return nullptr;
40 
41  auto *MD = cast<MetadataAsValue>(Op)->getMetadata();
42  if (auto *V = dyn_cast<ValueAsMetadata>(MD))
43  return V->getValue();
44 
45  // When the value goes to null, it gets replaced by an empty MDNode.
46  assert(!cast<MDNode>(MD)->getNumOperands() && "Expected an empty MDNode");
47  return nullptr;
48 }
49 
51  StringRef Name) {
52  assert(Name.startswith("llvm."));
53 
54  // Do successive binary searches of the dotted name components. For
55  // "llvm.gc.experimental.statepoint.p1i8.p1i32", we will find the range of
56  // intrinsics starting with "llvm.gc", then "llvm.gc.experimental", then
57  // "llvm.gc.experimental.statepoint", and then we will stop as the range is
58  // size 1. During the search, we can skip the prefix that we already know is
59  // identical. By using strncmp we consider names with differing suffixes to
60  // be part of the equal range.
61  size_t CmpStart = 0;
62  size_t CmpEnd = 4; // Skip the "llvm" component.
63  const char *const *Low = NameTable.begin();
64  const char *const *High = NameTable.end();
65  const char *const *LastLow = Low;
66  while (CmpEnd < Name.size() && High - Low > 0) {
67  CmpStart = CmpEnd;
68  CmpEnd = Name.find('.', CmpStart + 1);
69  CmpEnd = CmpEnd == StringRef::npos ? Name.size() : CmpEnd;
70  auto Cmp = [CmpStart, CmpEnd](const char *LHS, const char *RHS) {
71  return strncmp(LHS + CmpStart, RHS + CmpStart, CmpEnd - CmpStart) < 0;
72  };
73  LastLow = Low;
74  std::tie(Low, High) = std::equal_range(Low, High, Name.data(), Cmp);
75  }
76  if (High - Low > 0)
77  LastLow = Low;
78 
79  if (LastLow == NameTable.end())
80  return -1;
81  StringRef NameFound = *LastLow;
82  if (Name == NameFound ||
83  (Name.startswith(NameFound) && Name[NameFound.size()] == '.'))
84  return LastLow - NameTable.begin();
85  return -1;
86 }
87 
90  return const_cast<Value *>(getArgOperand(4));
91  }
92  const Module *M = getModule();
94  return ConstantInt::get(Type::getInt64Ty(Context), 1);
95 }
LLVMContext & Context
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:52
unsigned getNumOperands() const
Definition: User.h:167
iterator end() const
Definition: ArrayRef.h:130
This file contains the declarations for metadata subclasses.
static IntegerType * getInt64Ty(LLVMContext &C)
Definition: Type.cpp:170
uint64_t High
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool startswith(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:264
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t size() const
size - Get the string size.
Definition: StringRef.h:135
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t find(char C, size_t From=0) const
Search for the first character C in the string.
Definition: StringRef.h:295
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:48
This file contains the declarations for the subclasses of Constant, which represent the different fla...
iterator begin() const
Definition: ArrayRef.h:129
static bool classof(const IntrinsicInst *I)
const Module * getModule() const
Return the module owning the function this instruction belongs to or nullptr it the function does not...
Definition: Instruction.cpp:58
Module.h This file contains the declarations for the Module class.
MDNode * getMetadata(unsigned KindID) const
Get the metadata of given kind attached to this Instruction.
Definition: Instruction.h:175
static Constant * get(Type *Ty, uint64_t V, bool isSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
Definition: Constants.cpp:558
Value * getArgOperand(unsigned i) const
getArgOperand/setArgOperand - Return/set the i-th call argument.
static const size_t npos
Definition: StringRef.h:51
Value * getVariableLocation(bool AllowNullOp=true) const
Get the location corresponding to the variable referenced by the debug info intrinsic.
int lookupLLVMIntrinsicByName(ArrayRef< const char * > NameTable, StringRef Name)
Looks up Name in NameTable via binary search.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
LLVM Value Representation.
Definition: Value.h:71
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE const char * data() const
data - Get a pointer to the start of the string (which may not be null terminated).
Definition: StringRef.h:125
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:47
Use & Op()
Definition: User.h:117
LLVMContext & getContext() const
Get the global data context.
Definition: Module.h:222