js/src/vm/Caches-inl.h
author Jon Coppeard <jcoppeard@mozilla.com>
Mon, 11 Mar 2019 07:02:39 +0000
changeset 521333 d45e5b4b57b98f6bf0fa85e951087a7359d5b1d7
parent 521296 1072bbe0b8c4623557a5baf44e5b01e12c624054
child 521903 d55401632cea92b6b2775ba278274b5490275876
permissions -rw-r--r--
Bug 1532946 - Tidy allocation functions by renaming overloads for object and string allocation r=sfink This patch attempts to make things clearer by renaming the functions used for allocating objects and strings to AllocateObject and AllocateString, rather than having everything be called Allocate. Allocate is still used for atoms though which is a little strange but was hard to change. Differential Revision: https://phabricator.services.mozilla.com/D22275

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 * vim: set ts=8 sts=2 et sw=2 tw=80:
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef vm_Caches_inl_h
#define vm_Caches_inl_h

#include "vm/Caches.h"

#include "gc/Allocator.h"
#include "gc/GCTrace.h"
#include "vm/Probes.h"
#include "vm/Realm.h"

#include "vm/JSObject-inl.h"

namespace js {

inline bool NewObjectCache::lookupProto(const Class* clasp, JSObject* proto,
                                        gc::AllocKind kind,
                                        EntryIndex* pentry) {
  MOZ_ASSERT(!proto->is<GlobalObject>());
  return lookup(clasp, proto, kind, pentry);
}

inline bool NewObjectCache::lookupGlobal(const Class* clasp,
                                         GlobalObject* global,
                                         gc::AllocKind kind,
                                         EntryIndex* pentry) {
  return lookup(clasp, global, kind, pentry);
}

inline void NewObjectCache::fillGlobal(EntryIndex entry, const Class* clasp,
                                       GlobalObject* global, gc::AllocKind kind,
                                       NativeObject* obj) {
  // MOZ_ASSERT(global == obj->getGlobal());
  return fill(entry, clasp, global, kind, obj);
}

inline NativeObject* NewObjectCache::newObjectFromHit(JSContext* cx,
                                                      EntryIndex entryIndex,
                                                      gc::InitialHeap heap) {
  MOZ_ASSERT(unsigned(entryIndex) < mozilla::ArrayLength(entries));
  Entry* entry = &entries[entryIndex];

  NativeObject* templateObj =
      reinterpret_cast<NativeObject*>(&entry->templateObject);

  // Do an end run around JSObject::group() to avoid doing AutoUnprotectCell
  // on the templateObj, which is not a GC thing and can't use
  // runtimeFromAnyThread.
  ObjectGroup* group = templateObj->group_;

  // If we did the lookup based on the proto we might have a group/object from a
  // different (same-compartment) realm, so we have to do a realm check.
  if (group->realm() != cx->realm()) {
    return nullptr;
  }

  MOZ_ASSERT(!group->hasUnanalyzedPreliminaryObjects());

  {
    AutoSweepObjectGroup sweepGroup(group);
    if (group->shouldPreTenure(sweepGroup)) {
      heap = gc::TenuredHeap;
    }
  }

  if (cx->runtime()->gc.upcomingZealousGC()) {
    return nullptr;
  }

  NativeObject* obj = static_cast<NativeObject*>(
      AllocateObject<NoGC>(cx, entry->kind, /* nDynamicSlots = */ 0,
                           heap, group->clasp()));
  if (!obj) {
    return nullptr;
  }

  copyCachedToObject(obj, templateObj, entry->kind);

  if (group->clasp()->shouldDelayMetadataBuilder()) {
    cx->realm()->setObjectPendingMetadata(cx, obj);
  } else {
    obj = static_cast<NativeObject*>(SetNewObjectMetadata(cx, obj));
  }

  probes::CreateObject(cx, obj);
  gc::gcTracer.traceCreateObject(obj);
  return obj;
}

} /* namespace js */

#endif /* vm_Caches_inl_h */