LLVM  8.0.0svn
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/ADT/StringSwitch.h"
26 #include "llvm/IR/Constants.h"
28 #include "llvm/IR/GlobalVariable.h"
29 #include "llvm/IR/Metadata.h"
30 #include "llvm/IR/Module.h"
32 using namespace llvm;
33 
34 //===----------------------------------------------------------------------===//
35 /// DbgVariableIntrinsic - This is the common base class for debug info
36 /// intrinsics for variables.
37 ///
38 
40  Value *Op = getArgOperand(0);
41  if (AllowNullOp && !Op)
42  return nullptr;
43 
44  auto *MD = cast<MetadataAsValue>(Op)->getMetadata();
45  if (auto *V = dyn_cast<ValueAsMetadata>(MD))
46  return V->getValue();
47 
48  // When the value goes to null, it gets replaced by an empty MDNode.
49  assert(!cast<MDNode>(MD)->getNumOperands() && "Expected an empty MDNode");
50  return nullptr;
51 }
52 
54  if (auto Fragment = getExpression()->getFragmentInfo())
55  return Fragment->SizeInBits;
56  return getVariable()->getSizeInBits();
57 }
58 
60  StringRef Name) {
61  assert(Name.startswith("llvm."));
62 
63  // Do successive binary searches of the dotted name components. For
64  // "llvm.gc.experimental.statepoint.p1i8.p1i32", we will find the range of
65  // intrinsics starting with "llvm.gc", then "llvm.gc.experimental", then
66  // "llvm.gc.experimental.statepoint", and then we will stop as the range is
67  // size 1. During the search, we can skip the prefix that we already know is
68  // identical. By using strncmp we consider names with differing suffixes to
69  // be part of the equal range.
70  size_t CmpStart = 0;
71  size_t CmpEnd = 4; // Skip the "llvm" component.
72  const char *const *Low = NameTable.begin();
73  const char *const *High = NameTable.end();
74  const char *const *LastLow = Low;
75  while (CmpEnd < Name.size() && High - Low > 0) {
76  CmpStart = CmpEnd;
77  CmpEnd = Name.find('.', CmpStart + 1);
78  CmpEnd = CmpEnd == StringRef::npos ? Name.size() : CmpEnd;
79  auto Cmp = [CmpStart, CmpEnd](const char *LHS, const char *RHS) {
80  return strncmp(LHS + CmpStart, RHS + CmpStart, CmpEnd - CmpStart) < 0;
81  };
82  LastLow = Low;
83  std::tie(Low, High) = std::equal_range(Low, High, Name.data(), Cmp);
84  }
85  if (High - Low > 0)
86  LastLow = Low;
87 
88  if (LastLow == NameTable.end())
89  return -1;
90  StringRef NameFound = *LastLow;
91  if (Name == NameFound ||
92  (Name.startswith(NameFound) && Name[NameFound.size()] == '.'))
93  return LastLow - NameTable.begin();
94  return -1;
95 }
96 
99  return const_cast<Value *>(getArgOperand(4));
100  }
101  const Module *M = getModule();
103  return ConstantInt::get(Type::getInt64Ty(Context), 1);
104 }
105 
108  unsigned NumOperands = getNumArgOperands();
109  Metadata *MD =
110  dyn_cast<MetadataAsValue>(getArgOperand(NumOperands - 2))->getMetadata();
111  if (!MD || !isa<MDString>(MD))
112  return rmInvalid;
113  StringRef RoundingArg = cast<MDString>(MD)->getString();
114 
115  // For dynamic rounding mode, we use round to nearest but we will set the
116  // 'exact' SDNodeFlag so that the value will not be rounded.
117  return StringSwitch<RoundingMode>(RoundingArg)
118  .Case("round.dynamic", rmDynamic)
119  .Case("round.tonearest", rmToNearest)
120  .Case("round.downward", rmDownward)
121  .Case("round.upward", rmUpward)
122  .Case("round.towardzero", rmTowardZero)
123  .Default(rmInvalid);
124 }
125 
128  unsigned NumOperands = getNumArgOperands();
129  Metadata *MD =
130  dyn_cast<MetadataAsValue>(getArgOperand(NumOperands - 1))->getMetadata();
131  if (!MD || !isa<MDString>(MD))
132  return ebInvalid;
133  StringRef ExceptionArg = cast<MDString>(MD)->getString();
134  return StringSwitch<ExceptionBehavior>(ExceptionArg)
135  .Case("fpexcept.ignore", ebIgnore)
136  .Case("fpexcept.maytrap", ebMayTrap)
137  .Case("fpexcept.strict", ebStrict)
138  .Default(ebInvalid);
139 }
140 
142  switch (getIntrinsicID()) {
143  default:
144  return false;
145  case Intrinsic::experimental_constrained_sqrt:
146  case Intrinsic::experimental_constrained_sin:
147  case Intrinsic::experimental_constrained_cos:
148  case Intrinsic::experimental_constrained_exp:
149  case Intrinsic::experimental_constrained_exp2:
150  case Intrinsic::experimental_constrained_log:
151  case Intrinsic::experimental_constrained_log10:
152  case Intrinsic::experimental_constrained_log2:
153  case Intrinsic::experimental_constrained_rint:
154  case Intrinsic::experimental_constrained_nearbyint:
155  return true;
156  }
157 }
158 
160  switch (getIntrinsicID()) {
161  default:
162  return false;
163  case Intrinsic::experimental_constrained_fma:
164  return true;
165  }
166 }
167 
LLVMContext & Context
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:64
iterator begin() const
Definition: ArrayRef.h:137
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t size() const
size - Get the string size.
Definition: StringRef.h:138
This file contains the declarations for metadata subclasses.
static IntegerType * getInt64Ty(LLVMContext &C)
Definition: Type.cpp:177
uint64_t High
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:128
Optional< uint64_t > getFragmentSizeInBits() const
Get the size (in bits) of the variable, or fragment of the variable that is described.
LLVMContext & getContext() const
Get the global data context.
Definition: Module.h:243
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE R Default(T Value)
Definition: StringSwitch.h:203
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool startswith(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:267
RoundingMode getRoundingMode() const
MDNode * getMetadata(unsigned KindID) const
Get the metadata of given kind attached to this Instruction.
Definition: Instruction.h:217
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: APInt.h:33
ExceptionBehavior getExceptionBehavior() const
A switch()-like statement whose cases are string literals.
Definition: StringSwitch.h:43
unsigned getNumOperands() const
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:69
This file contains the declarations for the subclasses of Constant, which represent the different fla...
DIExpression * getExpression() const
Metadata wrapper in the Value hierarchy.
Definition: Metadata.h:174
static bool classof(const IntrinsicInst *I)
Intrinsic::ID getIntrinsicID() const
Return the intrinsic ID of this intrinsic.
Definition: IntrinsicInst.h:51
Optional< uint64_t > getSizeInBits() const
Determines the size of the variable&#39;s type.
Module.h This file contains the declarations for the Module class.
iterator end() const
Definition: ArrayRef.h:138
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:621
const Module * getModule() const
Return the module owning the function this instruction belongs to or nullptr it the function does not...
Definition: Instruction.cpp:56
LLVM_ATTRIBUTE_ALWAYS_INLINE StringSwitch & Case(StringLiteral S, T Value)
Definition: StringSwitch.h:70
Value * getVariableLocation(bool AllowNullOp=true) const
Get the location corresponding to the variable referenced by the debug info intrinsic.
static const size_t npos
Definition: StringRef.h:51
unsigned getNumArgOperands() const
Return the number of call arguments.
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:323
DILocalVariable * getVariable() const
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Value * getArgOperand(unsigned i) const
getArgOperand/setArgOperand - Return/set the i-th call argument.
LLVM Value Representation.
Definition: Value.h:73
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.
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:298
Root of the metadata hierarchy.
Definition: Metadata.h:58