X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FSupport%2FSmallPtrSet.cpp;h=68938fa5a5716849ce499d1b56c7ef0d4fc4da04;hb=de551f91d8816632a76a065084caab9fab6aacff;hp=da1a11029e79dea9f828bc5eb05ff2c9d8fa0565;hpb=6394e5e4fd5dd0ef31ae1bb029a206aa057695f2;p=oota-llvm.git diff --git a/lib/Support/SmallPtrSet.cpp b/lib/Support/SmallPtrSet.cpp index da1a11029e7..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. // //===----------------------------------------------------------------------===// // @@ -13,12 +13,33 @@ //===----------------------------------------------------------------------===// #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; @@ -37,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! @@ -48,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. @@ -75,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) @@ -109,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*)); @@ -124,51 +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; + 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 all valid entries. - for (void **BucketPtr = that.CurArray, **E = that.CurArray+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; - } + // 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) { + 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()) + 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?"); } + + // 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()) + free(CurArray); }