LCOV - code coverage report
Current view: top level - lib/IR - Use.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 46 48 95.8 %
Date: 2018-06-17 00:07:59 Functions: 6 6 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===-- Use.cpp - Implement the Use class ---------------------------------===//
       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             : #include "llvm/IR/Use.h"
      11             : #include "llvm/IR/User.h"
      12             : #include "llvm/IR/Value.h"
      13             : #include <new>
      14             : 
      15             : namespace llvm {
      16             : 
      17       87653 : void Use::swap(Use &RHS) {
      18       87653 :   if (Val == RHS.Val)
      19             :     return;
      20             : 
      21       87653 :   if (Val)
      22             :     removeFromList();
      23             : 
      24             :   Value *OldVal = Val;
      25       87653 :   if (RHS.Val) {
      26             :     RHS.removeFromList();
      27       87653 :     Val = RHS.Val;
      28             :     Val->addUse(*this);
      29             :   } else {
      30           0 :     Val = nullptr;
      31             :   }
      32             : 
      33       87653 :   if (OldVal) {
      34       87653 :     RHS.Val = OldVal;
      35             :     RHS.Val->addUse(RHS);
      36             :   } else {
      37           0 :     RHS.Val = nullptr;
      38             :   }
      39             : }
      40             : 
      41   126471304 : User *Use::getUser() const {
      42   126471304 :   const Use *End = getImpliedUser();
      43             :   const UserRef *ref = reinterpret_cast<const UserRef *>(End);
      44   126471304 :   return ref->getInt() ? ref->getPointer()
      45   126471304 :                        : reinterpret_cast<User *>(const_cast<Use *>(End));
      46             : }
      47             : 
      48      657600 : unsigned Use::getOperandNo() const {
      49     1315200 :   return this - getUser()->op_begin();
      50             : }
      51             : 
      52             : // Sets up the waymarking algorithm's tags for a series of Uses. See the
      53             : // algorithm details here:
      54             : //
      55             : //   http://www.llvm.org/docs/ProgrammersManual.html#the-waymarking-algorithm
      56             : //
      57    12995503 : Use *Use::initTags(Use *const Start, Use *Stop) {
      58             :   ptrdiff_t Done = 0;
      59    33290488 :   while (Done < 20) {
      60    33283739 :     if (Start == Stop--)
      61             :       return Start;
      62             :     static const PrevPtrTag tags[20] = {
      63             :         fullStopTag,  oneDigitTag,  stopTag,      oneDigitTag, oneDigitTag,
      64             :         stopTag,      zeroDigitTag, oneDigitTag,  oneDigitTag, stopTag,
      65             :         zeroDigitTag, oneDigitTag,  zeroDigitTag, oneDigitTag, stopTag,
      66             :         oneDigitTag,  oneDigitTag,  oneDigitTag,  oneDigitTag, stopTag};
      67    20294985 :     new (Stop) Use(tags[Done++]);
      68             :   }
      69             : 
      70             :   ptrdiff_t Count = Done;
      71     2423414 :   while (Start != Stop) {
      72     2416665 :     --Stop;
      73     2416665 :     if (!Count) {
      74      189645 :       new (Stop) Use(stopTag);
      75      189645 :       ++Done;
      76             :       Count = Done;
      77             :     } else {
      78     2227020 :       new (Stop) Use(PrevPtrTag(Count & 1));
      79     2227020 :       Count >>= 1;
      80     2227020 :       ++Done;
      81             :     }
      82             :   }
      83             : 
      84             :   return Start;
      85             : }
      86             : 
      87    10916034 : void Use::zap(Use *Start, const Use *Stop, bool del) {
      88    26412813 :   while (Start != Stop)
      89    15496779 :     (--Stop)->~Use();
      90    10916034 :   if (del)
      91      825389 :     ::operator delete(Start);
      92    10916034 : }
      93             : 
      94   126471304 : const Use *Use::getImpliedUser() const {
      95             :   const Use *Current = this;
      96             : 
      97             :   while (true) {
      98   186881748 :     unsigned Tag = (Current++)->Prev.getInt();
      99   186881748 :     switch (Tag) {
     100    60410444 :     case zeroDigitTag:
     101             :     case oneDigitTag:
     102    60410444 :       continue;
     103             : 
     104    18218152 :     case stopTag: {
     105    18218152 :       ++Current;
     106             :       ptrdiff_t Offset = 1;
     107             :       while (true) {
     108             :         unsigned Tag = Current->Prev.getInt();
     109    47102734 :         switch (Tag) {
     110    14442291 :         case zeroDigitTag:
     111             :         case oneDigitTag:
     112    14442291 :           ++Current;
     113    14442291 :           Offset = (Offset << 1) + Tag;
     114             :           continue;
     115    18218152 :         default:
     116    18218152 :           return Current + Offset;
     117             :         }
     118    14442291 :       }
     119             :     }
     120             : 
     121             :     case fullStopTag:
     122    60410444 :       return Current;
     123             :     }
     124             :   }
     125             : }
     126             : 
     127             : } // End llvm namespace

Generated by: LCOV version 1.13