js/src/gc/StableCellHasher-inl.h

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
   2  * vim: set ts=8 sts=2 et sw=2 tw=80:
   3  * This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #ifndef gc_StableCellHasher_inl_h
   8 #define gc_StableCellHasher_inl_h
   9
  10 #include "gc/StableCellHasher.h"
  11
  12 #include "mozilla/HashFunctions.h"
  13
  14 #include "gc/Cell.h"
  15 #include "gc/Marking.h"
  16 #include "gc/Zone.h"
  17 #include "vm/JSObject.h"
  18 #include "vm/NativeObject.h"
  19 #include "vm/Runtime.h"
  20
  21 namespace js {
  22 namespace gc {
  23
  24 extern uint64_t NextCellUniqueId(JSRuntime* rt);
  25
  26 inline bool MaybeGetUniqueId(Cell* cell, uint64_t* uidp) {
  27   MOZ_ASSERT(uidp);
  28   MOZ_ASSERT(CurrentThreadCanAccessRuntime(cell->runtimeFromAnyThread()) ||
  29              CurrentThreadIsPerformingGC());
  30
  31   if (cell->is<JSObject>()) {
  32     JSObject* obj = cell->as<JSObject>();
  33     if (obj->is<NativeObject>()) {
  34       auto* nobj = &obj->as<NativeObject>();
  35       if (!nobj->hasUniqueId()) {
  36         return false;
  37       }
  38
  39       *uidp = nobj->uniqueId();
  40       return true;
  41     }
  42   }
  43
  44   // Get an existing uid, if one has been set.
  45   auto p = cell->zone()->uniqueIds().readonlyThreadsafeLookup(cell);
  46   if (!p) {
  47     return false;
  48   }
  49
  50   *uidp = p->value();
  51
  52   return true;
  53 }
  54
  55 extern bool CreateUniqueIdForNativeObject(NativeObject* obj, uint64_t* uidp);
  56 extern bool CreateUniqueIdForNonNativeObject(Cell* cell, UniqueIdMap::AddPtr,
  57                                              uint64_t* uidp);
  58
  59 inline bool GetOrCreateUniqueId(Cell* cell, uint64_t* uidp) {
  60   MOZ_ASSERT(uidp);
  61   MOZ_ASSERT(CurrentThreadCanAccessRuntime(cell->runtimeFromAnyThread()) ||
  62              CurrentThreadIsPerformingGC());
  63
  64   if (cell->is<JSObject>()) {
  65     JSObject* obj = cell->as<JSObject>();
  66     if (obj->is<NativeObject>()) {
  67       auto* nobj = &obj->as<NativeObject>();
  68       if (nobj->hasUniqueId()) {
  69         *uidp = nobj->uniqueId();
  70         return true;
  71       }
  72
  73       return CreateUniqueIdForNativeObject(nobj, uidp);
  74     }
  75   }
  76
  77   // Get an existing uid, if one has been set.
  78   auto p = cell->zone()->uniqueIds().lookupForAdd(cell);
  79   if (p) {
  80     *uidp = p->value();
  81     return true;
  82   }
  83
  84   return CreateUniqueIdForNonNativeObject(cell, p, uidp);
  85 }
  86
  87 inline bool SetOrUpdateUniqueId(JSContext* cx, Cell* cell, uint64_t uid) {
  88   MOZ_ASSERT(CurrentThreadCanAccessRuntime(cell->runtimeFromAnyThread()));
  89
  90   if (cell->is<JSObject>()) {
  91     JSObject* obj = cell->as<JSObject>();
  92     if (obj->is<NativeObject>()) {
  93       auto* nobj = &obj->as<NativeObject>();
  94       return nobj->setOrUpdateUniqueId(cx, uid);
  95     }
  96   }
  97
  98   // If the cell was in the nursery, hopefully unlikely, then we need to
  99   // tell the nursery about it so that it can sweep the uid if the thing
 100   // does not get tenured.
 101   JSRuntime* runtime = cell->runtimeFromMainThread();
 102   if (IsInsideNursery(cell) &&
 103       !runtime->gc.nursery().addedUniqueIdToCell(cell)) {
 104     return false;
 105   }
 106
 107   return cell->zone()->uniqueIds().put(cell, uid);
 108 }
 109
 110 inline uint64_t GetUniqueIdInfallible(Cell* cell) {
 111   uint64_t uid;
 112   AutoEnterOOMUnsafeRegion oomUnsafe;
 113   if (!GetOrCreateUniqueId(cell, &uid)) {
 114     oomUnsafe.crash("failed to allocate uid");
 115   }
 116   return uid;
 117 }
 118
 119 inline bool HasUniqueId(Cell* cell) {
 120   MOZ_ASSERT(CurrentThreadCanAccessRuntime(cell->runtimeFromAnyThread()) ||
 121              CurrentThreadIsPerformingGC());
 122
 123   if (cell->is<JSObject>()) {
 124     JSObject* obj = cell->as<JSObject>();
 125     if (obj->is<NativeObject>()) {
 126       return obj->as<NativeObject>().hasUniqueId();
 127     }
 128   }
 129
 130   return cell->zone()->uniqueIds().has(cell);
 131 }
 132
 133 inline void TransferUniqueId(Cell* tgt, Cell* src) {
 134   MOZ_ASSERT(src != tgt);
 135   MOZ_ASSERT(!IsInsideNursery(tgt));
 136   MOZ_ASSERT(CurrentThreadCanAccessRuntime(tgt->runtimeFromAnyThread()));
 137   MOZ_ASSERT(src->zone() == tgt->zone());
 138
 139   Zone* zone = tgt->zone();
 140   MOZ_ASSERT(!zone->uniqueIds().has(tgt));
 141   zone->uniqueIds().rekeyIfMoved(src, tgt);
 142 }
 143
 144 inline void RemoveUniqueId(Cell* cell) {
 145   MOZ_ASSERT(CurrentThreadCanAccessRuntime(cell->runtimeFromAnyThread()));
 146   // The cell may no longer be in the hash table if it was swapped with a
 147   // NativeObject.
 148   cell->zone()->uniqueIds().remove(cell);
 149 }
 150
 151 }  // namespace gc
 152
 153 static inline js::HashNumber UniqueIdToHash(uint64_t uid) {
 154   // This uses the default hasher which returns the lower 32 bits of 64 bit
 155   // integers as the hash code. This is OK because he result will be scrambled
 156   // later by ScrambleHashCode().
 157   return DefaultHasher<uint64_t>::hash(uid);
 158 }
 159
 160 template <typename T>
 161 /* static */ bool StableCellHasher<T>::maybeGetHash(const Lookup& l,
 162                                                     HashNumber* hashOut) {
 163   if (!l) {
 164     *hashOut = 0;
 165     return true;
 166   }
 167
 168   uint64_t uid;
 169   if (!gc::MaybeGetUniqueId(l, &uid)) {
 170     return false;
 171   }
 172
 173   *hashOut = UniqueIdToHash(uid);
 174   return true;
 175 }
 176
 177 template <typename T>
 178 /* static */ bool StableCellHasher<T>::ensureHash(const Lookup& l,
 179                                                   HashNumber* hashOut) {
 180   if (!l) {
 181     *hashOut = 0;
 182     return true;
 183   }
 184
 185   uint64_t uid;
 186   if (!gc::GetOrCreateUniqueId(l, &uid)) {
 187     return false;
 188   }
 189
 190   *hashOut = UniqueIdToHash(uid);
 191   return true;
 192 }
 193
 194 template <typename T>
 195 /* static */ HashNumber StableCellHasher<T>::hash(const Lookup& l) {
 196   if (!l) {
 197     return 0;
 198   }
 199
 200   // We have to access the zone from-any-thread here: a worker thread may be
 201   // cloning a self-hosted object from the main runtime's self- hosting zone
 202   // into another runtime. The zone's uid lock will protect against multiple
 203   // workers doing this simultaneously.
 204   MOZ_ASSERT(CurrentThreadCanAccessZone(l->zoneFromAnyThread()) ||
 205              CurrentThreadIsPerformingGC());
 206
 207   return UniqueIdToHash(gc::GetUniqueIdInfallible(l));
 208 }
 209
 210 template <typename T>
 211 /* static */ bool StableCellHasher<T>::match(const Key& k, const Lookup& l) {
 212   if (k == l) {
 213     return true;
 214   }
 215
 216   if (!k || !l) {
 217     return false;
 218   }
 219
 220   MOZ_ASSERT(CurrentThreadCanAccessZone(l->zoneFromAnyThread()) ||
 221              CurrentThreadIsPerformingGC());
 222
 223 #ifdef DEBUG
 224   // Incremental table sweeping means that existing table entries may no
 225   // longer have unique IDs. We fail the match in that case and the entry is
 226   // removed from the table later on.
 227   if (!gc::HasUniqueId(k)) {
 228     Key key = k;
 229     MOZ_ASSERT(IsAboutToBeFinalizedUnbarriered(key));
 230   }
 231   MOZ_ASSERT(gc::HasUniqueId(l));
 232 #endif
 233
 234   uint64_t keyId;
 235   if (!gc::MaybeGetUniqueId(k, &keyId)) {
 236     // Key is dead and cannot match lookup which must be live.
 237     return false;
 238   }
 239
 240   return keyId == gc::GetUniqueIdInfallible(l);
 241 }
 242
 243 }  // namespace js
 244
 245 #endif  // gc_StableCellHasher_inl_h