RPCSX/llvm
1
0
Fork 0
mirror of https://github.com/RPCSX/llvm.git synced 2025-02-10 14:36:01 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

[cleanup] Run clang-format over the Use code. It was *really*

Browse Source 
inconsistent both with itself and with LLVM at large with formatting.
The *s were on the wrong side, the indent was off, etc etc. This is much
cleaner.

Also, go clang-format laying out the array of tags in nice columns.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@202799 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chandler Carruth 2014-03-04 08:53:41 +00:00
parent 0a6057117e
commit 2bfe24c418
2 changed files with 55 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
include/llvm/IR/Use.h
View File

@ -37,16 +37,14 @@ namespace llvm {
class Value; class Value;
class User; class User;
class Use; class Use;
template<typename> template <typename> struct simplify_type;
struct simplify_type;
// Use** is only 4-byte aligned. // Use** is only 4-byte aligned.
template<> template <> class PointerLikeTypeTraits<Use **> {
class PointerLikeTypeTraits<Use**> {
public: public:
static inline void *getAsVoidPointer(Use** P) { return P; } static inline void *getAsVoidPointer(Use **P) { return P; }
static inline Use **getFromVoidPointer(void *P) { static inline Use **getFromVoidPointer(void *P) {
return static_cast<Use**>(P); return static_cast<Use **>(P);
} }
enum { NumLowBitsAvailable = 2 }; enum { NumLowBitsAvailable = 2 };
}; };
@ -76,28 +74,24 @@ public:
// A type for the word following an array of hung-off Uses in memory, which is // A type for the word following an array of hung-off Uses in memory, which is
// a pointer back to their User with the bottom bit set. // a pointer back to their User with the bottom bit set.
typedef PointerIntPair<User*, 1, unsigned> UserRef; typedef PointerIntPair<User *, 1, unsigned> UserRef;
private: private:
Use(const Use &U) LLVM_DELETED_FUNCTION; Use(const Use &U) LLVM_DELETED_FUNCTION;
/// Destructor - Only for zap() /// Destructor - Only for zap()
~Use() { ~Use() {
if (Val) removeFromList(); if (Val)
removeFromList();
} }
enum PrevPtrTag { zeroDigitTag enum PrevPtrTag { zeroDigitTag, oneDigitTag, stopTag, fullStopTag };
, oneDigitTag
, stopTag
, fullStopTag };
/// Constructor /// Constructor
Use(PrevPtrTag tag) : Val(0) { Use(PrevPtrTag tag) : Val(0) { Prev.setInt(tag); }
Prev.setInt(tag);
}
public: public:
operator Value*() const { return Val; } operator Value *() const { return Val; }
Value *get() const { return Val; } Value *get() const { return Val; }
/// \brief Returns the User that contains this Use. /// \brief Returns the User that contains this Use.
@ -117,7 +111,7 @@ public:
return *this; return *this;
} }
Value *operator->() { return Val; } Value *operator->() { return Val; }
const Value *operator->() const { return Val; } const Value *operator->() const { return Val; }
Use *getNext() const { return Next; } Use *getNext() const { return Next; }
@ -133,25 +127,25 @@ public:
static void zap(Use *Start, const Use *Stop, bool del = false); static void zap(Use *Start, const Use *Stop, bool del = false);
private: private:
const Use* getImpliedUser() const; const Use *getImpliedUser() const;
Value *Val; Value *Val;
Use *Next; Use *Next;
PointerIntPair<Use**, 2, PrevPtrTag> Prev; PointerIntPair<Use **, 2, PrevPtrTag> Prev;
void setPrev(Use **NewPrev) { void setPrev(Use **NewPrev) { Prev.setPointer(NewPrev); }
Prev.setPointer(NewPrev);
}
void addToList(Use **List) { void addToList(Use **List) {
Next = *List; Next = *List;
if (Next) Next->setPrev(&Next); if (Next)
Next->setPrev(&Next);
setPrev(List); setPrev(List);
*List = this; *List = this;
} }
void removeFromList() { void removeFromList() {
Use **StrippedPrev = Prev.getPointer(); Use **StrippedPrev = Prev.getPointer();
*StrippedPrev = Next; *StrippedPrev = Next;
if (Next) Next->setPrev(StrippedPrev); if (Next)
Next->setPrev(StrippedPrev);
} }
friend class Value; friend class Value;
@ -159,21 +153,15 @@ private:
/// \brief Allow clients to treat uses just like values when using /// \brief Allow clients to treat uses just like values when using
/// casting operators. /// casting operators.
template<> struct simplify_type<Use> { template <> struct simplify_type<Use> {
typedef Value* SimpleType; typedef Value *SimpleType;
static SimpleType getSimplifiedValue(Use &Val) { static SimpleType getSimplifiedValue(Use &Val) { return Val.get(); }
return Val.get();
}
}; };
template<> struct simplify_type<const Use> { template <> struct simplify_type<const Use> {
typedef /*const*/ Value* SimpleType; typedef /*const*/ Value *SimpleType;
static SimpleType getSimplifiedValue(const Use &Val) { static SimpleType getSimplifiedValue(const Use &Val) { return Val.get(); }
return Val.get();
}
}; };
template<typename UserTy> // UserTy == 'User' or 'const User' template<typename UserTy> // UserTy == 'User' or 'const User'
class value_use_iterator : public std::iterator<std::forward_iterator_tag, class value_use_iterator : public std::iterator<std::forward_iterator_tag,
UserTy*, ptrdiff_t> { UserTy*, ptrdiff_t> {

66
lib/IR/Use.cpp
View File

@ -40,10 +40,9 @@ void Use::swap(Use &RHS) {
User *Use::getUser() const { User *Use::getUser() const {
const Use *End = getImpliedUser(); const Use *End = getImpliedUser();
const UserRef *ref = reinterpret_cast<const UserRef*>(End); const UserRef *ref = reinterpret_cast<const UserRef *>(End);
return ref->getInt() return ref->getInt() ? ref->getPointer()
? ref->getPointer() : reinterpret_cast<User *>(const_cast<Use *>(End));
: reinterpret_cast<User*>(const_cast<Use*>(End));
} }
// Sets up the waymarking algoritm's tags for a series of Uses. See the // Sets up the waymarking algoritm's tags for a series of Uses. See the
@ -51,31 +50,28 @@ User *Use::getUser() const {
// //
// http://www.llvm.org/docs/ProgrammersManual.html#UserLayout // http://www.llvm.org/docs/ProgrammersManual.html#UserLayout
// //
Use *Use::initTags(Use * const Start, Use *Stop) { Use *Use::initTags(Use *const Start, Use *Stop) {
ptrdiff_t Done = 0; ptrdiff_t Done = 0;
while (Done < 20) { while (Done < 20) {
if (Start == Stop--) if (Start == Stop--)
return Start; return Start;
static const PrevPtrTag tags[20] = { fullStopTag, oneDigitTag, stopTag, static const PrevPtrTag tags[20] = {
oneDigitTag, oneDigitTag, stopTag, fullStopTag, oneDigitTag, stopTag, oneDigitTag, oneDigitTag,
zeroDigitTag, oneDigitTag, oneDigitTag, stopTag, zeroDigitTag, oneDigitTag, oneDigitTag, stopTag,
stopTag, zeroDigitTag, oneDigitTag, zeroDigitTag, oneDigitTag, zeroDigitTag, oneDigitTag, stopTag,
zeroDigitTag, oneDigitTag, stopTag, oneDigitTag, oneDigitTag, oneDigitTag, oneDigitTag, stopTag};
oneDigitTag, oneDigitTag, oneDigitTag, new (Stop) Use(tags[Done++]);
oneDigitTag, stopTag
};
new(Stop) Use(tags[Done++]);
} }
ptrdiff_t Count = Done; ptrdiff_t Count = Done;
while (Start != Stop) { while (Start != Stop) {
--Stop; --Stop;
if (!Count) { if (!Count) {
new(Stop) Use(stopTag); new (Stop) Use(stopTag);
++Done; ++Done;
Count = Done; Count = Done;
} else { } else {
new(Stop) Use(PrevPtrTag(Count & 1)); new (Stop) Use(PrevPtrTag(Count & 1));
Count >>= 1; Count >>= 1;
++Done; ++Done;
} }
@ -97,29 +93,29 @@ const Use *Use::getImpliedUser() const {
while (true) { while (true) {
unsigned Tag = (Current++)->Prev.getInt(); unsigned Tag = (Current++)->Prev.getInt();
switch (Tag) { switch (Tag) {
case zeroDigitTag: case zeroDigitTag:
case oneDigitTag: case oneDigitTag:
continue; continue;
case stopTag: { case stopTag: {
++Current; ++Current;
ptrdiff_t Offset = 1; ptrdiff_t Offset = 1;
while (true) { while (true) {
unsigned Tag = Current->Prev.getInt(); unsigned Tag = Current->Prev.getInt();
switch (Tag) { switch (Tag) {
case zeroDigitTag: case zeroDigitTag:
case oneDigitTag: case oneDigitTag:
++Current; ++Current;
Offset = (Offset << 1) + Tag; Offset = (Offset << 1) + Tag;
continue; continue;
default: default:
return Current + Offset; return Current + Offset;
}
} }
} }
}
case fullStopTag: case fullStopTag:
return Current; return Current;
} }
} }
} }