LCOV - code coverage report
Current view: top level - lib/IR - Use.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 56 58 96.6 %
Date: 2017-09-14 15:23:50 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       84572 : void Use::swap(Use &RHS) {
      18       84572 :   if (Val == RHS.Val)
      19             :     return;
      20             : 
      21       84572 :   if (Val)
      22             :     removeFromList();
      23             : 
      24       84572 :   Value *OldVal = Val;
      25       84572 :   if (RHS.Val) {
      26       84572 :     RHS.removeFromList();
      27       84572 :     Val = RHS.Val;
      28       84572 :     Val->addUse(*this);
      29             :   } else {
      30           0 :     Val = nullptr;
      31             :   }
      32             : 
      33       84572 :   if (OldVal) {
      34       84572 :     RHS.Val = OldVal;
      35       84572 :     RHS.Val->addUse(RHS);
      36             :   } else {
      37           0 :     RHS.Val = nullptr;
      38             :   }
      39             : }
      40             : 
      41   102335504 : User *Use::getUser() const {
      42   102335504 :   const Use *End = getImpliedUser();
      43   102335504 :   const UserRef *ref = reinterpret_cast<const UserRef *>(End);
      44   105879533 :   return ref->getInt() ? ref->getPointer()
      45   102335504 :                        : reinterpret_cast<User *>(const_cast<Use *>(End));
      46             : }
      47             : 
      48      601545 : unsigned Use::getOperandNo() const {
      49     1203090 :   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     9903532 : Use *Use::initTags(Use *const Start, Use *Stop) {
      58     9903532 :   ptrdiff_t Done = 0;
      59    25304055 :   while (Done < 20) {
      60    25300177 :     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    30801046 :     new (Stop) Use(tags[Done++]);
      68             :   }
      69             : 
      70             :   ptrdiff_t Count = Done;
      71     2191656 :   while (Start != Stop) {
      72     2187778 :     --Stop;
      73     2187778 :     if (!Count) {
      74      326940 :       new (Stop) Use(stopTag);
      75      163470 :       ++Done;
      76      163470 :       Count = Done;
      77             :     } else {
      78     4048616 :       new (Stop) Use(PrevPtrTag(Count & 1));
      79     2024308 :       Count >>= 1;
      80     2024308 :       ++Done;
      81             :     }
      82             :   }
      83             : 
      84             :   return Start;
      85             : }
      86             : 
      87     8564347 : void Use::zap(Use *Start, const Use *Stop, bool del) {
      88    20583152 :   while (Start != Stop)
      89    12018805 :     (--Stop)->~Use();
      90     8564347 :   if (del)
      91      644125 :     ::operator delete(Start);
      92     8564347 : }
      93             : 
      94   102335504 : const Use *Use::getImpliedUser() const {
      95   102335504 :   const Use *Current = this;
      96             : 
      97             :   while (true) {
      98   301908306 :     unsigned Tag = (Current++)->Prev.getInt();
      99   150954153 :     switch (Tag) {
     100    48618649 :     case zeroDigitTag:
     101             :     case oneDigitTag:
     102    48618649 :       continue;
     103             : 
     104    11952736 :     case stopTag: {
     105    11952736 :       ++Current;
     106    11952736 :       ptrdiff_t Offset = 1;
     107             :       while (true) {
     108    34135052 :         unsigned Tag = Current->Prev.getInt();
     109    22182316 :         switch (Tag) {
     110     5114790 :         case zeroDigitTag:
     111             :         case oneDigitTag:
     112     5114790 :           ++Current;
     113     5114790 :           Offset = (Offset << 1) + Tag;
     114             :           continue;
     115    11952736 :         default:
     116    11952736 :           return Current + Offset;
     117             :         }
     118     5114790 :       }
     119             :     }
     120             : 
     121             :     case fullStopTag:
     122    48618649 :       return Current;
     123             :     }
     124             :   }
     125             : }
     126             : 
     127             : } // End llvm namespace

Generated by: LCOV version 1.13