LCOV - code coverage report
Current view: top level - lib/IR - IntrinsicInst.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 63 63 100.0 %
Date: 2017-09-14 15:23:50 Functions: 7 7 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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"
      27             : #include "llvm/IR/GlobalVariable.h"
      28             : #include "llvm/IR/Metadata.h"
      29             : #include "llvm/IR/Module.h"
      30             : #include "llvm/Support/raw_ostream.h"
      31             : using namespace llvm;
      32             : 
      33             : //===----------------------------------------------------------------------===//
      34             : /// DbgInfoIntrinsic - This is the common base class for debug info intrinsics
      35             : ///
      36             : 
      37      862287 : Value *DbgInfoIntrinsic::getVariableLocation(bool AllowNullOp) const {
      38     1724574 :   Value *Op = getArgOperand(0);
      39      862287 :   if (AllowNullOp && !Op)
      40             :     return nullptr;
      41             : 
      42      862287 :   auto *MD = cast<MetadataAsValue>(Op)->getMetadata();
      43      854787 :   if (auto *V = dyn_cast<ValueAsMetadata>(MD))
      44      854787 :     return V->getValue();
      45             : 
      46             :   // When the value goes to null, it gets replaced by an empty MDNode.
      47             :   assert(!cast<MDNode>(MD)->getNumOperands() && "Expected an empty MDNode");
      48             :   return nullptr;
      49             : }
      50             : 
      51       82343 : int llvm::Intrinsic::lookupLLVMIntrinsicByName(ArrayRef<const char *> NameTable,
      52             :                                                StringRef Name) {
      53             :   assert(Name.startswith("llvm."));
      54             : 
      55             :   // Do successive binary searches of the dotted name components. For
      56             :   // "llvm.gc.experimental.statepoint.p1i8.p1i32", we will find the range of
      57             :   // intrinsics starting with "llvm.gc", then "llvm.gc.experimental", then
      58             :   // "llvm.gc.experimental.statepoint", and then we will stop as the range is
      59             :   // size 1. During the search, we can skip the prefix that we already know is
      60             :   // identical. By using strncmp we consider names with differing suffixes to
      61             :   // be part of the equal range.
      62       82343 :   size_t CmpStart = 0;
      63       82343 :   size_t CmpEnd = 4; // Skip the "llvm" component.
      64       82343 :   const char *const *Low = NameTable.begin();
      65       82343 :   const char *const *High = NameTable.end();
      66       82343 :   const char *const *LastLow = Low;
      67      505625 :   while (CmpEnd < Name.size() && High - Low > 0) {
      68      211641 :     CmpStart = CmpEnd;
      69      359628 :     CmpEnd = Name.find('.', CmpStart + 1);
      70      147987 :     CmpEnd = CmpEnd == StringRef::npos ? Name.size() : CmpEnd;
      71     2416745 :     auto Cmp = [CmpStart, CmpEnd](const char *LHS, const char *RHS) {
      72     2416745 :       return strncmp(LHS + CmpStart, RHS + CmpStart, CmpEnd - CmpStart) < 0;
      73      211641 :     };
      74      211641 :     LastLow = Low;
      75      846564 :     std::tie(Low, High) = std::equal_range(Low, High, Name.data(), Cmp);
      76             :   }
      77       82343 :   if (High - Low > 0)
      78       48825 :     LastLow = Low;
      79             : 
      80       82343 :   if (LastLow == NameTable.end())
      81             :     return -1;
      82      164686 :   StringRef NameFound = *LastLow;
      83             :   if (Name == NameFound ||
      84       40500 :       (Name.startswith(NameFound) && Name[NameFound.size()] == '.'))
      85       69058 :     return LastLow - NameTable.begin();
      86             :   return -1;
      87             : }
      88             : 
      89         755 : Value *InstrProfIncrementInst::getStep() const {
      90        1510 :   if (InstrProfIncrementInstStep::classof(this)) {
      91           1 :     return const_cast<Value *>(getArgOperand(4));
      92             :   }
      93         754 :   const Module *M = getModule();
      94         754 :   LLVMContext &Context = M->getContext();
      95         754 :   return ConstantInt::get(Type::getInt64Ty(Context), 1);
      96             : }
      97             : 
      98             : ConstrainedFPIntrinsic::RoundingMode
      99         195 : ConstrainedFPIntrinsic::getRoundingMode() const {
     100         390 :   unsigned NumOperands = getNumArgOperands();
     101             :   Metadata *MD =
     102         585 :       dyn_cast<MetadataAsValue>(getArgOperand(NumOperands - 2))->getMetadata();
     103         390 :   if (!MD || !isa<MDString>(MD))
     104             :     return rmInvalid;
     105         390 :   StringRef RoundingArg = cast<MDString>(MD)->getString();
     106             : 
     107             :   // For dynamic rounding mode, we use round to nearest but we will set the
     108             :   // 'exact' SDNodeFlag so that the value will not be rounded.
     109         195 :   return StringSwitch<RoundingMode>(RoundingArg)
     110         585 :     .Case("round.dynamic",    rmDynamic)
     111         585 :     .Case("round.tonearest",  rmToNearest)
     112         585 :     .Case("round.downward",   rmDownward)
     113         585 :     .Case("round.upward",     rmUpward)
     114         585 :     .Case("round.towardzero", rmTowardZero)
     115         390 :     .Default(rmInvalid);
     116             : }
     117             : 
     118             : ConstrainedFPIntrinsic::ExceptionBehavior
     119         193 : ConstrainedFPIntrinsic::getExceptionBehavior() const {
     120         386 :   unsigned NumOperands = getNumArgOperands();
     121             :   Metadata *MD =
     122         579 :       dyn_cast<MetadataAsValue>(getArgOperand(NumOperands - 1))->getMetadata();
     123         386 :   if (!MD || !isa<MDString>(MD))
     124             :     return ebInvalid;
     125         386 :   StringRef ExceptionArg = cast<MDString>(MD)->getString();
     126         193 :   return StringSwitch<ExceptionBehavior>(ExceptionArg)
     127         579 :     .Case("fpexcept.ignore",  ebIgnore)
     128         579 :     .Case("fpexcept.maytrap", ebMayTrap)
     129         579 :     .Case("fpexcept.strict",  ebStrict)
     130         386 :     .Default(ebInvalid);
     131             : }
     132             : 
     133         139 : bool ConstrainedFPIntrinsic::isUnaryOp() const {
     134         278 :   switch (getIntrinsicID()) {
     135             :     default:
     136             :       return false;
     137         119 :     case Intrinsic::experimental_constrained_sqrt:
     138             :     case Intrinsic::experimental_constrained_sin:
     139             :     case Intrinsic::experimental_constrained_cos:
     140             :     case Intrinsic::experimental_constrained_exp:
     141             :     case Intrinsic::experimental_constrained_exp2:
     142             :     case Intrinsic::experimental_constrained_log:
     143             :     case Intrinsic::experimental_constrained_log10:
     144             :     case Intrinsic::experimental_constrained_log2:
     145             :     case Intrinsic::experimental_constrained_rint:
     146             :     case Intrinsic::experimental_constrained_nearbyint:
     147         119 :       return true;
     148             :   }
     149             : }
     150             : 
     151          35 : bool ConstrainedFPIntrinsic::isTernaryOp() const {
     152          70 :   switch (getIntrinsicID()) {
     153             :     default:
     154             :       return false;
     155          19 :     case Intrinsic::experimental_constrained_fma:
     156          19 :       return true;
     157             :   }
     158             : }
     159             : 

Generated by: LCOV version 1.13