/// establish the unique bits of data for the node. The Profile method is
/// passed a FoldingSetNodeID object which is used to gather the bits. Just
/// call one of the Add* functions defined in the FoldingSetImpl::NodeID class.
+/// NOTE: That the folding set does not own the nodes and it is the
+/// responsibility of the user to dispose of the nodes.
///
/// Eg.
/// class MyNode : public FoldingSetNode {
/// If found then M with be non-NULL, else InsertPoint will point to where it
/// should be inserted using InsertNode.
///
-/// 3) If you get a NULL result from FindNodeOrInsertPos then you can ass a new
+/// 3) If you get a NULL result from FindNodeOrInsertPos then you can as a new
/// node with FindNodeOrInsertPos;
///
/// InsertNode(N, InsertPoint);
///
/// bool WasRemoved = RemoveNode(N);
///
-/// The result indicates whether the node did exist in the folding set.
+/// The result indicates whether the node existed in the folding set.
//===----------------------------------------------------------------------===//
///
class FoldingSetImpl {
private:
- // Buckets - Array of bucket chains.
+ /// Buckets - Array of bucket chains.
+ ///
void **Buckets;
- // NumBuckets - Length of the Buckets array. Always a power of 2.
+ /// NumBuckets - Length of the Buckets array. Always a power of 2.
+ ///
unsigned NumBuckets;
- // NumNodes - Number of nodes in the folding set. Growth occurs when NumNodes
- // is greater than twice teh number of buckets.
+ /// NumNodes - Number of nodes in the folding set. Growth occurs when NumNodes
+ /// is greater than twice the number of buckets.
unsigned NumNodes;
public:
///
class Node {
private:
- // nextInBucket - next linek in the bucket list.
- void *nextInBucket;
+ // NextInFoldingSetBucket - next link in the bucket list.
+ void *NextInFoldingSetBucket;
public:
- Node() : nextInBucket(0) {}
+ Node() : NextInFoldingSetBucket(0) {}
// Accessors
- void *getNextInBucket() const { return nextInBucket; }
- void SetNextInBucket(void *N) { nextInBucket = N; }
+ void *getNextInBucket() const { return NextInFoldingSetBucket; }
+ void SetNextInBucket(void *N) { NextInFoldingSetBucket = N; }
};
/// RemoveNode - Remove a node from the folding set, returning true if one
/// FindNodeOrInsertPos.
void InsertNode(Node *N, void *InsertPos);
- private:
- /// GetNextPtr - In order to save space, each bucket is a
- /// singly-linked-list. In order to make deletion more efficient, we make
- /// the list circular, so we can delete a node without computing its hash.
- /// The problem with this is that the start of the hash buckets are not
- /// Nodes. If NextInBucketPtr is a bucket pointer, this method returns null
- /// : use GetBucketPtr when this happens.
- Node *GetNextPtr(void *NextInBucketPtr);
-
- /// GetNextPtr - This is just like the previous GetNextPtr implementation,
- /// but allows a bucket array to be specified.
- Node *GetNextPtr(void *NextInBucketPtr, void **Buckets, unsigned NumBuck);
-
- /// GetBucketPtr - Provides a casting of a bucket pointer for isNode
- /// testing.
- void **GetBucketPtr(void *NextInBucketPtr);
-
- /// GetBucketFor - Hash the specified node ID and return the hash bucket for
- /// the specified ID.
- void **GetBucketFor(const NodeID &ID) const;
-
- /// GrowHashTable - Double the size of the hash table and rehash everything.
- ///
- void GrowHashTable();
-
- protected:
+private:
+
+ /// GrowHashTable - Double the size of the hash table and rehash everything.
+ ///
+ void GrowHashTable();
- /// GetNodeProfile - Instantiations of the FoldingSet template implement
- /// this function to gather data bits for teh given node.
- virtual void GetNodeProfile(NodeID &ID, Node *N) = 0;
- };
+protected:
- // Convenence types to hide the implementation of the folding set.
- typedef FoldingSetImpl::Node FoldingSetNode;
- typedef FoldingSetImpl::NodeID FoldingSetNodeID;
+ /// GetNodeProfile - Instantiations of the FoldingSet template implement
+ /// this function to gather data bits for the given node.
+ virtual void GetNodeProfile(NodeID &ID, Node *N) const = 0;
+};
- //===--------------------------------------------------------------------===//
- /// FoldingSet - This template class is used to instantiate a specialized
- /// implementation of the folding set to the node class T. T must be a
- /// subclass of FoldingSetNode and implement a Profile function.
- ///
- template<class T> class FoldingSet : public FoldingSetImpl {
- private:
- /// GetNodeProfile - Each instantiatation of the FoldingSet
- virtual void GetNodeProfile(NodeID &ID, Node *N) {
- T *TN = static_cast<T *>(N);
- TN->Profile(ID);
- }
-
- public:
- /// RemoveNode - Remove a node from the folding set, returning true if one
- /// was removed or false if the node was not in the folding set.
- bool RemoveNode(T *N) {
- return FoldingSetImpl::RemoveNode(static_cast<FoldingSetNode *>(N));
- }
-
- /// GetOrInsertNode - If there is an existing simple Node exactly
- /// equal to the specified node, return it. Otherwise, insert 'N' and
- /// return it instead.
- T *GetOrInsertNode(Node *N) {
- return static_cast<T *>(FoldingSetImpl::GetOrInsertNode(
- static_cast<FoldingSetNode *>(N)));
- }
-
- /// FindNodeOrInsertPos - Look up the node specified by ID. If it exists,
- /// return it. If not, return the insertion token that will make insertion
- /// faster.
- T *FindNodeOrInsertPos(const FoldingSetNodeID &ID, void *&InsertPos) {
- return static_cast<T *>(FoldingSetImpl::FindNodeOrInsertPos(ID,
- InsertPos));
- }
-
- /// InsertNode - Insert the specified node into the folding set, knowing
- /// that it is not already in the folding set. InsertPos must be obtained
- /// from FindNodeOrInsertPos.
- void InsertNode(T *N, void *InsertPos) {
- FoldingSetImpl::InsertNode(static_cast<FoldingSetNode *>(N), InsertPos);
- }
- };
+// Convenience types to hide the implementation of the folding set.
+typedef FoldingSetImpl::Node FoldingSetNode;
+typedef FoldingSetImpl::NodeID FoldingSetNodeID;
+
+//===--------------------------------------------------------------------===//
+/// FoldingSet - This template class is used to instantiate a specialized
+/// implementation of the folding set to the node class T. T must be a
+/// subclass of FoldingSetNode and implement a Profile function.
+///
+template<class T> class FoldingSet : public FoldingSetImpl {
+private:
+ /// GetNodeProfile - Each instantiatation of the FoldingSet
+ virtual void GetNodeProfile(NodeID &ID, Node *N) const {
+ T *TN = static_cast<T *>(N);
+ TN->Profile(ID);
+ }
+
+public:
+ /// GetOrInsertNode - If there is an existing simple Node exactly
+ /// equal to the specified node, return it. Otherwise, insert 'N' and
+ /// return it instead.
+ T *GetOrInsertNode(Node *N) {
+ return static_cast<T *>(FoldingSetImpl::GetOrInsertNode(N));
+ }
+
+ /// FindNodeOrInsertPos - Look up the node specified by ID. If it exists,
+ /// return it. If not, return the insertion token that will make insertion
+ /// faster.
+ T *FindNodeOrInsertPos(const FoldingSetNodeID &ID, void *&InsertPos) {
+ return static_cast<T *>(FoldingSetImpl::FindNodeOrInsertPos(ID,
+ InsertPos));
+ }
+};
}; // End of namespace llvm.
//===----------------------------------------------------------------------===//
#include "llvm/ADT/FoldingSet.h"
-
#include "llvm/ADT/MathExtras.h"
-
using namespace llvm;
//===----------------------------------------------------------------------===//
Bits.push_back(FloatToBits(F));
}
void FoldingSetImpl::NodeID::AddDouble(double D) {
- Bits.push_back(DoubleToBits(D));
+ AddInteger(DoubleToBits(D));
}
void FoldingSetImpl::NodeID::AddString(const std::string &String) {
- // Note: An assumption is made here that strings are composed of one byte
- // chars.
unsigned Size = String.size();
- unsigned Units = Size / sizeof(unsigned);
+ unsigned Units = Size / 4;
+ unsigned Pos = 0;
const unsigned *Base = (const unsigned *)String.data();
- Bits.insert(Bits.end(), Base, Base + Units);
- if (Size & 3) {
- unsigned V = 0;
- for (unsigned i = Units * sizeof(unsigned); i < Size; ++i)
- V = (V << 8) | String[i];
- Bits.push_back(V);
+
+ // If the string is aligned do a bulk transfer.
+ if (!((intptr_t)Base & 3)) {
+ Bits.insert(Bits.end(), Base, Base + Units);
+ Pos = Units * sizeof(unsigned);
+ } else {
+ // Otherwise do it the hard way.
+ for ( Pos += 4; Pos < Size; Pos += 4) {
+ unsigned V = ((unsigned char)String[Pos - 4] << 24) |
+ ((unsigned char)String[Pos - 3] << 16) |
+ ((unsigned char)String[Pos - 2] << 8) |
+ (unsigned char)String[Pos - 1];
+ Bits.push_back(V);
+ }
}
+
+ // With the leftover bits.
+ unsigned V = 0;
+ // Pos will have overshot size by 4 - #bytes left over.
+ switch (Pos - Size) {
+ case 1: V = (V << 8) | (unsigned char)String[Size - 3]; // Fall thru.
+ case 2: V = (V << 8) | (unsigned char)String[Size - 2]; // Fall thru.
+ case 3: V = (V << 8) | (unsigned char)String[Size - 1]; break;
+ case 0: return; // Nothing left.
+ }
+
+ Bits.push_back(V);
}
/// ComputeHash - Compute a strong hash value for this NodeID, used to
//===----------------------------------------------------------------------===//
-// FoldingSetImpl Implementation
-
-FoldingSetImpl::FoldingSetImpl() : NumNodes(0) {
- NumBuckets = 64;
- Buckets = new void*[NumBuckets];
- memset(Buckets, 0, NumBuckets*sizeof(void*));
-}
-FoldingSetImpl::~FoldingSetImpl() {
- delete [] Buckets;
-}
+/// Helper functions for FoldingSetImpl.
/// GetNextPtr - In order to save space, each bucket is a
/// singly-linked-list. In order to make deletion more efficient, we make
/// The problem with this is that the start of the hash buckets are not
/// Nodes. If NextInBucketPtr is a bucket pointer, this method returns null
/// : use GetBucketPtr when this happens.
-FoldingSetImpl::Node *FoldingSetImpl::GetNextPtr(void *NextInBucketPtr) {
- if (NextInBucketPtr >= Buckets && NextInBucketPtr < Buckets+NumBuckets)
- return 0;
- return static_cast<Node*>(NextInBucketPtr);
-}
-
-/// GetNextPtr - This is just like the previous GetNextPtr implementation,
-/// but allows a bucket array to be specified.
-FoldingSetImpl::Node *FoldingSetImpl::GetNextPtr(void *NextInBucketPtr,
- void **Bucks,
- unsigned NumBuck) {
- if (NextInBucketPtr >= Bucks && NextInBucketPtr < Bucks+NumBuck)
+static FoldingSetImpl::Node *GetNextPtr(void *NextInBucketPtr,
+ void **Buckets, unsigned NumBuckets) {
+ if (NextInBucketPtr >= Buckets && NextInBucketPtr < Buckets + NumBuckets)
return 0;
- return static_cast<Node*>(NextInBucketPtr);
+ return static_cast<FoldingSetImpl::Node*>(NextInBucketPtr);
}
/// GetBucketPtr - Provides a casting of a bucket pointer for isNode
/// testing.
-void **FoldingSetImpl::GetBucketPtr(void *NextInBucketPtr) {
+static void **GetBucketPtr(void *NextInBucketPtr) {
return static_cast<void**>(NextInBucketPtr);
}
/// GetBucketFor - Hash the specified node ID and return the hash bucket for
/// the specified ID.
-void **FoldingSetImpl::GetBucketFor(const NodeID &ID) const {
+static void **GetBucketFor(const FoldingSetImpl::NodeID &ID,
+ void **Buckets, unsigned NumBuckets) {
// NumBuckets is always a power of 2.
unsigned BucketNum = ID.ComputeHash() & (NumBuckets-1);
- return Buckets+BucketNum;
+ return Buckets + BucketNum;
+}
+
+//===----------------------------------------------------------------------===//
+// FoldingSetImpl Implementation
+
+FoldingSetImpl::FoldingSetImpl() : NumNodes(0) {
+ NumBuckets = 64;
+ Buckets = new void*[NumBuckets];
+ memset(Buckets, 0, NumBuckets*sizeof(void*));
+}
+FoldingSetImpl::~FoldingSetImpl() {
+ delete [] Buckets;
}
/// GrowHashTable - Double the size of the hash table and rehash everything.
// Insert the node into the new bucket, after recomputing the hash.
NodeID ID;
GetNodeProfile(ID, NodeInBucket);
- InsertNode(NodeInBucket, GetBucketFor(ID));
+ InsertNode(NodeInBucket, GetBucketFor(ID, Buckets, NumBuckets));
}
}
/// faster.
FoldingSetImpl::Node *FoldingSetImpl::FindNodeOrInsertPos(const NodeID &ID,
void *&InsertPos) {
- void **Bucket = GetBucketFor(ID);
+ void **Bucket = GetBucketFor(ID, Buckets, NumBuckets);
void *Probe = *Bucket;
InsertPos = 0;
- while (Node *NodeInBucket = GetNextPtr(Probe)) {
+ while (Node *NodeInBucket = GetNextPtr(Probe, Buckets, NumBuckets)) {
NodeID OtherID;
GetNodeProfile(OtherID, NodeInBucket);
if (OtherID == ID)
GrowHashTable();
NodeID ID;
GetNodeProfile(ID, N);
- InsertPos = GetBucketFor(ID);
+ InsertPos = GetBucketFor(ID, Buckets, NumBuckets);
}
/// The insert position is actually a bucket pointer.
void *NodeNextPtr = Ptr;
N->SetNextInBucket(0);
while (true) {
- if (Node *NodeInBucket = GetNextPtr(Ptr)) {
+ if (Node *NodeInBucket = GetNextPtr(Ptr, Buckets, NumBuckets)) {
// Advance pointer.
Ptr = NodeInBucket->getNextInBucket();
projects / oota-llvm.git / commitdiff