[vmkit-commits] [vmkit] r136594 - in /vmkit/trunk: include/j3/JavaAOTCompiler.h include/mvm/MvmDenseMap.h include/mvm/UTF8.h lib/J3/Compiler/JavaAOTCompiler.cpp lib/J3/VMCore/LockedMap.cpp lib/J3/VMCore/LockedMap.h lib/J3/VMCore/Precompiled.cpp lib/Mvm/Runtime/UTF8.cpp
Nicolas Geoffray
nicolas.geoffray at lip6.fr
Sun Jul 31 09:56:00 PDT 2011
Author: geoffray
Date: Sun Jul 31 11:56:00 2011
New Revision: 136594
URL: http://llvm.org/viewvc/llvm-project?rev=136594&view=rev
Log:
Move j3::J3DenseMap to mvm::MvmDenseMap.
Added:
vmkit/trunk/include/mvm/MvmDenseMap.h
Modified:
vmkit/trunk/include/j3/JavaAOTCompiler.h
vmkit/trunk/include/mvm/UTF8.h
vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp
vmkit/trunk/lib/J3/VMCore/LockedMap.cpp
vmkit/trunk/lib/J3/VMCore/LockedMap.h
vmkit/trunk/lib/J3/VMCore/Precompiled.cpp
vmkit/trunk/lib/Mvm/Runtime/UTF8.cpp
Modified: vmkit/trunk/include/j3/JavaAOTCompiler.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/j3/JavaAOTCompiler.h?rev=136594&r1=136593&r2=136594&view=diff
==============================================================================
--- vmkit/trunk/include/j3/JavaAOTCompiler.h (original)
+++ vmkit/trunk/include/j3/JavaAOTCompiler.h Sun Jul 31 11:56:00 2011
@@ -10,8 +10,8 @@
#ifndef J3_AOT_COMPILER_H
#define J3_AOT_COMPILER_H
+#include "mvm/MvmDenseMap.h"
#include "j3/JavaLLVMCompiler.h"
-#include "j3/J3DenseMap.h"
namespace j3 {
@@ -100,7 +100,7 @@
llvm::Constant* CreateConstantFromJavaObject(JavaObject* obj);
llvm::Constant* CreateConstantFromClassBytes(ClassBytes* bytes);
llvm::Constant* CreateConstantFromJavaConstantPool(JavaConstantPool* ctp);
- llvm::Constant* CreateConstantFromClassMap(const J3DenseMap<const UTF8*, CommonClass*>& map);
+ llvm::Constant* CreateConstantFromClassMap(const mvm::MvmDenseMap<const UTF8*, CommonClass*>& map);
void AddInitializerToClass(llvm::GlobalVariable* varGV, CommonClass* classDef);
llvm::Constant* getUTF8(const UTF8* val);
Added: vmkit/trunk/include/mvm/MvmDenseMap.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/MvmDenseMap.h?rev=136594&view=auto
==============================================================================
--- vmkit/trunk/include/mvm/MvmDenseMap.h (added)
+++ vmkit/trunk/include/mvm/MvmDenseMap.h Sun Jul 31 11:56:00 2011
@@ -0,0 +1,512 @@
+//===- MvmDenseMap.h - Dense probed hash table ------------------*- C++ -*-===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file defines the MvmDenseMap copied from llvm/ADT/DenseMap.h, but
+// without storing pairs.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef MVM_DENSEMAP_H
+#define MVM_DENSEMAP_H
+
+#include "llvm/Support/MathExtras.h"
+#include "llvm/Support/PointerLikeTypeTraits.h"
+#include "llvm/Support/type_traits.h"
+#include <algorithm>
+#include <iterator>
+#include <new>
+#include <utility>
+#include <cassert>
+#include <cstddef>
+#include <cstring>
+
+namespace mvm {
+
+template<typename T>
+struct MvmDenseMapInfo {
+ //static inline T getEmptyKey();
+ //static inline T getTombstoneKey();
+ //static unsigned getHashValue(const T &Val);
+ //static bool isEqual(const T &LHS, const T &RHS);
+};
+
+template<typename KeyT, typename ValueT,
+ typename KeyInfoT = MvmDenseMapInfo<KeyT>,
+ bool IsConst = false>
+class MvmDenseMapIterator;
+
+template<typename KeyT, typename ValueT>
+struct MvmPair {
+ KeyT first;
+ ValueT second;
+};
+
+template<typename KeyT, typename ValueT,
+ typename KeyInfoT = MvmDenseMapInfo<KeyT> >
+class MvmDenseMap {
+public:
+ typedef MvmPair<KeyT, ValueT> BucketT;
+ uint32_t NumBuckets;
+ BucketT *Buckets;
+
+ uint32_t NumEntries;
+ uint32_t NumTombstones;
+ bool IsPrecompiled;
+
+ typedef KeyT key_type;
+ typedef ValueT mapped_type;
+ typedef BucketT value_type;
+
+ explicit MvmDenseMap(unsigned NumInitBuckets = 0) {
+ IsPrecompiled = false;
+ init(NumInitBuckets);
+ }
+
+ ~MvmDenseMap() {
+ const KeyT EmptyKey = getEmptyKey(), TombstoneKey = getTombstoneKey();
+ for (BucketT *P = Buckets, *E = Buckets+NumBuckets; P != E; ++P) {
+ if (!KeyInfoT::isEqual(P->first, EmptyKey) &&
+ !KeyInfoT::isEqual(P->first, TombstoneKey))
+ P->second.~ValueT();
+ P->first.~KeyT();
+ }
+#ifndef NDEBUG
+ if (NumBuckets)
+ memset((void*)Buckets, 0x5a, sizeof(BucketT)*NumBuckets);
+#endif
+ if (!IsPrecompiled) {
+ operator delete(Buckets);
+ }
+ }
+
+ typedef MvmDenseMapIterator<KeyT, ValueT, KeyInfoT> iterator;
+ typedef MvmDenseMapIterator<KeyT, ValueT, KeyInfoT, true> const_iterator;
+ inline iterator begin() {
+ // When the map is empty, avoid the overhead of AdvancePastEmptyBuckets().
+ return empty() ? end() : iterator(Buckets, Buckets+NumBuckets);
+ }
+ inline iterator end() {
+ return iterator(Buckets+NumBuckets, Buckets+NumBuckets);
+ }
+ inline const_iterator begin() const {
+ return empty() ? end() : const_iterator(Buckets, Buckets+NumBuckets);
+ }
+ inline const_iterator end() const {
+ return const_iterator(Buckets+NumBuckets, Buckets+NumBuckets);
+ }
+
+ bool empty() const { return NumEntries == 0; }
+ unsigned size() const { return NumEntries; }
+
+ /// Grow the densemap so that it has at least Size buckets. Does not shrink
+ void resize(size_t Size) {
+ if (Size > NumBuckets)
+ grow(Size);
+ }
+
+ void clear() {
+ if (NumEntries == 0 && NumTombstones == 0) return;
+
+ // If the capacity of the array is huge, and the # elements used is small,
+ // shrink the array.
+ if (NumEntries * 4 < NumBuckets && NumBuckets > 64) {
+ shrink_and_clear();
+ return;
+ }
+
+ const KeyT EmptyKey = getEmptyKey(), TombstoneKey = getTombstoneKey();
+ for (BucketT *P = Buckets, *E = Buckets+NumBuckets; P != E; ++P) {
+ if (!KeyInfoT::isEqual(P->first, EmptyKey)) {
+ if (!KeyInfoT::isEqual(P->first, TombstoneKey)) {
+ P->second.~ValueT();
+ --NumEntries;
+ }
+ P->first = EmptyKey;
+ }
+ }
+ assert(NumEntries == 0 && "Node count imbalance!");
+ NumTombstones = 0;
+ }
+
+ /// count - Return true if the specified key is in the map.
+ bool count(const KeyT &Val) const {
+ BucketT *TheBucket;
+ return LookupBucketFor(Val, TheBucket);
+ }
+
+ iterator find(const KeyT &Val) {
+ BucketT *TheBucket;
+ if (LookupBucketFor(Val, TheBucket))
+ return iterator(TheBucket, Buckets+NumBuckets);
+ return end();
+ }
+ const_iterator find(const KeyT &Val) const {
+ BucketT *TheBucket;
+ if (LookupBucketFor(Val, TheBucket))
+ return const_iterator(TheBucket, Buckets+NumBuckets);
+ return end();
+ }
+
+ /// lookup - Return the entry for the specified key, or a default
+ /// constructed value if no such entry exists.
+ ValueT lookup(const KeyT &Val) const {
+ BucketT *TheBucket;
+ if (LookupBucketFor(Val, TheBucket))
+ return TheBucket->second;
+ return ValueT();
+ }
+
+ // Inserts key,value pair into the map if the key isn't already in the map.
+ // If the key is already in the map, it returns false and doesn't update the
+ // value.
+ std::pair<iterator, bool> insert(const std::pair<KeyT, ValueT> &KV) {
+ BucketT *TheBucket;
+ if (LookupBucketFor(KV.first, TheBucket))
+ return std::make_pair(iterator(TheBucket, Buckets+NumBuckets),
+ false); // Already in map.
+
+ // Otherwise, insert the new element.
+ TheBucket = InsertIntoBucket(KV.first, KV.second, TheBucket);
+ return std::make_pair(iterator(TheBucket, Buckets+NumBuckets),
+ true);
+ }
+
+ /// insert - Range insertion of pairs.
+ template<typename InputIt>
+ void insert(InputIt I, InputIt E) {
+ for (; I != E; ++I)
+ insert(*I);
+ }
+
+
+ bool erase(const KeyT &Val) {
+ BucketT *TheBucket;
+ if (!LookupBucketFor(Val, TheBucket))
+ return false; // not in map.
+
+ TheBucket->second.~ValueT();
+ TheBucket->first = getTombstoneKey();
+ --NumEntries;
+ ++NumTombstones;
+ return true;
+ }
+ void erase(iterator I) {
+ BucketT *TheBucket = &*I;
+ TheBucket->second.~ValueT();
+ TheBucket->first = getTombstoneKey();
+ --NumEntries;
+ ++NumTombstones;
+ }
+
+ void swap(MvmDenseMap& RHS) {
+ std::swap(NumBuckets, RHS.NumBuckets);
+ std::swap(Buckets, RHS.Buckets);
+ std::swap(NumEntries, RHS.NumEntries);
+ std::swap(NumTombstones, RHS.NumTombstones);
+ }
+
+ value_type& FindAndConstruct(const KeyT &Key) {
+ BucketT *TheBucket;
+ if (LookupBucketFor(Key, TheBucket))
+ return *TheBucket;
+
+ return *InsertIntoBucket(Key, ValueT(), TheBucket);
+ }
+
+ ValueT &operator[](const KeyT &Key) {
+ return FindAndConstruct(Key).second;
+ }
+
+ /// isPointerIntoBucketsArray - Return true if the specified pointer points
+ /// somewhere into the MvmDenseMap's array of buckets (i.e. either to a key or
+ /// value in the MvmDenseMap).
+ bool isPointerIntoBucketsArray(const void *Ptr) const {
+ return Ptr >= Buckets && Ptr < Buckets+NumBuckets;
+ }
+
+ /// getPointerIntoBucketsArray() - Return an opaque pointer into the buckets
+ /// array. In conjunction with the previous method, this can be used to
+ /// determine whether an insertion caused the MvmDenseMap to reallocate.
+ const void *getPointerIntoBucketsArray() const { return Buckets; }
+
+private:
+ BucketT *InsertIntoBucket(const KeyT &Key, const ValueT &Value,
+ BucketT *TheBucket) {
+ // If the load of the hash table is more than 3/4, or if fewer than 1/8 of
+ // the buckets are empty (meaning that many are filled with tombstones),
+ // grow the table.
+ //
+ // The later case is tricky. For example, if we had one empty bucket with
+ // tons of tombstones, failing lookups (e.g. for insertion) would have to
+ // probe almost the entire table until it found the empty bucket. If the
+ // table completely filled with tombstones, no lookup would ever succeed,
+ // causing infinite loops in lookup.
+ ++NumEntries;
+ if (NumEntries*4 >= NumBuckets*3) {
+ this->grow(NumBuckets * 2);
+ LookupBucketFor(Key, TheBucket);
+ }
+ if (NumBuckets-(NumEntries+NumTombstones) < NumBuckets/8) {
+ this->grow(NumBuckets);
+ LookupBucketFor(Key, TheBucket);
+ }
+
+ // If we are writing over a tombstone, remember this.
+ if (!KeyInfoT::isEqual(TheBucket->first, getEmptyKey()))
+ --NumTombstones;
+
+ TheBucket->first = Key;
+ new (&TheBucket->second) ValueT(Value);
+ return TheBucket;
+ }
+
+ static unsigned getHashValue(const KeyT &Val) {
+ return KeyInfoT::getHashValue(Val);
+ }
+ static const KeyT getEmptyKey() {
+ return KeyInfoT::getEmptyKey();
+ }
+ static const KeyT getTombstoneKey() {
+ return KeyInfoT::getTombstoneKey();
+ }
+
+ /// LookupBucketFor - Lookup the appropriate bucket for Val, returning it in
+ /// FoundBucket. If the bucket contains the key and a value, this returns
+ /// true, otherwise it returns a bucket with an empty marker or tombstone and
+ /// returns false.
+ bool LookupBucketFor(const KeyT &Val, BucketT *&FoundBucket) const {
+ unsigned BucketNo = getHashValue(Val);
+ unsigned ProbeAmt = 1;
+ BucketT *BucketsPtr = Buckets;
+
+ if (NumBuckets == 0) {
+ FoundBucket = 0;
+ return false;
+ }
+
+ // FoundTombstone - Keep track of whether we find a tombstone while probing.
+ BucketT *FoundTombstone = 0;
+ const KeyT EmptyKey = getEmptyKey();
+ const KeyT TombstoneKey = getTombstoneKey();
+ assert(!KeyInfoT::isEqual(Val, EmptyKey) &&
+ !KeyInfoT::isEqual(Val, TombstoneKey) &&
+ "Empty/Tombstone value shouldn't be inserted into map!");
+
+ while (1) {
+ BucketT *ThisBucket = BucketsPtr + (BucketNo & (NumBuckets-1));
+ // Found Val's bucket? If so, return it.
+ if (KeyInfoT::isEqual(ThisBucket->first, Val)) {
+ FoundBucket = ThisBucket;
+ return true;
+ }
+
+ // If we found an empty bucket, the key doesn't exist in the set.
+ // Insert it and return the default value.
+ if (KeyInfoT::isEqual(ThisBucket->first, EmptyKey)) {
+ // If we've already seen a tombstone while probing, fill it in instead
+ // of the empty bucket we eventually probed to.
+ if (FoundTombstone) ThisBucket = FoundTombstone;
+ FoundBucket = FoundTombstone ? FoundTombstone : ThisBucket;
+ return false;
+ }
+
+ // If this is a tombstone, remember it. If Val ends up not in the map, we
+ // prefer to return it than something that would require more probing.
+ if (KeyInfoT::isEqual(ThisBucket->first, TombstoneKey) && !FoundTombstone)
+ FoundTombstone = ThisBucket; // Remember the first tombstone found.
+
+ // Otherwise, it's a hash collision or a tombstone, continue quadratic
+ // probing.
+ BucketNo += ProbeAmt++;
+ }
+ }
+
+ void init(unsigned InitBuckets) {
+ NumEntries = 0;
+ NumTombstones = 0;
+ NumBuckets = InitBuckets;
+
+ if (InitBuckets == 0) {
+ Buckets = 0;
+ return;
+ }
+
+ assert(InitBuckets && (InitBuckets & (InitBuckets-1)) == 0 &&
+ "# initial buckets must be a power of two!");
+ Buckets = static_cast<BucketT*>(operator new(sizeof(BucketT)*InitBuckets));
+ // Initialize all the keys to EmptyKey.
+ const KeyT EmptyKey = getEmptyKey();
+ for (unsigned i = 0; i != InitBuckets; ++i)
+ new (&Buckets[i].first) KeyT(EmptyKey);
+ }
+
+ void grow(unsigned AtLeast) {
+ unsigned OldNumBuckets = NumBuckets;
+ BucketT *OldBuckets = Buckets;
+
+ if (NumBuckets < 64)
+ NumBuckets = 64;
+
+ // Double the number of buckets.
+ while (NumBuckets < AtLeast)
+ NumBuckets <<= 1;
+ NumTombstones = 0;
+ Buckets = static_cast<BucketT*>(operator new(sizeof(BucketT)*NumBuckets));
+
+ // Initialize all the keys to EmptyKey.
+ const KeyT EmptyKey = getEmptyKey();
+ for (unsigned i = 0, e = NumBuckets; i != e; ++i)
+ new (&Buckets[i].first) KeyT(EmptyKey);
+
+ // Insert all the old elements.
+ const KeyT TombstoneKey = getTombstoneKey();
+ for (BucketT *B = OldBuckets, *E = OldBuckets+OldNumBuckets; B != E; ++B) {
+ if (!KeyInfoT::isEqual(B->first, EmptyKey) &&
+ !KeyInfoT::isEqual(B->first, TombstoneKey)) {
+ // Insert the key/value into the new table.
+ BucketT *DestBucket;
+ bool FoundVal = LookupBucketFor(B->first, DestBucket);
+ (void)FoundVal; // silence warning.
+ assert(!FoundVal && "Key already in new map?");
+ DestBucket->first = B->first;
+ new (&DestBucket->second) ValueT(B->second);
+
+ // Free the value.
+ B->second.~ValueT();
+ }
+ B->first.~KeyT();
+ }
+
+#ifndef NDEBUG
+ if (OldNumBuckets)
+ memset((void*)OldBuckets, 0x5a, sizeof(BucketT)*OldNumBuckets);
+#endif
+ // Free the old table.
+ if (!IsPrecompiled) {
+ operator delete(OldBuckets);
+ } else {
+ IsPrecompiled = false;
+ }
+ }
+
+ void shrink_and_clear() {
+ unsigned OldNumBuckets = NumBuckets;
+ BucketT *OldBuckets = Buckets;
+
+ // Reduce the number of buckets.
+ NumBuckets = NumEntries > 32 ? 1 << (llvm::Log2_32_Ceil(NumEntries) + 1)
+ : 64;
+ NumTombstones = 0;
+ Buckets = static_cast<BucketT*>(operator new(sizeof(BucketT)*NumBuckets));
+
+ // Initialize all the keys to EmptyKey.
+ const KeyT EmptyKey = getEmptyKey();
+ for (unsigned i = 0, e = NumBuckets; i != e; ++i)
+ new (&Buckets[i].first) KeyT(EmptyKey);
+
+ // Free the old buckets.
+ const KeyT TombstoneKey = getTombstoneKey();
+ for (BucketT *B = OldBuckets, *E = OldBuckets+OldNumBuckets; B != E; ++B) {
+ if (!KeyInfoT::isEqual(B->first, EmptyKey) &&
+ !KeyInfoT::isEqual(B->first, TombstoneKey)) {
+ // Free the value.
+ B->second.~ValueT();
+ }
+ B->first.~KeyT();
+ }
+
+#ifndef NDEBUG
+ memset((void*)OldBuckets, 0x5a, sizeof(BucketT)*OldNumBuckets);
+#endif
+ if (!IsPrecompiled) {
+ // Free the old table.
+ operator delete(OldBuckets);
+ } else {
+ IsPrecompiled = false;
+ }
+
+ NumEntries = 0;
+ }
+
+public:
+ /// Return the approximate size (in bytes) of the actual map.
+ /// This is just the raw memory used by MvmDenseMap.
+ /// If entries are pointers to objects, the size of the referenced objects
+ /// are not included.
+ size_t getMemorySize() const {
+ return NumBuckets * sizeof(BucketT);
+ }
+};
+
+template<typename KeyT, typename ValueT,
+ typename KeyInfoT, bool IsConst>
+class MvmDenseMapIterator {
+ typedef MvmPair<KeyT, ValueT> Bucket;
+ typedef MvmDenseMapIterator<KeyT, ValueT, KeyInfoT, true> ConstIterator;
+ friend class MvmDenseMapIterator<KeyT, ValueT, KeyInfoT, true>;
+public:
+ typedef ptrdiff_t difference_type;
+ typedef typename llvm::conditional<IsConst, const Bucket, Bucket>::type value_type;
+ typedef value_type *pointer;
+ typedef value_type &reference;
+ typedef std::forward_iterator_tag iterator_category;
+private:
+ pointer Ptr, End;
+public:
+ MvmDenseMapIterator() : Ptr(0), End(0) {}
+
+ MvmDenseMapIterator(pointer Pos, pointer E) : Ptr(Pos), End(E) {
+ AdvancePastEmptyBuckets();
+ }
+
+ // If IsConst is true this is a converting constructor from iterator to
+ // const_iterator and the default copy constructor is used.
+ // Otherwise this is a copy constructor for iterator.
+ MvmDenseMapIterator(const MvmDenseMapIterator<KeyT, ValueT,
+ KeyInfoT, false>& I)
+ : Ptr(I.Ptr), End(I.End) {}
+
+ reference operator*() const {
+ return *Ptr;
+ }
+ pointer operator->() const {
+ return Ptr;
+ }
+
+ bool operator==(const ConstIterator &RHS) const {
+ return Ptr == RHS.operator->();
+ }
+ bool operator!=(const ConstIterator &RHS) const {
+ return Ptr != RHS.operator->();
+ }
+
+ inline MvmDenseMapIterator& operator++() { // Preincrement
+ ++Ptr;
+ AdvancePastEmptyBuckets();
+ return *this;
+ }
+ MvmDenseMapIterator operator++(int) { // Postincrement
+ MvmDenseMapIterator tmp = *this; ++*this; return tmp;
+ }
+
+private:
+ void AdvancePastEmptyBuckets() {
+ const KeyT Empty = KeyInfoT::getEmptyKey();
+ const KeyT Tombstone = KeyInfoT::getTombstoneKey();
+
+ while (Ptr != End &&
+ (KeyInfoT::isEqual(Ptr->first, Empty) ||
+ KeyInfoT::isEqual(Ptr->first, Tombstone)))
+ ++Ptr;
+ }
+};
+
+} // end namespace j3
+
+#endif
Modified: vmkit/trunk/include/mvm/UTF8.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/include/mvm/UTF8.h?rev=136594&r1=136593&r2=136594&view=diff
==============================================================================
--- vmkit/trunk/include/mvm/UTF8.h (original)
+++ vmkit/trunk/include/mvm/UTF8.h Sun Jul 31 11:56:00 2011
@@ -3,6 +3,7 @@
#include <map>
#include "mvm/Allocator.h"
+#include "mvm/MvmDenseMap.h"
namespace mvm {
@@ -20,15 +21,14 @@
}
public:
- /// size - The (constant) size of the array.
+ /// size - The (constant) size of the UTF8.
ssize_t size;
- /// elements - Elements of this array. The size here is different than the
- /// actual size of the Java array. This is to facilitate Java array accesses
- /// in JnJVM code. The size should be set to zero, but this is invalid C99.
+ /// elements - Elements of this UTF8.
+ /// The size should be set to zero, but this is invalid C99.
uint16 elements[1];
- /// extract - Similar, but creates it in the map.
+ /// extract - Extracts an UTF8 from the current UTF8
const UTF8* extract(UTF8Map* map, uint32 start, uint32 len) const;
/// equals - Are the two UTF8s equal?
@@ -65,6 +65,47 @@
}
};
+extern "C" const UTF8 TombstoneKey;
+extern "C" const UTF8 EmptyKey;
+
+// Provide MvmDenseMapInfo for UTF8.
+template<>
+struct MvmDenseMapInfo<const UTF8*> {
+ static inline const UTF8* getEmptyKey() {
+ return &EmptyKey;
+ }
+ static inline const UTF8* getTombstoneKey() {
+ return &TombstoneKey;
+ }
+ static unsigned getHashValue(const UTF8* PtrVal) {
+ return PtrVal->hash();
+ }
+ static bool isEqual(const UTF8* LHS, const UTF8* RHS) { return LHS->equals(RHS); }
+};
+
+
+struct UTF8MapKey {
+ uint32_t hash;
+ const UTF8* data;
+ UTF8MapKey(uint32_t h, const UTF8* d) : hash(h), data(d) {}
+};
+
+// Provide MvmDenseMapInfo for UTF8MapKey.
+template<>
+struct MvmDenseMapInfo<UTF8MapKey> {
+ static inline const UTF8MapKey getEmptyKey() {
+ static UTF8MapKey EmptyKey(0, NULL);
+ return EmptyKey;
+ }
+ static inline const UTF8MapKey getTombstoneKey() {
+ static UTF8MapKey TombstoneKey(-1, NULL);
+ return TombstoneKey;
+ }
+ static unsigned getHashValue(const UTF8MapKey& key) {
+ return key.data->hash();
+ }
+ static bool isEqual(const UTF8MapKey& LHS, const UTF8MapKey& RHS) { return LHS.data->equals(RHS.data); }
+};
class UTF8Map : public mvm::PermanentObject {
private:
Modified: vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp?rev=136594&r1=136593&r2=136594&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp (original)
+++ vmkit/trunk/lib/J3/Compiler/JavaAOTCompiler.cpp Sun Jul 31 11:56:00 2011
@@ -1099,7 +1099,7 @@
return ConstantStruct::get(STy, ClassElts);
}
-Constant* JavaAOTCompiler::CreateConstantFromClassMap(const J3DenseMap<const UTF8*, CommonClass*>& map) {
+Constant* JavaAOTCompiler::CreateConstantFromClassMap(const mvm::MvmDenseMap<const UTF8*, CommonClass*>& map) {
StructType* STy =
dyn_cast<StructType>(JavaIntrinsics.J3DenseMapType->getContainedType(0));
Module& Mod = *getLLVMModule();
@@ -1113,15 +1113,15 @@
ArrayType* ATy = ArrayType::get(JavaIntrinsics.ptrType, map.NumBuckets * 2);
for (uint32 i = 0; i < map.NumBuckets; ++i) {
- J3Pair<const UTF8*, CommonClass*> pair = map.Buckets[i];
- if (pair.first == &TombstoneKey) {
+ mvm::MvmPair<const UTF8*, CommonClass*> pair = map.Buckets[i];
+ if (pair.first == &mvm::TombstoneKey) {
static GlobalVariable* gv =
new GlobalVariable(Mod, JavaIntrinsics.UTF8Type->getContainedType(0),
false, GlobalValue::ExternalLinkage, NULL,
"TombstoneKey");
TempElts.push_back(ConstantExpr::getCast(Instruction::BitCast, gv, JavaIntrinsics.ptrType));
TempElts.push_back(Constant::getNullValue(JavaIntrinsics.ptrType));
- } else if (pair.first == &EmptyKey) {
+ } else if (pair.first == &mvm::EmptyKey) {
static GlobalVariable* gv =
new GlobalVariable(Mod, JavaIntrinsics.UTF8Type->getContainedType(0),
false, GlobalValue::ExternalLinkage, NULL,
Modified: vmkit/trunk/lib/J3/VMCore/LockedMap.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/LockedMap.cpp?rev=136594&r1=136593&r2=136594&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/LockedMap.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/LockedMap.cpp Sun Jul 31 11:56:00 2011
@@ -15,9 +15,6 @@
namespace j3 {
-extern "C" const UTF8 TombstoneKey(0);
-extern "C" const UTF8 EmptyKey(0);
-
bool ltarray16::operator()(const ArrayUInt16* s1, const ArrayUInt16* s2) const {
llvm_gcroot(s1, 0);
llvm_gcroot(s2, 0);
Modified: vmkit/trunk/lib/J3/VMCore/LockedMap.h
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/LockedMap.h?rev=136594&r1=136593&r2=136594&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/LockedMap.h (original)
+++ vmkit/trunk/lib/J3/VMCore/LockedMap.h Sun Jul 31 11:56:00 2011
@@ -16,7 +16,6 @@
#ifndef JNJVM_LOCKED_MAP_H
#define JNJVM_LOCKED_MAP_H
-#include "j3/J3DenseMap.h"
#include <map>
@@ -25,30 +24,12 @@
#include "types.h"
#include "mvm/Allocator.h"
+#include "mvm/MvmDenseMap.h"
#include "mvm/Threads/Locks.h"
#include "UTF8.h"
-extern "C" const j3::UTF8 TombstoneKey;
-extern "C" const j3::UTF8 EmptyKey;
-
namespace j3 {
-// Provide J3DenseMapInfo for UTF8.
-template<>
-struct J3DenseMapInfo<const j3::UTF8*> {
- static inline const j3::UTF8* getEmptyKey() {
- return &EmptyKey;
- }
- static inline const j3::UTF8* getTombstoneKey() {
- return &TombstoneKey;
- }
- static unsigned getHashValue(const j3::UTF8* PtrVal) {
- return PtrVal->hash();
- }
- static bool isEqual(const j3::UTF8* LHS, const j3::UTF8* RHS) { return LHS->equals(RHS); }
-};
-
-
class ArrayUInt16;
class JavaString;
class JnjvmClassLoader;
@@ -130,25 +111,25 @@
class ClassMap : public mvm::PermanentObject {
public:
ClassMap() {}
- ClassMap(J3DenseMap<const UTF8*, UserCommonClass*>* precompiled) : map(*precompiled) {}
+ ClassMap(mvm::MvmDenseMap<const mvm::UTF8*, UserCommonClass*>* precompiled) : map(*precompiled) {}
mvm::LockRecursive lock;
- J3DenseMap<const UTF8*, UserCommonClass*> map;
- typedef J3DenseMap<const UTF8*, UserCommonClass*>::iterator iterator;
+ mvm::MvmDenseMap<const mvm::UTF8*, UserCommonClass*> map;
+ typedef mvm::MvmDenseMap<const mvm::UTF8*, UserCommonClass*>::iterator iterator;
};
class TypeMap : public mvm::PermanentObject {
public:
mvm::LockNormal lock;
- J3DenseMap<const UTF8*, Typedef*> map;
- typedef J3DenseMap<const UTF8*, Typedef*>::iterator iterator;
+ mvm::MvmDenseMap<const mvm::UTF8*, Typedef*> map;
+ typedef mvm::MvmDenseMap<const mvm::UTF8*, Typedef*>::iterator iterator;
};
class SignMap : public mvm::PermanentObject {
public:
mvm::LockNormal lock;
- J3DenseMap<const UTF8*, Signdef*> map;
- typedef J3DenseMap<const UTF8*, Signdef*>::iterator iterator;
+ mvm::MvmDenseMap<const mvm::UTF8*, Signdef*> map;
+ typedef mvm::MvmDenseMap<const mvm::UTF8*, Signdef*>::iterator iterator;
};
} // end namespace j3
Modified: vmkit/trunk/lib/J3/VMCore/Precompiled.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/J3/VMCore/Precompiled.cpp?rev=136594&r1=136593&r2=136594&view=diff
==============================================================================
--- vmkit/trunk/lib/J3/VMCore/Precompiled.cpp (original)
+++ vmkit/trunk/lib/J3/VMCore/Precompiled.cpp Sun Jul 31 11:56:00 2011
@@ -352,8 +352,8 @@
upcalls->OfLong->classLoader = loader;
upcalls->OfDouble->classLoader = loader;
- J3DenseMap<const UTF8*, CommonClass*>* precompiledClassMap =
- reinterpret_cast<J3DenseMap<const UTF8*, CommonClass*>*>(dlsym(nativeHandle, "ClassMap"));
+ mvm::MvmDenseMap<const UTF8*, CommonClass*>* precompiledClassMap =
+ reinterpret_cast<mvm::MvmDenseMap<const UTF8*, CommonClass*>*>(dlsym(nativeHandle, "ClassMap"));
loader->classes = new (loader->allocator, "ClassMap") ClassMap(precompiledClassMap);
for (ClassMap::iterator i = loader->getClasses()->map.begin(),
e = loader->getClasses()->map.end(); i != e; i++) {
Modified: vmkit/trunk/lib/Mvm/Runtime/UTF8.cpp
URL: http://llvm.org/viewvc/llvm-project/vmkit/trunk/lib/Mvm/Runtime/UTF8.cpp?rev=136594&r1=136593&r2=136594&view=diff
==============================================================================
--- vmkit/trunk/lib/Mvm/Runtime/UTF8.cpp (original)
+++ vmkit/trunk/lib/Mvm/Runtime/UTF8.cpp Sun Jul 31 11:56:00 2011
@@ -11,7 +11,11 @@
#include "mvm/UTF8.h"
#include "mvm/PrintBuffer.h"
-using namespace mvm;
+namespace mvm {
+
+extern "C" const UTF8 TombstoneKey(0);
+extern "C" const UTF8 EmptyKey(0);
+
void UTF8::print(PrintBuffer *pb) const {
pb->writeUTF8(this);
@@ -162,3 +166,5 @@
void UTF8Map::insert(const UTF8* val) {
map.insert(std::make_pair(val->hash(), val));
}
+
+}
More information about the vmkit-commits
mailing list