contrib/llvm/lib/IR/IntrinsicInst.cpp

   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/Support/raw_ostream.h"
  29 using namespace llvm;
  30
  31 //===----------------------------------------------------------------------===//
  32 /// DbgInfoIntrinsic - This is the common base class for debug info intrinsics
  33 ///
  34
  35 Value *DbgInfoIntrinsic::getVariableLocation(bool AllowNullOp) const {
  36   Value *Op = getArgOperand(0);
  37   if (AllowNullOp && !Op)
  38     return nullptr;
  39
  40   auto *MD = cast<MetadataAsValue>(Op)->getMetadata();
  41   if (auto *V = dyn_cast<ValueAsMetadata>(MD))
  42     return V->getValue();
  43
  44   // When the value goes to null, it gets replaced by an empty MDNode.
  45   assert(!cast<MDNode>(MD)->getNumOperands() && "Expected an empty MDNode");
  46   return nullptr;
  47 }
  48
  49 int llvm::Intrinsic::lookupLLVMIntrinsicByName(ArrayRef<const char *> NameTable,
  50                                                StringRef Name) {
  51   assert(Name.startswith("llvm."));
  52
  53   // Do successive binary searches of the dotted name components. For
  54   // "llvm.gc.experimental.statepoint.p1i8.p1i32", we will find the range of
  55   // intrinsics starting with "llvm.gc", then "llvm.gc.experimental", then
  56   // "llvm.gc.experimental.statepoint", and then we will stop as the range is
  57   // size 1. During the search, we can skip the prefix that we already know is
  58   // identical. By using strncmp we consider names with differing suffixes to
  59   // be part of the equal range.
  60   size_t CmpStart = 0;
  61   size_t CmpEnd = 4; // Skip the "llvm" component.
  62   const char *const *Low = NameTable.begin();
  63   const char *const *High = NameTable.end();
  64   const char *const *LastLow = Low;
  65   while (CmpEnd < Name.size() && High - Low > 0) {
  66     CmpStart = CmpEnd;
  67     CmpEnd = Name.find('.', CmpStart + 1);
  68     CmpEnd = CmpEnd == StringRef::npos ? Name.size() : CmpEnd;
  69     auto Cmp = [CmpStart, CmpEnd](const char *LHS, const char *RHS) {
  70       return strncmp(LHS + CmpStart, RHS + CmpStart, CmpEnd - CmpStart) < 0;
  71     };
  72     LastLow = Low;
  73     std::tie(Low, High) = std::equal_range(Low, High, Name.data(), Cmp);
  74   }
  75   if (High - Low > 0)
  76     LastLow = Low;
  77
  78   if (LastLow == NameTable.end())
  79     return -1;
  80   StringRef NameFound = *LastLow;
  81   if (Name == NameFound ||
  82       (Name.startswith(NameFound) && Name[NameFound.size()] == '.'))
  83     return LastLow - NameTable.begin();
  84   return -1;
  85 }