Add m-esr52 at 52.6.0

1 files changed, 564 insertions, 0 deletions

diff --git a/js/src/vm/TraceLogging.h b/js/src/vm/TraceLogging.h
new file mode 100644
index 000000000..92ebecef2
--- /dev/null
+++ b/js/src/vm/TraceLogging.h
@@ -0,0 +1,564 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
+ * vim: set ts=8 sts=4 et sw=4 tw=99:
+ * 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 TraceLogging_h
+#define TraceLogging_h
+
+#include "mozilla/GuardObjects.h"
+#include "mozilla/LinkedList.h"
+
+#include "jsalloc.h"
+
+#include "js/HashTable.h"
+#include "js/TypeDecls.h"
+#include "js/Vector.h"
+#include "threading/Thread.h"
+#include "vm/MutexIDs.h"
+#include "vm/TraceLoggingGraph.h"
+#include "vm/TraceLoggingTypes.h"
+
+struct JSRuntime;
+
+namespace JS {
+    class ReadOnlyCompileOptions;
+} // namespace JS
+
+namespace js {
+class PerThreadData;
+
+namespace jit {
+    class CompileRuntime;
+} // namespace jit
+
+/*
+ * Tracelogging overview.
+ *
+ * Tracelogging makes it possible to trace the occurrence of a single event
+ * and/or the start and stop of an event. This is implemented with as low
+ * overhead as possible to not interfere with running.
+ *
+ * Logging something is done in 3 stages.
+ * 1) Get the tracelogger of the current thread.
+ *     - TraceLoggerForMainThread(JSRuntime*)
+ *     - TraceLoggerForCurrentThread(); // Should NOT be used for the mainthread.
+ *
+ * 2) Optionally create a TraceLoggerEvent for the text that needs to get logged. This
+ *    step takes some time, so try to do this beforehand, outside the hot
+ *    path and don't do unnecessary repetitions, since it will cripple
+ *    performance.
+ *     - TraceLoggerEvent event(logger, "foo");
+ *
+ *    There are also some predefined events. They are located in
+ *    TraceLoggerTextId. They don't require to create an TraceLoggerEvent and
+ *    can also be used as an argument to these functions.
+ *
+ * 3) Log the occurrence of a single event:
+ *    - TraceLogTimestamp(logger, TraceLoggerTextId);
+ *      Note: it is temporarily not supported to provide an TraceLoggerEvent as
+ *            argument to log the occurrence of a single event.
+ *
+ *    or log the start and stop of an event:
+ *    - TraceLogStartEvent(logger, TraceLoggerTextId);
+ *    - TraceLogStartEvent(logger, TraceLoggerEvent);
+ *    - TraceLogStopEvent(logger, TraceLoggerTextId);
+ *    - TraceLogStopEvent(logger, TraceLoggerEvent);
+ *
+ *    or the start/stop of an event with a RAII class:
+ *    - AutoTraceLog atl(logger, TraceLoggerTextId);
+ *    - AutoTraceLog atl(logger, TraceLoggerEvent);
+ */
+
+class AutoTraceLog;
+class TraceLoggerEventPayload;
+class TraceLoggerThread;
+
+/**
+ * An event that can be used to report start/stop events to TraceLogger. It
+ * prepares the given info by requesting a TraceLoggerEventPayload containing
+ * the string to report and an unique id. It also increases the useCount of
+ * this payload, so it cannot get removed.
+ */
+class TraceLoggerEvent {
+  private:
+    TraceLoggerEventPayload* payload_;
+
+  public:
+    TraceLoggerEvent() { payload_ = nullptr; };
+#ifdef JS_TRACE_LOGGING
+    TraceLoggerEvent(TraceLoggerThread* logger, TraceLoggerTextId textId);
+    TraceLoggerEvent(TraceLoggerThread* logger, TraceLoggerTextId type, JSScript* script);
+    TraceLoggerEvent(TraceLoggerThread* logger, TraceLoggerTextId type,
+                     const JS::ReadOnlyCompileOptions& compileOptions);
+    TraceLoggerEvent(TraceLoggerThread* logger, const char* text);
+    TraceLoggerEvent(const TraceLoggerEvent& event);
+    TraceLoggerEvent& operator=(const TraceLoggerEvent& other);
+    ~TraceLoggerEvent();
+#else
+    TraceLoggerEvent (TraceLoggerThread* logger, TraceLoggerTextId textId) {}
+    TraceLoggerEvent (TraceLoggerThread* logger, TraceLoggerTextId type, JSScript* script) {}
+    TraceLoggerEvent (TraceLoggerThread* logger, TraceLoggerTextId type,
+                      const JS::ReadOnlyCompileOptions& compileOptions) {}
+    TraceLoggerEvent (TraceLoggerThread* logger, const char* text) {}
+    TraceLoggerEvent(const TraceLoggerEvent& event) {}
+    TraceLoggerEvent& operator=(const TraceLoggerEvent& other) {};
+    ~TraceLoggerEvent() {}
+#endif
+
+    TraceLoggerEventPayload* payload() const {
+        MOZ_ASSERT(hasPayload());
+        return payload_;
+    }
+    bool hasPayload() const {
+        return !!payload_;
+    }
+};
+
+/**
+ * An internal class holding the string information to report, together with an
+ * unique id and a useCount. Whenever this useCount reaches 0, this event
+ * cannot get started/stopped anymore. Consumers may still request the
+ * string information.
+ */
+class TraceLoggerEventPayload {
+    uint32_t textId_;
+    UniqueChars string_;
+    uint32_t uses_;
+
+  public:
+    TraceLoggerEventPayload(uint32_t textId, char* string)
+      : textId_(textId),
+        string_(string),
+        uses_(0)
+    { }
+
+    ~TraceLoggerEventPayload() {
+        MOZ_ASSERT(uses_ == 0);
+    }
+
+    uint32_t textId() {
+        return textId_;
+    }
+    const char* string() {
+        return string_.get();
+    }
+    uint32_t uses() {
+        return uses_;
+    }
+    void use() {
+        uses_++;
+    }
+    void release() {
+        uses_--;
+    }
+};
+
+class TraceLoggerThread
+{
+#ifdef JS_TRACE_LOGGING
+  private:
+    typedef HashMap<const void*,
+                    TraceLoggerEventPayload*,
+                    PointerHasher<const void*, 3>,
+                    SystemAllocPolicy> PointerHashMap;
+    typedef HashMap<uint32_t,
+                    TraceLoggerEventPayload*,
+                    DefaultHasher<uint32_t>,
+                    SystemAllocPolicy> TextIdHashMap;
+
+    uint32_t enabled_;
+    bool failed;
+
+    UniquePtr<TraceLoggerGraph> graph;
+
+    PointerHashMap pointerMap;
+    TextIdHashMap textIdPayloads;
+    uint32_t nextTextId;
+
+    ContinuousSpace<EventEntry> events;
+
+    // Every time the events get flushed, this count is increased by one.
+    // Together with events.lastEntryId(), this gives an unique id for every
+    // event.
+    uint32_t iteration_;
+
+#ifdef DEBUG
+    typedef Vector<uint32_t, 1, js::SystemAllocPolicy > GraphStack;
+    GraphStack graphStack;
+#endif
+
+  public:
+    AutoTraceLog* top;
+
+    TraceLoggerThread()
+      : enabled_(0),
+        failed(false),
+        graph(),
+        nextTextId(TraceLogger_Last),
+        iteration_(0),
+        top(nullptr)
+    { }
+
+    bool init();
+    ~TraceLoggerThread();
+
+    bool init(uint32_t loggerId);
+    void initGraph();
+
+    bool enable();
+    bool enable(JSContext* cx);
+    bool disable(bool force = false, const char* = "");
+    bool enabled() { return enabled_ > 0; }
+
+  private:
+    bool fail(JSContext* cx, const char* error);
+
+  public:
+    // Given the previous iteration and size, return an array of events
+    // (there could be lost events). At the same time update the iteration and
+    // size and gives back how many events there are.
+    EventEntry* getEventsStartingAt(uint32_t* lastIteration, uint32_t* lastSize, size_t* num) {
+        EventEntry* start;
+        if (iteration_ == *lastIteration) {
+            MOZ_ASSERT(*lastSize <= events.size());
+            *num = events.size() - *lastSize;
+            start = events.data() + *lastSize;
+        } else {
+            *num = events.size();
+            start = events.data();
+        }
+
+        getIterationAndSize(lastIteration, lastSize);
+        return start;
+    }
+
+    void getIterationAndSize(uint32_t* iteration, uint32_t* size) const {
+        *iteration = iteration_;
+        *size = events.size();
+    }
+
+    // Extract the details filename, lineNumber and columnNumber out of a event
+    // containing script information.
+    void extractScriptDetails(uint32_t textId, const char** filename, size_t* filename_len,
+                              const char** lineno, size_t* lineno_len, const char** colno,
+                              size_t* colno_len);
+
+    bool lostEvents(uint32_t lastIteration, uint32_t lastSize) {
+        // If still logging in the same iteration, there are no lost events.
+        if (lastIteration == iteration_) {
+            MOZ_ASSERT(lastSize <= events.size());
+            return false;
+        }
+
+        // If we are in the next consecutive iteration we are only sure we
+        // didn't lose any events when the lastSize equals the maximum size
+        // 'events' can get.
+        if (lastIteration == iteration_ - 1 && lastSize == events.maxSize())
+            return false;
+
+        return true;
+    }
+
+    const char* eventText(uint32_t id);
+    bool textIdIsScriptEvent(uint32_t id);
+
+    // The createTextId functions map a unique input to a logger ID.
+    // This can be used to give start and stop events. Calls to these functions should be
+    // limited if possible, because of the overhead.
+    // Note: it is not allowed to use them in logTimestamp.
+    TraceLoggerEventPayload* getOrCreateEventPayload(TraceLoggerTextId textId);
+    TraceLoggerEventPayload* getOrCreateEventPayload(const char* text);
+    TraceLoggerEventPayload* getOrCreateEventPayload(TraceLoggerTextId type, JSScript* script);
+    TraceLoggerEventPayload* getOrCreateEventPayload(TraceLoggerTextId type,
+                                                     const JS::ReadOnlyCompileOptions& script);
+  private:
+    TraceLoggerEventPayload* getOrCreateEventPayload(TraceLoggerTextId type, const char* filename,
+                                                     size_t lineno, size_t colno, const void* p);
+
+  public:
+    // Log an event (no start/stop, only the timestamp is recorded).
+    void logTimestamp(TraceLoggerTextId id);
+
+    // Record timestamps for start and stop of an event.
+    void startEvent(TraceLoggerTextId id);
+    void startEvent(const TraceLoggerEvent& event);
+    void stopEvent(TraceLoggerTextId id);
+    void stopEvent(const TraceLoggerEvent& event);
+
+    // These functions are actually private and shouldn't be used in normal
+    // code. They are made public so they can be used in assembly.
+    void logTimestamp(uint32_t id);
+    void startEvent(uint32_t id);
+    void stopEvent(uint32_t id);
+  private:
+    void stopEvent();
+    void log(uint32_t id);
+
+  public:
+    static unsigned offsetOfEnabled() {
+        return offsetof(TraceLoggerThread, enabled_);
+    }
+#endif
+};
+
+#ifdef JS_TRACE_LOGGING
+class TraceLoggerMainThread
+  : public TraceLoggerThread,
+    public mozilla::LinkedListElement<TraceLoggerMainThread>
+{
+
+};
+#endif
+
+class TraceLoggerThreadState
+{
+#ifdef JS_TRACE_LOGGING
+    typedef HashMap<Thread::Id,
+                    TraceLoggerThread*,
+                    Thread::Hasher,
+                    SystemAllocPolicy> ThreadLoggerHashMap;
+
+#ifdef DEBUG
+    bool initialized;
+#endif
+
+    bool enabledTextIds[TraceLogger_Last];
+    bool mainThreadEnabled;
+    bool offThreadEnabled;
+    bool graphSpewingEnabled;
+    bool spewErrors;
+    ThreadLoggerHashMap threadLoggers;
+    mozilla::LinkedList<TraceLoggerMainThread> traceLoggerMainThreadList;
+
+  public:
+    uint64_t startupTime;
+    Mutex lock;
+
+    TraceLoggerThreadState()
+      :
+#ifdef DEBUG
+        initialized(false),
+#endif
+        mainThreadEnabled(false),
+        offThreadEnabled(false),
+        graphSpewingEnabled(false),
+        spewErrors(false),
+        lock(js::mutexid::TraceLoggerThreadState)
+    { }
+
+    bool init();
+    ~TraceLoggerThreadState();
+
+    TraceLoggerThread* forMainThread(JSRuntime* runtime);
+    TraceLoggerThread* forMainThread(jit::CompileRuntime* runtime);
+    TraceLoggerThread* forThread(const Thread::Id& thread);
+    void destroyMainThread(JSRuntime* runtime);
+
+    bool isTextIdEnabled(uint32_t textId) {
+        if (textId < TraceLogger_Last)
+            return enabledTextIds[textId];
+        return true;
+    }
+    void enableTextId(JSContext* cx, uint32_t textId);
+    void disableTextId(JSContext* cx, uint32_t textId);
+    void maybeSpewError(const char* text) {
+        if (spewErrors)
+            fprintf(stderr, "%s\n", text);
+    }
+
+  private:
+    TraceLoggerThread* forMainThread(PerThreadData* mainThread);
+#endif
+};
+
+#ifdef JS_TRACE_LOGGING
+void DestroyTraceLoggerThreadState();
+void DestroyTraceLoggerMainThread(JSRuntime* runtime);
+
+TraceLoggerThread* TraceLoggerForMainThread(JSRuntime* runtime);
+TraceLoggerThread* TraceLoggerForMainThread(jit::CompileRuntime* runtime);
+TraceLoggerThread* TraceLoggerForCurrentThread();
+#else
+inline TraceLoggerThread* TraceLoggerForMainThread(JSRuntime* runtime) {
+    return nullptr;
+};
+inline TraceLoggerThread* TraceLoggerForMainThread(jit::CompileRuntime* runtime) {
+    return nullptr;
+};
+inline TraceLoggerThread* TraceLoggerForCurrentThread() {
+    return nullptr;
+};
+#endif
+
+inline bool TraceLoggerEnable(TraceLoggerThread* logger) {
+#ifdef JS_TRACE_LOGGING
+    if (logger)
+        return logger->enable();
+#endif
+    return false;
+}
+inline bool TraceLoggerEnable(TraceLoggerThread* logger, JSContext* cx) {
+#ifdef JS_TRACE_LOGGING
+    if (logger)
+        return logger->enable(cx);
+#endif
+    return false;
+}
+inline bool TraceLoggerDisable(TraceLoggerThread* logger) {
+#ifdef JS_TRACE_LOGGING
+    if (logger)
+        return logger->disable();
+#endif
+    return false;
+}
+
+#ifdef JS_TRACE_LOGGING
+bool TraceLogTextIdEnabled(uint32_t textId);
+void TraceLogEnableTextId(JSContext* cx, uint32_t textId);
+void TraceLogDisableTextId(JSContext* cx, uint32_t textId);
+#else
+inline bool TraceLogTextIdEnabled(uint32_t textId) {
+    return false;
+}
+inline void TraceLogEnableTextId(JSContext* cx, uint32_t textId) {}
+inline void TraceLogDisableTextId(JSContext* cx, uint32_t textId) {}
+#endif
+inline void TraceLogTimestamp(TraceLoggerThread* logger, TraceLoggerTextId textId) {
+#ifdef JS_TRACE_LOGGING
+    if (logger)
+        logger->logTimestamp(textId);
+#endif
+}
+inline void TraceLogStartEvent(TraceLoggerThread* logger, TraceLoggerTextId textId) {
+#ifdef JS_TRACE_LOGGING
+    if (logger)
+        logger->startEvent(textId);
+#endif
+}
+inline void TraceLogStartEvent(TraceLoggerThread* logger, const TraceLoggerEvent& event) {
+#ifdef JS_TRACE_LOGGING
+    if (logger)
+        logger->startEvent(event);
+#endif
+}
+inline void TraceLogStopEvent(TraceLoggerThread* logger, TraceLoggerTextId textId) {
+#ifdef JS_TRACE_LOGGING
+    if (logger)
+        logger->stopEvent(textId);
+#endif
+}
+inline void TraceLogStopEvent(TraceLoggerThread* logger, const TraceLoggerEvent& event) {
+#ifdef JS_TRACE_LOGGING
+    if (logger)
+        logger->stopEvent(event);
+#endif
+}
+
+// Helper functions for assembly. May not be used otherwise.
+inline void TraceLogTimestampPrivate(TraceLoggerThread* logger, uint32_t id) {
+#ifdef JS_TRACE_LOGGING
+    if (logger)
+        logger->logTimestamp(id);
+#endif
+}
+inline void TraceLogStartEventPrivate(TraceLoggerThread* logger, uint32_t id) {
+#ifdef JS_TRACE_LOGGING
+    if (logger)
+        logger->startEvent(id);
+#endif
+}
+inline void TraceLogStopEventPrivate(TraceLoggerThread* logger, uint32_t id) {
+#ifdef JS_TRACE_LOGGING
+    if (logger)
+        logger->stopEvent(id);
+#endif
+}
+
+// Automatic logging at the start and end of function call.
+class MOZ_RAII AutoTraceLog
+{
+#ifdef JS_TRACE_LOGGING
+    TraceLoggerThread* logger;
+    union {
+        const TraceLoggerEvent* event;
+        TraceLoggerTextId id;
+    } payload;
+    bool isEvent;
+    bool executed;
+    AutoTraceLog* prev;
+
+  public:
+    AutoTraceLog(TraceLoggerThread* logger,
+                 const TraceLoggerEvent& event MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
+      : logger(logger),
+        isEvent(true),
+        executed(false)
+    {
+        MOZ_GUARD_OBJECT_NOTIFIER_INIT;
+        payload.event = &event;
+        if (logger) {
+            logger->startEvent(event);
+
+            prev = logger->top;
+            logger->top = this;
+        }
+    }
+
+    AutoTraceLog(TraceLoggerThread* logger, TraceLoggerTextId id MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
+      : logger(logger),
+        isEvent(false),
+        executed(false)
+    {
+        MOZ_GUARD_OBJECT_NOTIFIER_INIT;
+        payload.id = id;
+        if (logger) {
+            logger->startEvent(id);
+
+            prev = logger->top;
+            logger->top = this;
+        }
+    }
+
+    ~AutoTraceLog()
+    {
+        if (logger) {
+            while (this != logger->top)
+                logger->top->stop();
+            stop();
+        }
+    }
+  private:
+    void stop() {
+        if (!executed) {
+            executed = true;
+            if (isEvent)
+                logger->stopEvent(*payload.event);
+            else
+                logger->stopEvent(payload.id);
+        }
+
+        if (logger->top == this)
+            logger->top = prev;
+    }
+#else
+  public:
+    AutoTraceLog(TraceLoggerThread* logger, uint32_t textId MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
+    {
+        MOZ_GUARD_OBJECT_NOTIFIER_INIT;
+    }
+    AutoTraceLog(TraceLoggerThread* logger,
+                 const TraceLoggerEvent& event MOZ_GUARD_OBJECT_NOTIFIER_PARAM)
+    {
+        MOZ_GUARD_OBJECT_NOTIFIER_INIT;
+    }
+#endif
+
+  private:
+    MOZ_DECL_USE_GUARD_OBJECT_NOTIFIER
+};
+
+} // namespace js
+
+#endif /* TraceLogging_h */