lib/VMCore/Use.cpp

   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 // This file implements the algorithm for finding the User of a Use.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "llvm/User.h"
  15
  16 namespace llvm {
  17
  18 //===----------------------------------------------------------------------===//
  19 //                         Use swap Implementation
  20 //===----------------------------------------------------------------------===//
  21
  22 void Use::swap(Use &RHS) {
  23   Value *V1(Val);
  24   Value *V2(RHS.Val);
  25   if (V1 != V2) {
  26     if (V1) {
  27       removeFromList();
  28     }
  29
  30     if (V2) {
  31       RHS.removeFromList();
  32       Val = V2;
  33       V2->addUse(*this);
  34     } else {
  35       Val = 0;
  36     }
  37
  38     if (V1) {
  39       RHS.Val = V1;
  40       V1->addUse(RHS);
  41     } else {
  42       RHS.Val = 0;
  43     }
  44   }
  45 }
  46
  47 //===----------------------------------------------------------------------===//
  48 //                         Use getImpliedUser Implementation
  49 //===----------------------------------------------------------------------===//
  50
  51 const Use *Use::getImpliedUser() const {
  52   const Use *Current = this;
  53
  54   while (true) {
  55     unsigned Tag = extractTag<PrevPtrTag, fullStopTag>((Current++)->Prev);
  56     switch (Tag) {
  57       case zeroDigitTag:
  58       case oneDigitTag:
  59         continue;
  60
  61       case stopTag: {
  62         ++Current;
  63         ptrdiff_t Offset = 1;
  64         while (true) {
  65           unsigned Tag = extractTag<PrevPtrTag, fullStopTag>(Current->Prev);
  66           switch (Tag) {
  67             case zeroDigitTag:
  68             case oneDigitTag:
  69               ++Current;
  70               Offset = (Offset << 1) + Tag;
  71               continue;
  72             default:
  73               return Current + Offset;
  74           }
  75         }
  76       }
  77
  78       case fullStopTag:
  79         return Current;
  80     }
  81   }
  82 }
  83
  84 //===----------------------------------------------------------------------===//
  85 //                         Use initTags Implementation
  86 //===----------------------------------------------------------------------===//
  87
  88 Use *Use::initTags(Use * const Start, Use *Stop, ptrdiff_t Done) {
  89   ptrdiff_t Count = Done;
  90   while (Start != Stop) {
  91     --Stop;
  92     Stop->Val = 0;
  93     if (!Count) {
  94       Stop->Prev = reinterpret_cast<Use**>(Done == 0 ? fullStopTag : stopTag);
  95       ++Done;
  96       Count = Done;
  97     } else {
  98       Stop->Prev = reinterpret_cast<Use**>(Count & 1);
  99       Count >>= 1;
 100       ++Done;
 101     }
 102   }
 103
 104   return Start;
 105 }
 106
 107 //===----------------------------------------------------------------------===//
 108 //                         Use zap Implementation
 109 //===----------------------------------------------------------------------===//
 110
 111 void Use::zap(Use *Start, const Use *Stop, bool del) {
 112   if (del) {
 113     while (Start != Stop) {
 114       (--Stop)->~Use();
 115     }
 116     ::operator delete(Start);
 117     return;
 118   }
 119
 120   while (Start != Stop) {
 121     (Start++)->set(0);
 122   }
 123 }
 124
 125 //===----------------------------------------------------------------------===//
 126 //                         AugmentedUse layout struct
 127 //===----------------------------------------------------------------------===//
 128
 129 struct AugmentedUse : Use {
 130   User *ref;
 131   AugmentedUse(); // not implemented
 132 };
 133
 134
 135 //===----------------------------------------------------------------------===//
 136 //                         Use getUser Implementation
 137 //===----------------------------------------------------------------------===//
 138
 139 User *Use::getUser() const {
 140   const Use *End = getImpliedUser();
 141   User *She = static_cast<const AugmentedUse*>(End - 1)->ref;
 142   She = extractTag<Tag, tagOne>(She)
 143       ? llvm::stripTag<tagOne>(She)
 144       : reinterpret_cast<User*>(const_cast<Use*>(End));
 145
 146   return She;
 147 }
 148
 149 //===----------------------------------------------------------------------===//
 150 //                         User allocHungoffUses Implementation
 151 //===----------------------------------------------------------------------===//
 152
 153 Use *User::allocHungoffUses(unsigned N) const {
 154   Use *Begin = static_cast<Use*>(::operator new(sizeof(Use) * N
 155                                                 + sizeof(AugmentedUse)
 156                                                 - sizeof(Use)));
 157   Use *End = Begin + N;
 158   static_cast<AugmentedUse&>(End[-1]).ref = addTag(this, tagOne);
 159   return Use::initTags(Begin, End);
 160 }
 161
 162 } // End llvm namespace