//===----------------------------------------------------------------------===//
void Use::swap(Use &RHS) {
- ptrdiff_t dist((char*)&RHS - (char*)this);
-
- if (dist) {
- Use *valid1(stripTag<tagMaskN>(Next));
- Use *valid2(stripTag<tagMaskN>(RHS.Next));
- if (valid1 && valid2) {
- bool real1(fullStopTagN != extractTag<NextPtrTag, tagMaskN>(Next));
- bool real2(fullStopTagN != extractTag<NextPtrTag, tagMaskN>(RHS.Next));
- (char*&)*stripTag<tagMask>(Prev) += dist;
- (char*&)*stripTag<tagMask>(RHS.Prev) -= dist;
- if (real1)
- (char*&)valid1->Next += dist;
- if (real2)
- (char*&)valid2->Next -= dist;
-
- }
-
- // swap the members
- std::swap(Next, RHS.Next);
- Use** Prev1 = transferTag<tagMask>(Prev, stripTag<tagMask>(RHS.Prev));
- RHS.Prev = transferTag<tagMask>(RHS.Prev, stripTag<tagMask>(Prev));
- Prev = Prev1;
- }
- /* Value *V1(Val1);
- Value *V2(RHS.Val1);
+ Value *V1(Val);
+ Value *V2(RHS.Val);
if (V1 != V2) {
if (V1) {
removeFromList();
if (V2) {
RHS.removeFromList();
- Val1 = V2;
+ Val = V2;
V2->addUse(*this);
} else {
- Val1 = 0;
+ Val = 0;
}
if (V1) {
- RHS.Val1 = V1;
+ RHS.Val = V1;
V1->addUse(RHS);
} else {
- RHS.Val1 = 0;
+ RHS.Val = 0;
}
}
- */
}
//===----------------------------------------------------------------------===//
const Use *Current = this;
while (true) {
- unsigned Tag = extractTag<PrevPtrTag, tagMask>((Current++)->Prev);
+ unsigned Tag = (Current++)->Prev.getInt();
switch (Tag) {
case zeroDigitTag:
case oneDigitTag:
++Current;
ptrdiff_t Offset = 1;
while (true) {
- unsigned Tag = extractTag<PrevPtrTag, tagMask>(Current->Prev);
+ unsigned Tag = Current->Prev.getInt();
switch (Tag) {
case zeroDigitTag:
case oneDigitTag:
//===----------------------------------------------------------------------===//
Use *Use::initTags(Use * const Start, Use *Stop, ptrdiff_t Done) {
+ while (Done < 20) {
+ if (Start == Stop--)
+ return Start;
+ static const PrevPtrTag tags[20] = { fullStopTag, oneDigitTag, stopTag,
+ oneDigitTag, oneDigitTag, stopTag,
+ zeroDigitTag, oneDigitTag, oneDigitTag,
+ stopTag, zeroDigitTag, oneDigitTag,
+ zeroDigitTag, oneDigitTag, stopTag,
+ oneDigitTag, oneDigitTag, oneDigitTag,
+ oneDigitTag, stopTag
+ };
+ Stop->Prev.setFromOpaqueValue(reinterpret_cast<Use**>(tags[Done++]));
+ Stop->Val = 0;
+ }
+
ptrdiff_t Count = Done;
while (Start != Stop) {
--Stop;
- Stop->Val1 = 0;
- Stop->Next = nilUse(0);
+ Stop->Val = 0;
if (!Count) {
- Stop->Prev = reinterpret_cast<Use**>(Done == 0 ? fullStopTag : stopTag);
+ Stop->Prev.setFromOpaqueValue(reinterpret_cast<Use**>(stopTag));
++Done;
Count = Done;
} else {
- Stop->Prev = reinterpret_cast<Use**>(Count & 1);
+ Stop->Prev.setFromOpaqueValue(reinterpret_cast<Use**>(Count & 1));
Count >>= 1;
++Done;
}
// AugmentedUse layout struct
//===----------------------------------------------------------------------===//
-struct AugmentedUse : Use {
- User *ref;
+struct AugmentedUse : public Use {
+ PointerIntPair<User*, 1, Tag> ref;
AugmentedUse(); // not implemented
};
User *Use::getUser() const {
const Use *End = getImpliedUser();
- User *She = static_cast<const AugmentedUse*>(End - 1)->ref;
- She = extractTag<Tag, tagOne>(She)
- ? llvm::stripTag<tagOne>(She)
- : reinterpret_cast<User*>(const_cast<Use*>(End));
-
- return She;
+ const PointerIntPair<User*, 1, Tag>& ref(
+ static_cast<const AugmentedUse*>(End - 1)->ref);
+ User *She = ref.getPointer();
+ return ref.getInt()
+ ? She
+ : (User*)End;
}
//===----------------------------------------------------------------------===//
+ sizeof(AugmentedUse)
- sizeof(Use)));
Use *End = Begin + N;
- static_cast<AugmentedUse&>(End[-1]).ref = addTag(this, tagOne);
+ PointerIntPair<User*, 1, Tag>& ref(static_cast<AugmentedUse&>(End[-1]).ref);
+ ref.setPointer(const_cast<User*>(this));
+ ref.setInt(tagOne);
return Use::initTags(Begin, End);
}
+//===----------------------------------------------------------------------===//
+// User operator new Implementations
+//===----------------------------------------------------------------------===//
+
+void *User::operator new(size_t s, unsigned Us) {
+ void *Storage = ::operator new(s + sizeof(Use) * Us);
+ Use *Start = static_cast<Use*>(Storage);
+ Use *End = Start + Us;
+ User *Obj = reinterpret_cast<User*>(End);
+ Obj->OperandList = Start;
+ Obj->NumOperands = Us;
+ Use::initTags(Start, End);
+ return Obj;
+}
+
+/// Prefixed allocation - just before the first Use, allocate a NULL pointer.
+/// The destructor can detect its presence and readjust the OperandList
+/// for deletition.
+///
+void *User::operator new(size_t s, unsigned Us, bool Prefix) {
+ // currently prefixed allocation only admissible for
+ // unconditional branch instructions
+ if (!Prefix)
+ return operator new(s, Us);
+
+ assert(Us == 1 && "Other than one Use allocated?");
+ typedef PointerIntPair<void*, 2, Use::PrevPtrTag> TaggedPrefix;
+ void *Raw = ::operator new(s + sizeof(TaggedPrefix) + sizeof(Use) * Us);
+ TaggedPrefix *Pre = static_cast<TaggedPrefix*>(Raw);
+ Pre->setFromOpaqueValue(0);
+ void *Storage = Pre + 1; // skip over prefix
+ Use *Start = static_cast<Use*>(Storage);
+ Use *End = Start + Us;
+ User *Obj = reinterpret_cast<User*>(End);
+ Obj->OperandList = Start;
+ Obj->NumOperands = Us;
+ Use::initTags(Start, End);
+ return Obj;
+}
+
+//===----------------------------------------------------------------------===//
+// User operator delete Implementation
+//===----------------------------------------------------------------------===//
+
+void User::operator delete(void *Usr) {
+ User *Start = static_cast<User*>(Usr);
+ Use *Storage = static_cast<Use*>(Usr) - Start->NumOperands;
+ //
+ // look for a variadic User
+ if (Storage == Start->OperandList) {
+ ::operator delete(Storage);
+ return;
+ }
+ //
+ // check for the flag whether the destructor has detected a prefixed
+ // allocation, in which case we remove the flag and delete starting
+ // at OperandList
+ if (reinterpret_cast<intptr_t>(Start->OperandList) & 1) {
+ ::operator delete(reinterpret_cast<char*>(Start->OperandList) - 1);
+ return;
+ }
+ //
+ // in all other cases just delete the nullary User (covers hung-off
+ // uses also
+ ::operator delete(Usr);
+}
+
} // End llvm namespace