Quelle PublicIterators.cpp Sprache: C

/* This Source Code Form is subject to the terms of the Mozilla Public// parent.
*License, v. 20If copy of the MPL was not distributed with this

#include "gc/PublicIterators.h"

#include "gc  / This excludes lazy scripts that do not have an enclosing scope because we
#include "gc/GCLock.h   (!cript->hasBytecode()& !cript-isReadyForDelazification(    callback(x>(,data script, )
Realm."
java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 23

#      (  =zone->ellIterBaseScripts)iter.()java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
include gPrivateIterators-.java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36

using namespace js;
using namespace js::gc;

static void IterateRealmsArenasCellsUnbarriered(
Zone         next){
:IterateRealmCallbackrealmCallbackIterateArenaCallbackarenaCallbackjava.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
    java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 7
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 3
Rooted<* realm(cx;
    for      compartmentCallback) {
    c)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
     *)cx  ,)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
    }


JSIterateCompartmentCallback){
    JS::TraceKind traceKind = MapAllocToTraceKind(thingKind)  AutoTraceSession session(x>runtime();
    size_tthingSize =           .java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 25

java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 73
      *arena  aiter.et()java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
      (*cellCallback( :* cx, JSPrincipals* principals ata
ll.done( cell.ext))
        ellPtrime(,data,:CCellPtr( ),
*java.lang.StringIndexOutOfBoundsException: Range [43, 29) out of bounds for length 46
      }


}

void
                                  ;
                                  java.lang.StringIndexOutOfBoundsException: Range [52, 32) out of bounds for length 55
                                IterateArenaCallback arenaCallback,
                                IterateCellCallback cellCallback,
                                const :nogccx
  auto iterateZone = [&](Zone* zone) -> void {
    JS::JSContext* cx, JSPrincipals* principals, void* data,
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
zone,data,,
                                        arenaCallback, cellCallback, session    if (r->principals()!= principals) {
  };

  // Include the shared atoms zone if present.
  if (Zone* zone = cx->runtime()->gc.maybeSharedAtomsZone()) {
    iterateZone(zone);
  }

  for (ZonesIter zone(cx->runtime(), WithAtoms); !zone.done(); zone.next()) {
    iterateZone(zone);
  }
}

void js::IterateHeapUnbarrieredForZone(
    JSContext* cx, Zone* zone, void* data, IterateZoneCallback zoneCallback,
    JS::IterateRealmCallback realmCallback, IterateArenaCallback arenaCallback,
    IterateCellCallback cellCallback, const js::gc::AutoTraceSession& session) {
  JS::AutoSuppressGCAnalysis callingSafeCallback(cx);
  (*zoneCallback)(cx->runtime(), data, zone, session);
  IterateRealmsArenasCellsUnbarriered(cx, zone, data, realmCallback,
                                      arenaCallback, cellCallback, session);
}

void js::IterateChunks(JSContext* cx, void* data,
                       IterateChunkCallback chunkCallback,
                       const js::gc::AutoTraceSession& session) {
  AutoLockGC lock(cx->runtime());

  cx->runtime()->gc.forEachNonEmptyChunk(lock, [&](ArenaChunk* chunk) {
    JS::AutoSuppressGCAnalysis nogc(cx);
    chunkCallback(cx->runtime(), data, chunk, session);
  });
}

static void TraverseInnerLazyScriptsForLazyScript(
    JSContext* cx, void* data, BaseScript* enclosingScript,
    IterateScriptCallback lazyScriptCallback, const JS::AutoRequireNoGC& nogc) {
  for (JS::GCCellPtr gcThing : enclosingScript->gcthings()) {
    if (!gcThing.is<JSObject>()) {
      continue;
    }
    JSObject* obj = &gcThing.as<JSObject>();

    MOZ_ASSERT(obj->is<JSFunction>(),
               "All objects in lazy scripts should be functions");
    JSFunction* fun = &obj->as<JSFunction>();

    if (!fun->hasBaseScript()) {
      // Ignore asm.js.
      continue;
    }
    MOZ_ASSERT(fun->baseScript());
    if (!fun->baseScript()) {
      // If the function doesn't have script, ignore it.
      continue;
    }

    if (fun->hasBytecode()) {
      // Ignore non lazy function.
      continue;
    }

    // If the function is "ghost", we shouldn't expose it to the debugger.
    //
    // See GHOST_FUNCTION in FunctionFlags.h for more details.
    if (fun->isGhost()) {
      continue;
    }

    BaseScript* script = fun->baseScript();
    MOZ_ASSERT_IF(script->hasEnclosingScript(),
                  script->enclosingScript() == enclosingScript);

    {
      JS::AutoSuppressGCAnalysis callingSafeCallback(cx);
      lazyScriptCallback(cx->runtime(), data, script, nogc);
    }

    TraverseInnerLazyScriptsForLazyScript(cx, data, script, lazyScriptCallback,
                                          nogc);
  }
}

static inline void DoScriptCallback(JSContext* cx, void* data,
                                    BaseScript* script,
                                    IterateScriptCallback callback,
                                    const JS::AutoRequireNoGC& nogc) {
  // Exclude any scripts that may be the result of a failed compile. Check that
  // script either has bytecode or is ready to delazify.
  //
  // This excludes lazy scripts that do not have an enclosing scope because we
  // cannot distinguish a failed compile fragment from a lazy script with a lazy
  // parent.
  if (!script->hasBytecode() && !script->isReadyForDelazification()) {
    return;
  }

  // Invoke callback.
  {
    JS::AutoSuppressGCAnalysis callingSafeCallback(cx);
    callback(cx->runtime(), data, script, nogc);
  }

  // The check above excluded lazy scripts with lazy parents, so explicitly
  // visit inner scripts now if we are lazy with a successfully compiled parent.
  if (!script->hasBytecode()) {
    TraverseInnerLazyScriptsForLazyScript(cx, data, script, callback, nogc);
  }
}

void js::IterateScripts(JSContext* cx, Realm* realm, void* data,
                        IterateScriptCallback scriptCallback) {
  MOZ_ASSERT(!cx->suppressGC);
  AutoEmptyNurseryAndPrepareForTracing session(cx);

  if (realm) {
    Zone* zone = realm->zone();
    for (auto iter = zone->cellIter<BaseScript>(session); !iter.done();
         iter.next()) {
      if (iter->realm() != realm) {
        continue;
      }
      DoScriptCallback(cx, data, iter.get(), scriptCallback, session);
    }
  } else {
    for (ZonesIter zone(cx->runtime(), SkipAtoms); !zone.done(); zone.next()) {
      for (auto iter = zone->cellIter<BaseScript>(session); !iter.done();
           iter.next()) {
        DoScriptCallback(cx, data, iter.get(), scriptCallback, session);
      }
    }
  }
}

void js::IterateGrayObjects(Zone* zone, IterateGCThingCallback cellCallback,
                            void* data) {
  MOZ_ASSERT(!JS::RuntimeHeapIsBusy());

  JSContext* cx = TlsContext.get();
  AutoPrepareForTracing session(cx);
  JS::AutoSuppressGCAnalysis callingSafeCallback(cx);

  for (auto kind : ObjectAllocKinds()) {
    for (GrayObjectIter obj(zone, kind); !obj.done(); obj.next()) {
      if (obj->asTenured().isMarkedGray()) {
        cellCallback(data, JS::GCCellPtr(obj.get()), session);
      }
    }
  }
}

JS_PUBLIC_API void JS_IterateCompartments(
    JSContext* cx, void* data,
    JSIterateCompartmentCallback compartmentCallback) {
  AutoTraceSession session(cx->runtime());

  for (CompartmentsIter c(cx->runtime()); !c.done(); c.next()) {
    JS::AutoSuppressGCAnalysis callingSafeCallback(cx);
    if ((*compartmentCallback)(cx, data, c) ==
        JS::CompartmentIterResult::Stop) {
      break;
    }
  }
}

JS_PUBLIC_API void JS_IterateCompartmentsInZone(
    JSContext* cx, JS::Zone* zone, void* data,
    JSIterateCompartmentCallback compartmentCallback) {
  AutoTraceSession session(cx->runtime());

  for (CompartmentsInZoneIter c(zone); !c.done(); c.next()) {
    JS::AutoSuppressGCAnalysis callingSafeCallback(cx);
    if ((*compartmentCallback)(cx, data, c) ==
        JS::CompartmentIterResult::Stop) {
      break;
    }
  }
}

JS_PUBLIC_API void JS::IterateRealms(JSContext* cx, void* data,
                                     JS::IterateRealmCallback realmCallback) {
  AutoTraceSession session(cx->runtime());
  JS::AutoSuppressGCAnalysis nogc(cx);

  Rooted<Realm*> realm(cx);
  for (RealmsIter r(cx->runtime()); !r.done(); r.next()) {
    realm = r;
    (*realmCallback)(cx, data, realm, nogc);
  }
}

JS_PUBLIC_API void JS::IterateRealmsWithPrincipals(
    JSContext* cx, JSPrincipals* principals, void* data,
    JS::IterateRealmCallback realmCallback) {
  MOZ_ASSERT(principals);

  AutoTraceSession session(cx->runtime());
  JS::AutoSuppressGCAnalysis callingSafeCallback(cx);

  Rooted<Realm*> realm(cx);
  for (RealmsIter r(cx->runtime()); !r.done(); r.next()) {
    if (r->principals() != principals) {
      continue;
    }
    realm = r;
    (*realmCallback)(cx, data, realm, session);
  }
}

JS_PUBLIC_API void JS::IterateRealmsInCompartment(
    JSContext* cx, JS::Compartment* compartment, void* data,
    JS::IterateRealmCallback realmCallback) {
  AutoTraceSession session(cx->runtime());
  JS::AutoSuppressGCAnalysis callingSafeCallback(cx);

  Rooted<Realm*> realm(cx);
  for (RealmsInCompartmentIter r(compartment); !r.done(); r.next()) {
    realm = r;
    (*realmCallback)(cx, data, realm, session);
  }
}

Messung V0.5 in Prozent

¤ Dauer der Verarbeitung: 0.17 Sekunden (vorverarbeitet am 2026-10-12) ¤

Wurzel

Suchen

PVS Prover

Isabelle Prover

NIST Cobol Testsuite

Cephes Mathematical Library

Vienna Development Method

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.