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-07-13 00:08:38 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       87623 : void Use::swap(Use &RHS) {
      18       87623 :   if (Val == RHS.Val)
      19             :     return;
      20             : 
      21       87623 :   if (Val)
      22             :     removeFromList();
      23             : 
      24             :   Value *OldVal = Val;
      25       87623 :   if (RHS.Val) {
      26             :     RHS.removeFromList();
      27       87623 :     Val = RHS.Val;
      28             :     Val->addUse(*this);
      29             :   } else {
      30           0 :     Val = nullptr;
      31             :   }
      32             : 
      33       87623 :   if (OldVal) {
      34       87623 :     RHS.Val = OldVal;
      35             :     RHS.Val->addUse(RHS);
      36             :   } else {
      37           0 :     RHS.Val = nullptr;
      38             :   }
      39             : }
      40             : 
      41   127585979 : User *Use::getUser() const {
      42   127585979 :   const Use *End = getImpliedUser();
      43             :   const UserRef *ref = reinterpret_cast<const UserRef *>(End);
      44   127585979 :   return ref->getInt() ? ref->getPointer()
      45   127585979 :                        : reinterpret_cast<User *>(const_cast<Use *>(End));
      46             : }
      47             : 
      48      658404 : unsigned Use::getOperandNo() const {
      49     1316808 :   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    13042657 : Use *Use::initTags(Use *const Start, Use *Stop) {
      58             :   ptrdiff_t Done = 0;
      59    33343571 :   while (Done < 20) {
      60    33336871 :     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    20300914 :     new (Stop) Use(tags[Done++]);
      68             :   }
      69             : 
      70             :   ptrdiff_t Count = Done;
      71     2423273 :   while (Start != Stop) {
      72     2416573 :     --Stop;
      73     2416573 :     if (!Count) {
      74      189647 :       new (Stop) Use(stopTag);
      75      189647 :       ++Done;
      76             :       Count = Done;
      77             :     } else {
      78     2226926 :       new (Stop) Use(PrevPtrTag(Count & 1));
      79     2226926 :       Count >>= 1;
      80     2226926 :       ++Done;
      81             :     }
      82             :   }
      83             : 
      84             :   return Start;
      85             : }
      86             : 
      87    11120798 : void Use::zap(Use *Start, const Use *Stop, bool del) {
      88    26890991 :   while (Start != Stop)
      89    15770193 :     (--Stop)->~Use();
      90    11120798 :   if (del)
      91      832450 :     ::operator delete(Start);
      92    11120798 : }
      93             : 
      94   127585978 : const Use *Use::getImpliedUser() const {
      95             :   const Use *Current = this;
      96             : 
      97             :   while (true) {
      98   188407101 :     unsigned Tag = (Current++)->Prev.getInt();
      99   188407101 :     switch (Tag) {
     100    60821123 :     case zeroDigitTag:
     101             :     case oneDigitTag:
     102    60821123 :       continue;
     103             : 
     104    18247841 :     case stopTag: {
     105    18247841 :       ++Current;
     106             :       ptrdiff_t Offset = 1;
     107             :       while (true) {
     108             :         unsigned Tag = Current->Prev.getInt();
     109    47146465 :         switch (Tag) {
     110    14449312 :         case zeroDigitTag:
     111             :         case oneDigitTag:
     112    14449312 :           ++Current;
     113    14449312 :           Offset = (Offset << 1) + Tag;
     114             :           continue;
     115    18247841 :         default:
     116    18247841 :           return Current + Offset;
     117             :         }
     118    14449312 :       }
     119             :     }
     120             : 
     121             :     case fullStopTag:
     122    60821123 :       return Current;
     123             :     }
     124             :   }
     125             : }
     126             : 
     127             : } // End llvm namespace

Generated by: LCOV version 1.13