X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FSupport%2FSmallPtrSet.cpp;h=68938fa5a5716849ce499d1b56c7ef0d4fc4da04;hb=23e97b05da7b31ed97e5ccc6330670da0173ca2e;hp=e8e530fceedb33a2271e5db7ec1a6dfda1823b9f;hpb=4d6f96d6997738419627ebe13dd6cb9c88a98fd7;p=oota-llvm.git diff --git a/lib/Support/SmallPtrSet.cpp b/lib/Support/SmallPtrSet.cpp index e8e530fceed..68938fa5a57 100644 --- a/lib/Support/SmallPtrSet.cpp +++ b/lib/Support/SmallPtrSet.cpp @@ -2,8 +2,8 @@ // // The LLVM Compiler Infrastructure // -// This file was developed by Chris Lattner and is distributed under -// the University of Illinois Open Source License. See LICENSE.TXT for details. +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // @@ -14,12 +14,32 @@ #include "llvm/ADT/SmallPtrSet.h" #include "llvm/Support/MathExtras.h" +#include + using namespace llvm; -bool SmallPtrSetImpl::insert(void *Ptr) { +void SmallPtrSetImpl::shrink_and_clear() { + assert(!isSmall() && "Can't shrink a small set!"); + free(CurArray); + + // Reduce the number of buckets. + CurArraySize = NumElements > 16 ? 1 << (Log2_32_Ceil(NumElements) + 1) : 32; + NumElements = NumTombstones = 0; + + // Install the new array. Clear all the buckets to empty. + CurArray = (const void**)malloc(sizeof(void*) * (CurArraySize+1)); + assert(CurArray && "Failed to allocate memory?"); + memset(CurArray, -1, CurArraySize*sizeof(void*)); + + // The end pointer, always valid, is set to a valid element to help the + // iterator. + CurArray[CurArraySize] = 0; +} + +bool SmallPtrSetImpl::insert_imp(const void * Ptr) { if (isSmall()) { // Check to see if it is already in the set. - for (void **APtr = SmallArray, **E = SmallArray+NumElements; + for (const void **APtr = SmallArray, **E = SmallArray+NumElements; APtr != E; ++APtr) if (*APtr == Ptr) return false; @@ -38,7 +58,7 @@ bool SmallPtrSetImpl::insert(void *Ptr) { Grow(); // Okay, we know we have space. Find a hash bucket. - void **Bucket = const_cast(FindBucketFor(Ptr)); + const void **Bucket = const_cast(FindBucketFor(Ptr)); if (*Bucket == Ptr) return false; // Already inserted, good. // Otherwise, insert it! @@ -49,10 +69,10 @@ bool SmallPtrSetImpl::insert(void *Ptr) { return true; } -bool SmallPtrSetImpl::erase(void *Ptr) { +bool SmallPtrSetImpl::erase_imp(const void * Ptr) { if (isSmall()) { // Check to see if it is in the set. - for (void **APtr = SmallArray, **E = SmallArray+NumElements; + for (const void **APtr = SmallArray, **E = SmallArray+NumElements; APtr != E; ++APtr) if (*APtr == Ptr) { // If it is in the set, replace this element. @@ -76,12 +96,12 @@ bool SmallPtrSetImpl::erase(void *Ptr) { return true; } -void * const *SmallPtrSetImpl::FindBucketFor(void *Ptr) const { +const void * const *SmallPtrSetImpl::FindBucketFor(const void *Ptr) const { unsigned Bucket = Hash(Ptr); unsigned ArraySize = CurArraySize; unsigned ProbeAmt = 1; - void *const *Array = CurArray; - void *const *Tombstone = 0; + const void *const *Array = CurArray; + const void *const *Tombstone = 0; while (1) { // Found Ptr's bucket? if (Array[Bucket] == Ptr) @@ -110,11 +130,12 @@ void SmallPtrSetImpl::Grow() { unsigned OldSize = CurArraySize; unsigned NewSize = OldSize < 64 ? 128 : OldSize*2; - void **OldBuckets = CurArray; + const void **OldBuckets = CurArray; bool WasSmall = isSmall(); // Install the new array. Clear all the buckets to empty. - CurArray = new void*[NewSize+1]; + CurArray = (const void**)malloc(sizeof(void*) * (NewSize+1)); + assert(CurArray && "Failed to allocate memory?"); CurArraySize = NewSize; memset(CurArray, -1, NewSize*sizeof(void*)); @@ -125,94 +146,78 @@ void SmallPtrSetImpl::Grow() { // Copy over all the elements. if (WasSmall) { // Small sets store their elements in order. - for (void **BucketPtr = OldBuckets, **E = OldBuckets+NumElements; + for (const void **BucketPtr = OldBuckets, **E = OldBuckets+NumElements; BucketPtr != E; ++BucketPtr) { - void *Elt = *BucketPtr; - *const_cast(FindBucketFor(Elt)) = Elt; + const void *Elt = *BucketPtr; + *const_cast(FindBucketFor(Elt)) = const_cast(Elt); } } else { // Copy over all valid entries. - for (void **BucketPtr = OldBuckets, **E = OldBuckets+OldSize; + for (const void **BucketPtr = OldBuckets, **E = OldBuckets+OldSize; BucketPtr != E; ++BucketPtr) { // Copy over the element if it is valid. - void *Elt = *BucketPtr; + const void *Elt = *BucketPtr; if (Elt != getTombstoneMarker() && Elt != getEmptyMarker()) - *const_cast(FindBucketFor(Elt)) = Elt; + *const_cast(FindBucketFor(Elt)) = const_cast(Elt); } - delete [] OldBuckets; + free(OldBuckets); NumTombstones = 0; } } SmallPtrSetImpl::SmallPtrSetImpl(const SmallPtrSetImpl& that) { - NumElements = that.NumElements; - NumTombstones = 0; + // If we're becoming small, prepare to insert into our stack space if (that.isSmall()) { - CurArraySize = that.CurArraySize; CurArray = &SmallArray[0]; - // Copy the entire contents of the array, including the -1's and the null - // terminator. - memcpy(CurArray, that.CurArray, sizeof(void*)*(CurArraySize+1)); + // Otherwise, allocate new heap space (unless we were the same size) } else { - CurArraySize = that.NumElements < 64 ? 128 : that.CurArraySize*2; - CurArray = new void*[CurArraySize+1]; - memset(CurArray, -1, CurArraySize*sizeof(void*)); - - // The end pointer, always valid, is set to a valid element to help the - // iterator. - CurArray[CurArraySize] = 0; - - // Copy over all valid entries. - for (void **BucketPtr = that.CurArray, **E = that.CurArray+that.CurArraySize; - BucketPtr != E; ++BucketPtr) { - // Copy over the element if it is valid. - void *Elt = *BucketPtr; - if (Elt != getTombstoneMarker() && Elt != getEmptyMarker()) - *const_cast(FindBucketFor(Elt)) = Elt; - } + CurArray = (const void**)malloc(sizeof(void*) * (that.CurArraySize+1)); + assert(CurArray && "Failed to allocate memory?"); } + + // Copy over the new array size + CurArraySize = that.CurArraySize; + + // Copy over the contents from the other set + memcpy(CurArray, that.CurArray, sizeof(void*)*(CurArraySize+1)); + + NumElements = that.NumElements; + NumTombstones = that.NumTombstones; } /// CopyFrom - implement operator= from a smallptrset that has the same pointer /// type, but may have a different small size. void SmallPtrSetImpl::CopyFrom(const SmallPtrSetImpl &RHS) { - // Allocate space if needed or clear the current elements out of the array. - if (CurArraySize < RHS.size()*2) { + if (isSmall() && RHS.isSmall()) + assert(CurArraySize == RHS.CurArraySize && + "Cannot assign sets with different small sizes"); + + // If we're becoming small, prepare to insert into our stack space + if (RHS.isSmall()) { if (!isSmall()) - delete [] CurArray; - - NumElements = NumTombstones = 0; - - // Get a power of two larger than twice the RHS size. - CurArraySize = 1 << Log2_32(RHS.size()*4); - - // Install the new array. Clear all the buckets to empty. - CurArray = new void*[CurArraySize+1]; - memset(CurArray, -1, CurArraySize*sizeof(void*)); - - // The end pointer, always valid, is set to a valid element to help the - // iterator. - CurArray[CurArraySize] = 0; - - } else if (!empty()) { - clear(); + free(CurArray); + CurArray = &SmallArray[0]; + // Otherwise, allocate new heap space (unless we were the same size) + } else if (CurArraySize != RHS.CurArraySize) { + if (isSmall()) + CurArray = (const void**)malloc(sizeof(void*) * (RHS.CurArraySize+1)); + else + CurArray = (const void**)realloc(CurArray, sizeof(void*)*(RHS.CurArraySize+1)); + assert(CurArray && "Failed to allocate memory?"); } - // Now that we know we have enough space, and that the current array is empty, - // copy over all the elements from the RHS. - for (void **BucketPtr = RHS.CurArray, **E = RHS.CurArray+RHS.CurArraySize; - BucketPtr != E; ++BucketPtr) { - // Copy over the element if it is valid. - void *Elt = *BucketPtr; - if (Elt != getTombstoneMarker() && Elt != getEmptyMarker()) { - if (isSmall()) - SmallArray[NumElements++] = Elt; - else - *const_cast(FindBucketFor(Elt)) = Elt; - } - } + // Copy over the new array size + CurArraySize = RHS.CurArraySize; + + // Copy over the contents from the other set + memcpy(CurArray, RHS.CurArray, sizeof(void*)*(CurArraySize+1)); + NumElements = RHS.NumElements; + NumTombstones = RHS.NumTombstones; +} + +SmallPtrSetImpl::~SmallPtrSetImpl() { if (!isSmall()) - NumElements = RHS.NumElements; + free(CurArray); }