Add m-esr52 at 52.6.0

1 files changed, 576 insertions, 0 deletions

diff --git a/js/src/builtin/Profilers.cpp b/js/src/builtin/Profilers.cpp
new file mode 100644
index 000000000..0d30a1c6b
--- /dev/null
+++ b/js/src/builtin/Profilers.cpp
@@ -0,0 +1,576 @@
+/* -*- 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/. */
+
+/* Profiling-related API */
+
+#include "builtin/Profilers.h"
+
+#include "mozilla/Sprintf.h"
+
+#include <stdarg.h>
+
+#ifdef MOZ_CALLGRIND
+# include <valgrind/callgrind.h>
+#endif
+
+#ifdef __APPLE__
+#ifdef MOZ_INSTRUMENTS
+# include "devtools/Instruments.h"
+#endif
+#endif
+
+#ifdef XP_WIN
+# include <process.h>
+# define getpid _getpid
+#endif
+
+#include "vm/Probes.h"
+
+#include "jscntxtinlines.h"
+
+using namespace js;
+
+using mozilla::ArrayLength;
+
+/* Thread-unsafe error management */
+
+static char gLastError[2000];
+
+#if defined(__APPLE__) || defined(__linux__) || defined(MOZ_CALLGRIND)
+static void
+MOZ_FORMAT_PRINTF(1, 2)
+UnsafeError(const char* format, ...)
+{
+    va_list args;
+    va_start(args, format);
+    (void) VsprintfLiteral(gLastError, format, args);
+    va_end(args);
+}
+#endif
+
+JS_PUBLIC_API(const char*)
+JS_UnsafeGetLastProfilingError()
+{
+    return gLastError;
+}
+
+#ifdef __APPLE__
+static bool
+StartOSXProfiling(const char* profileName, pid_t pid)
+{
+    bool ok = true;
+    const char* profiler = nullptr;
+#ifdef MOZ_INSTRUMENTS
+    ok = Instruments::Start(pid);
+    profiler = "Instruments";
+#endif
+    if (!ok) {
+        if (profileName)
+            UnsafeError("Failed to start %s for %s", profiler, profileName);
+        else
+            UnsafeError("Failed to start %s", profiler);
+        return false;
+    }
+    return true;
+}
+#endif
+
+JS_PUBLIC_API(bool)
+JS_StartProfiling(const char* profileName, pid_t pid)
+{
+    bool ok = true;
+#ifdef __APPLE__
+    ok = StartOSXProfiling(profileName, pid);
+#endif
+#ifdef __linux__
+    if (!js_StartPerf())
+        ok = false;
+#endif
+    return ok;
+}
+
+JS_PUBLIC_API(bool)
+JS_StopProfiling(const char* profileName)
+{
+    bool ok = true;
+#ifdef __APPLE__
+#ifdef MOZ_INSTRUMENTS
+    Instruments::Stop(profileName);
+#endif
+#endif
+#ifdef __linux__
+    if (!js_StopPerf())
+        ok = false;
+#endif
+    return ok;
+}
+
+/*
+ * Start or stop whatever platform- and configuration-specific profiling
+ * backends are available.
+ */
+static bool
+ControlProfilers(bool toState)
+{
+    bool ok = true;
+
+    if (! probes::ProfilingActive && toState) {
+#ifdef __APPLE__
+#if defined(MOZ_INSTRUMENTS)
+        const char* profiler;
+#ifdef MOZ_INSTRUMENTS
+        ok = Instruments::Resume();
+        profiler = "Instruments";
+#endif
+        if (!ok) {
+            UnsafeError("Failed to start %s", profiler);
+        }
+#endif
+#endif
+#ifdef MOZ_CALLGRIND
+        if (! js_StartCallgrind()) {
+            UnsafeError("Failed to start Callgrind");
+            ok = false;
+        }
+#endif
+    } else if (probes::ProfilingActive && ! toState) {
+#ifdef __APPLE__
+#ifdef MOZ_INSTRUMENTS
+        Instruments::Pause();
+#endif
+#endif
+#ifdef MOZ_CALLGRIND
+        if (! js_StopCallgrind()) {
+            UnsafeError("failed to stop Callgrind");
+            ok = false;
+        }
+#endif
+    }
+
+    probes::ProfilingActive = toState;
+
+    return ok;
+}
+
+/*
+ * Pause/resume whatever profiling mechanism is currently compiled
+ * in, if applicable. This will not affect things like dtrace.
+ *
+ * Do not mix calls to these APIs with calls to the individual
+ * profilers' pause/resume functions, because only overall state is
+ * tracked, not the state of each profiler.
+ */
+JS_PUBLIC_API(bool)
+JS_PauseProfilers(const char* profileName)
+{
+    return ControlProfilers(false);
+}
+
+JS_PUBLIC_API(bool)
+JS_ResumeProfilers(const char* profileName)
+{
+    return ControlProfilers(true);
+}
+
+JS_PUBLIC_API(bool)
+JS_DumpProfile(const char* outfile, const char* profileName)
+{
+    bool ok = true;
+#ifdef MOZ_CALLGRIND
+    js_DumpCallgrind(outfile);
+#endif
+    return ok;
+}
+
+#ifdef MOZ_PROFILING
+
+struct RequiredStringArg {
+    JSContext* mCx;
+    char* mBytes;
+    RequiredStringArg(JSContext* cx, const CallArgs& args, size_t argi, const char* caller)
+        : mCx(cx), mBytes(nullptr)
+    {
+        if (args.length() <= argi) {
+            JS_ReportErrorASCII(cx, "%s: not enough arguments", caller);
+        } else if (!args[argi].isString()) {
+            JS_ReportErrorASCII(cx, "%s: invalid arguments (string expected)", caller);
+        } else {
+            mBytes = JS_EncodeString(cx, args[argi].toString());
+        }
+    }
+    operator void*() {
+        return (void*) mBytes;
+    }
+    ~RequiredStringArg() {
+        js_free(mBytes);
+    }
+};
+
+static bool
+StartProfiling(JSContext* cx, unsigned argc, Value* vp)
+{
+    CallArgs args = CallArgsFromVp(argc, vp);
+    if (args.length() == 0) {
+        args.rval().setBoolean(JS_StartProfiling(nullptr, getpid()));
+        return true;
+    }
+
+    RequiredStringArg profileName(cx, args, 0, "startProfiling");
+    if (!profileName)
+        return false;
+
+    if (args.length() == 1) {
+        args.rval().setBoolean(JS_StartProfiling(profileName.mBytes, getpid()));
+        return true;
+    }
+
+    if (!args[1].isInt32()) {
+        JS_ReportErrorASCII(cx, "startProfiling: invalid arguments (int expected)");
+        return false;
+    }
+    pid_t pid = static_cast<pid_t>(args[1].toInt32());
+    args.rval().setBoolean(JS_StartProfiling(profileName.mBytes, pid));
+    return true;
+}
+
+static bool
+StopProfiling(JSContext* cx, unsigned argc, Value* vp)
+{
+    CallArgs args = CallArgsFromVp(argc, vp);
+    if (args.length() == 0) {
+        args.rval().setBoolean(JS_StopProfiling(nullptr));
+        return true;
+    }
+
+    RequiredStringArg profileName(cx, args, 0, "stopProfiling");
+    if (!profileName)
+        return false;
+    args.rval().setBoolean(JS_StopProfiling(profileName.mBytes));
+    return true;
+}
+
+static bool
+PauseProfilers(JSContext* cx, unsigned argc, Value* vp)
+{
+    CallArgs args = CallArgsFromVp(argc, vp);
+    if (args.length() == 0) {
+        args.rval().setBoolean(JS_PauseProfilers(nullptr));
+        return true;
+    }
+
+    RequiredStringArg profileName(cx, args, 0, "pauseProfiling");
+    if (!profileName)
+        return false;
+    args.rval().setBoolean(JS_PauseProfilers(profileName.mBytes));
+    return true;
+}
+
+static bool
+ResumeProfilers(JSContext* cx, unsigned argc, Value* vp)
+{
+    CallArgs args = CallArgsFromVp(argc, vp);
+    if (args.length() == 0) {
+        args.rval().setBoolean(JS_ResumeProfilers(nullptr));
+        return true;
+    }
+
+    RequiredStringArg profileName(cx, args, 0, "resumeProfiling");
+    if (!profileName)
+        return false;
+    args.rval().setBoolean(JS_ResumeProfilers(profileName.mBytes));
+    return true;
+}
+
+/* Usage: DumpProfile([filename[, profileName]]) */
+static bool
+DumpProfile(JSContext* cx, unsigned argc, Value* vp)
+{
+    bool ret;
+    CallArgs args = CallArgsFromVp(argc, vp);
+    if (args.length() == 0) {
+        ret = JS_DumpProfile(nullptr, nullptr);
+    } else {
+        RequiredStringArg filename(cx, args, 0, "dumpProfile");
+        if (!filename)
+            return false;
+
+        if (args.length() == 1) {
+            ret = JS_DumpProfile(filename.mBytes, nullptr);
+        } else {
+            RequiredStringArg profileName(cx, args, 1, "dumpProfile");
+            if (!profileName)
+                return false;
+
+            ret = JS_DumpProfile(filename.mBytes, profileName.mBytes);
+        }
+    }
+
+    args.rval().setBoolean(ret);
+    return true;
+}
+
+static bool
+GetMaxGCPauseSinceClear(JSContext* cx, unsigned argc, Value* vp)
+{
+    CallArgs args = CallArgsFromVp(argc, vp);
+    args.rval().setNumber(uint32_t(cx->runtime()->gc.stats.getMaxGCPauseSinceClear()));
+    return true;
+}
+
+static bool
+ClearMaxGCPauseAccumulator(JSContext* cx, unsigned argc, Value* vp)
+{
+    CallArgs args = CallArgsFromVp(argc, vp);
+    args.rval().setNumber(uint32_t(cx->runtime()->gc.stats.clearMaxGCPauseAccumulator()));
+    return true;
+}
+
+#if defined(MOZ_INSTRUMENTS)
+
+static bool
+IgnoreAndReturnTrue(JSContext* cx, unsigned argc, Value* vp)
+{
+    CallArgs args = CallArgsFromVp(argc, vp);
+    args.rval().setBoolean(true);
+    return true;
+}
+
+#endif
+
+#ifdef MOZ_CALLGRIND
+static bool
+StartCallgrind(JSContext* cx, unsigned argc, Value* vp)
+{
+    CallArgs args = CallArgsFromVp(argc, vp);
+    args.rval().setBoolean(js_StartCallgrind());
+    return true;
+}
+
+static bool
+StopCallgrind(JSContext* cx, unsigned argc, Value* vp)
+{
+    CallArgs args = CallArgsFromVp(argc, vp);
+    args.rval().setBoolean(js_StopCallgrind());
+    return true;
+}
+
+static bool
+DumpCallgrind(JSContext* cx, unsigned argc, Value* vp)
+{
+    CallArgs args = CallArgsFromVp(argc, vp);
+    if (args.length() == 0) {
+        args.rval().setBoolean(js_DumpCallgrind(nullptr));
+        return true;
+    }
+
+    RequiredStringArg outFile(cx, args, 0, "dumpCallgrind");
+    if (!outFile)
+        return false;
+
+    args.rval().setBoolean(js_DumpCallgrind(outFile.mBytes));
+    return true;
+}
+#endif
+
+static const JSFunctionSpec profiling_functions[] = {
+    JS_FN("startProfiling",  StartProfiling,      1,0),
+    JS_FN("stopProfiling",   StopProfiling,       1,0),
+    JS_FN("pauseProfilers",  PauseProfilers,      1,0),
+    JS_FN("resumeProfilers", ResumeProfilers,     1,0),
+    JS_FN("dumpProfile",     DumpProfile,         2,0),
+    JS_FN("getMaxGCPauseSinceClear",    GetMaxGCPauseSinceClear,    0, 0),
+    JS_FN("clearMaxGCPauseAccumulator", ClearMaxGCPauseAccumulator, 0, 0),
+#if defined(MOZ_INSTRUMENTS)
+    /* Keep users of the old shark API happy. */
+    JS_FN("connectShark",    IgnoreAndReturnTrue, 0,0),
+    JS_FN("disconnectShark", IgnoreAndReturnTrue, 0,0),
+    JS_FN("startShark",      StartProfiling,      0,0),
+    JS_FN("stopShark",       StopProfiling,       0,0),
+#endif
+#ifdef MOZ_CALLGRIND
+    JS_FN("startCallgrind", StartCallgrind,       0,0),
+    JS_FN("stopCallgrind",  StopCallgrind,        0,0),
+    JS_FN("dumpCallgrind",  DumpCallgrind,        1,0),
+#endif
+    JS_FS_END
+};
+
+#endif
+
+JS_PUBLIC_API(bool)
+JS_DefineProfilingFunctions(JSContext* cx, HandleObject obj)
+{
+    assertSameCompartment(cx, obj);
+#ifdef MOZ_PROFILING
+    return JS_DefineFunctions(cx, obj, profiling_functions);
+#else
+    return true;
+#endif
+}
+
+#ifdef MOZ_CALLGRIND
+
+JS_FRIEND_API(bool)
+js_StartCallgrind()
+{
+    JS_SILENCE_UNUSED_VALUE_IN_EXPR(CALLGRIND_START_INSTRUMENTATION);
+    JS_SILENCE_UNUSED_VALUE_IN_EXPR(CALLGRIND_ZERO_STATS);
+    return true;
+}
+
+JS_FRIEND_API(bool)
+js_StopCallgrind()
+{
+    JS_SILENCE_UNUSED_VALUE_IN_EXPR(CALLGRIND_STOP_INSTRUMENTATION);
+    return true;
+}
+
+JS_FRIEND_API(bool)
+js_DumpCallgrind(const char* outfile)
+{
+    if (outfile) {
+        JS_SILENCE_UNUSED_VALUE_IN_EXPR(CALLGRIND_DUMP_STATS_AT(outfile));
+    } else {
+        JS_SILENCE_UNUSED_VALUE_IN_EXPR(CALLGRIND_DUMP_STATS);
+    }
+
+    return true;
+}
+
+#endif /* MOZ_CALLGRIND */
+
+#ifdef __linux__
+
+/*
+ * Code for starting and stopping |perf|, the Linux profiler.
+ *
+ * Output from profiling is written to mozperf.data in your cwd.
+ *
+ * To enable, set MOZ_PROFILE_WITH_PERF=1 in your environment.
+ *
+ * To pass additional parameters to |perf record|, provide them in the
+ * MOZ_PROFILE_PERF_FLAGS environment variable.  If this variable does not
+ * exist, we default it to "--call-graph".  (If you don't want --call-graph but
+ * don't want to pass any other args, define MOZ_PROFILE_PERF_FLAGS to the empty
+ * string.)
+ *
+ * If you include --pid or --output in MOZ_PROFILE_PERF_FLAGS, you're just
+ * asking for trouble.
+ *
+ * Our split-on-spaces logic is lame, so don't expect MOZ_PROFILE_PERF_FLAGS to
+ * work if you pass an argument which includes a space (e.g.
+ * MOZ_PROFILE_PERF_FLAGS="-e 'foo bar'").
+ */
+
+#include <signal.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+static bool perfInitialized = false;
+static pid_t perfPid = 0;
+
+bool js_StartPerf()
+{
+    const char* outfile = "mozperf.data";
+
+    if (perfPid != 0) {
+        UnsafeError("js_StartPerf: called while perf was already running!\n");
+        return false;
+    }
+
+    // Bail if MOZ_PROFILE_WITH_PERF is empty or undefined.
+    if (!getenv("MOZ_PROFILE_WITH_PERF") ||
+        !strlen(getenv("MOZ_PROFILE_WITH_PERF"))) {
+        return true;
+    }
+
+    /*
+     * Delete mozperf.data the first time through -- we're going to append to it
+     * later on, so we want it to be clean when we start out.
+     */
+    if (!perfInitialized) {
+        perfInitialized = true;
+        unlink(outfile);
+        char cwd[4096];
+        printf("Writing perf profiling data to %s/%s\n",
+               getcwd(cwd, sizeof(cwd)), outfile);
+    }
+
+    pid_t mainPid = getpid();
+
+    pid_t childPid = fork();
+    if (childPid == 0) {
+        /* perf record --pid $mainPID --output=$outfile $MOZ_PROFILE_PERF_FLAGS */
+
+        char mainPidStr[16];
+        SprintfLiteral(mainPidStr, "%d", mainPid);
+        const char* defaultArgs[] = {"perf", "record", "--pid", mainPidStr, "--output", outfile};
+
+        Vector<const char*, 0, SystemAllocPolicy> args;
+        if (!args.append(defaultArgs, ArrayLength(defaultArgs)))
+            return false;
+
+        const char* flags = getenv("MOZ_PROFILE_PERF_FLAGS");
+        if (!flags) {
+            flags = "--call-graph";
+        }
+
+        UniqueChars flags2((char*)js_malloc(strlen(flags) + 1));
+        if (!flags2)
+            return false;
+        strcpy(flags2.get(), flags);
+
+        // Split |flags2| on spaces.
+        char* toksave;
+        char* tok = strtok_r(flags2.get(), " ", &toksave);
+        while (tok) {
+            if (!args.append(tok))
+                return false;
+            tok = strtok_r(nullptr, " ", &toksave);
+        }
+
+        if (!args.append((char*) nullptr))
+            return false;
+
+        execvp("perf", const_cast<char**>(args.begin()));
+
+        /* Reached only if execlp fails. */
+        fprintf(stderr, "Unable to start perf.\n");
+        exit(1);
+    }
+    if (childPid > 0) {
+        perfPid = childPid;
+
+        /* Give perf a chance to warm up. */
+        usleep(500 * 1000);
+        return true;
+    }
+    UnsafeError("js_StartPerf: fork() failed\n");
+    return false;
+}
+
+bool js_StopPerf()
+{
+    if (perfPid == 0) {
+        UnsafeError("js_StopPerf: perf is not running.\n");
+        return true;
+    }
+
+    if (kill(perfPid, SIGINT)) {
+        UnsafeError("js_StopPerf: kill failed\n");
+
+        // Try to reap the process anyway.
+        waitpid(perfPid, nullptr, WNOHANG);
+    }
+    else {
+        waitpid(perfPid, nullptr, 0);
+    }
+
+    perfPid = 0;
+    return true;
+}
+
+#endif /* __linux__ */