js/src/wasm/WasmRealm.cpp

   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  *
   4  * Copyright 2016 Mozilla Foundation
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18
  19 #include "wasm/WasmRealm.h"
  20
  21 #include "vm/GlobalObject.h"
  22 #include "vm/Realm.h"
  23 #include "wasm/WasmDebug.h"
  24 #include "wasm/WasmInstance.h"
  25 #include "wasm/WasmProcess.h"
  26
  27 #include "debugger/DebugAPI-inl.h"
  28 #include "wasm/WasmInstance-inl.h"
  29
  30 using namespace js;
  31 using namespace wasm;
  32
  33 wasm::Realm::Realm(JSRuntime* rt) : runtime_(rt) {}
  34
  35 wasm::Realm::~Realm() { MOZ_ASSERT(instances_.empty()); }
  36
  37 struct InstanceComparator {
  38   const Instance& target;
  39   explicit InstanceComparator(const Instance& target) : target(target) {}
  40
  41   int operator()(const Instance* instance) const {
  42     if (instance == &target) {
  43       return 0;
  44     }
  45
  46     // Instances can share code, so the segments can be equal (though they
  47     // can't partially overlap).  If the codeBases are equal, we sort by
  48     // Instance address.  Thus a Code may map to many instances.
  49
  50     // Compare by the first tier, always.
  51
  52     Tier instanceTier = instance->code().stableTier();
  53     Tier targetTier = target.code().stableTier();
  54
  55     if (instance->codeBase(instanceTier) == target.codeBase(targetTier)) {
  56       return instance < &target ? -1 : 1;
  57     }
  58
  59     return target.codeBase(targetTier) < instance->codeBase(instanceTier) ? -1
  60                                                                           : 1;
  61   }
  62 };
  63
  64 bool wasm::Realm::registerInstance(JSContext* cx,
  65                                    Handle<WasmInstanceObject*> instanceObj) {
  66   MOZ_ASSERT(runtime_ == cx->runtime());
  67
  68   Instance& instance = instanceObj->instance();
  69   MOZ_ASSERT(this == &instance.realm()->wasm);
  70
  71   instance.ensureProfilingLabels(cx->runtime()->geckoProfiler().enabled());
  72
  73   if (instance.debugEnabled() &&
  74       instance.realm()->debuggerObservesAllExecution()) {
  75     instance.debug().ensureEnterFrameTrapsState(cx, &instance, true);
  76   }
  77
  78   {
  79     if (!instances_.reserve(instances_.length() + 1)) {
  80       return false;
  81     }
  82
  83     auto runtimeInstances = cx->runtime()->wasmInstances.lock();
  84     if (!runtimeInstances->reserve(runtimeInstances->length() + 1)) {
  85       return false;
  86     }
  87
  88     // To avoid implementing rollback, do not fail after mutations start.
  89
  90     InstanceComparator cmp(instance);
  91     size_t index;
  92
  93     // The following section is not unsafe, but simulated OOM do not consider
  94     // the fact that these insert calls are guarded by the previous reserve
  95     // calls.
  96     AutoEnterOOMUnsafeRegion oomUnsafe;
  97     (void)oomUnsafe;
  98
  99     MOZ_ALWAYS_FALSE(
 100         BinarySearchIf(instances_, 0, instances_.length(), cmp, &index));
 101     MOZ_ALWAYS_TRUE(instances_.insert(instances_.begin() + index, &instance));
 102
 103     MOZ_ALWAYS_FALSE(BinarySearchIf(runtimeInstances.get(), 0,
 104                                     runtimeInstances->length(), cmp, &index));
 105     MOZ_ALWAYS_TRUE(
 106         runtimeInstances->insert(runtimeInstances->begin() + index, &instance));
 107   }
 108
 109   // Notify the debugger after wasmInstances is unlocked.
 110   DebugAPI::onNewWasmInstance(cx, instanceObj);
 111   return true;
 112 }
 113
 114 void wasm::Realm::unregisterInstance(Instance& instance) {
 115   InstanceComparator cmp(instance);
 116   size_t index;
 117
 118   if (BinarySearchIf(instances_, 0, instances_.length(), cmp, &index)) {
 119     instances_.erase(instances_.begin() + index);
 120   }
 121
 122   auto runtimeInstances = runtime_->wasmInstances.lock();
 123   if (BinarySearchIf(runtimeInstances.get(), 0, runtimeInstances->length(), cmp,
 124                      &index)) {
 125     runtimeInstances->erase(runtimeInstances->begin() + index);
 126   }
 127 }
 128
 129 void wasm::Realm::ensureProfilingLabels(bool profilingEnabled) {
 130   for (Instance* instance : instances_) {
 131     instance->ensureProfilingLabels(profilingEnabled);
 132   }
 133 }
 134
 135 void wasm::Realm::addSizeOfExcludingThis(MallocSizeOf mallocSizeOf,
 136                                          size_t* realmTables) {
 137   *realmTables += instances_.sizeOfExcludingThis(mallocSizeOf);
 138 }
 139
 140 void wasm::InterruptRunningCode(JSContext* cx) {
 141   auto runtimeInstances = cx->runtime()->wasmInstances.lock();
 142   for (Instance* instance : runtimeInstances.get()) {
 143     instance->setInterrupt();
 144   }
 145 }
 146
 147 void wasm::ResetInterruptState(JSContext* cx) {
 148   auto runtimeInstances = cx->runtime()->wasmInstances.lock();
 149   for (Instance* instance : runtimeInstances.get()) {
 150     instance->resetInterrupt(cx);
 151   }
 152 }