Add m-esr52 at 52.6.0

1 files changed, 679 insertions, 0 deletions

diff --git a/js/src/jit/JitSpewer.cpp b/js/src/jit/JitSpewer.cpp
new file mode 100644
index 000000000..b939f5ea2
--- /dev/null
+++ b/js/src/jit/JitSpewer.cpp
@@ -0,0 +1,679 @@
+/* -*- 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/. */
+
+#ifdef JS_JITSPEW
+
+#include "jit/JitSpewer.h"
+
+#include "mozilla/Atomics.h"
+
+#if defined(XP_WIN)
+# include <windows.h>
+#else
+# include <unistd.h>
+#endif
+
+#include "jsprf.h"
+
+#include "jit/Ion.h"
+#include "jit/MIR.h"
+#include "jit/MIRGenerator.h"
+#include "jit/MIRGraph.h"
+
+#include "threading/LockGuard.h"
+
+#include "vm/HelperThreads.h"
+#include "vm/MutexIDs.h"
+
+#ifndef JIT_SPEW_DIR
+# if defined(_WIN32)
+#  define JIT_SPEW_DIR ""
+# elif defined(__ANDROID__)
+#  define JIT_SPEW_DIR "/data/local/tmp/"
+# else
+#  define JIT_SPEW_DIR "/tmp/"
+# endif
+#endif
+
+using namespace js;
+using namespace js::jit;
+
+class IonSpewer
+{
+  private:
+    Mutex outputLock_;
+    Fprinter c1Output_;
+    Fprinter jsonOutput_;
+    bool firstFunction_;
+    bool asyncLogging_;
+    bool inited_;
+
+    void release();
+
+  public:
+    IonSpewer()
+      : outputLock_(mutexid::IonSpewer),
+        firstFunction_(false),
+        asyncLogging_(false),
+        inited_(false)
+    { }
+
+    // File output is terminated safely upon destruction.
+    ~IonSpewer();
+
+    bool init();
+    bool isEnabled() {
+        return inited_;
+    }
+    void setAsyncLogging(bool incremental) {
+        asyncLogging_ = incremental;
+    }
+    bool getAsyncLogging() {
+        return asyncLogging_;
+    }
+
+    void beginFunction();
+    void spewPass(GraphSpewer* gs);
+    void endFunction(GraphSpewer* gs);
+};
+
+// IonSpewer singleton.
+static IonSpewer ionspewer;
+
+static bool LoggingChecked = false;
+static_assert(JitSpew_Terminator <= 64, "Increase the size of the LoggingBits global.");
+static uint64_t LoggingBits = 0;
+static mozilla::Atomic<uint32_t, mozilla::Relaxed> filteredOutCompilations(0);
+
+static const char * const ChannelNames[] =
+{
+#define JITSPEW_CHANNEL(name) #name,
+    JITSPEW_CHANNEL_LIST(JITSPEW_CHANNEL)
+#undef JITSPEW_CHANNEL
+};
+
+static size_t ChannelIndentLevel[] =
+{
+#define JITSPEW_CHANNEL(name) 0,
+    JITSPEW_CHANNEL_LIST(JITSPEW_CHANNEL)
+#undef JITSPEW_CHANNEL
+};
+
+static bool
+FilterContainsLocation(JSScript* function)
+{
+    static const char* filter = getenv("IONFILTER");
+
+    // If there is no filter we accept all outputs.
+    if (!filter || !filter[0])
+        return true;
+
+    // Disable wasm output when filter is set.
+    if (!function)
+        return false;
+
+    const char* filename = function->filename();
+    const size_t line = function->lineno();
+    const size_t filelen = strlen(filename);
+    const char* index = strstr(filter, filename);
+    while (index) {
+        if (index == filter || index[-1] == ',') {
+            if (index[filelen] == 0 || index[filelen] == ',')
+                return true;
+            if (index[filelen] == ':' && line != size_t(-1)) {
+                size_t read_line = strtoul(&index[filelen + 1], nullptr, 10);
+                if (read_line == line)
+                    return true;
+            }
+        }
+        index = strstr(index + filelen, filename);
+    }
+    return false;
+}
+
+void
+jit::EnableIonDebugSyncLogging()
+{
+    ionspewer.init();
+    ionspewer.setAsyncLogging(false);
+    EnableChannel(JitSpew_IonSyncLogs);
+}
+
+void
+jit::EnableIonDebugAsyncLogging()
+{
+    ionspewer.init();
+    ionspewer.setAsyncLogging(true);
+}
+
+void
+IonSpewer::release()
+{
+    if (c1Output_.isInitialized())
+        c1Output_.finish();
+    if (jsonOutput_.isInitialized())
+        jsonOutput_.finish();
+    inited_ = false;
+}
+
+bool
+IonSpewer::init()
+{
+    if (inited_)
+        return true;
+
+    const size_t bufferLength = 256;
+    char c1Buffer[bufferLength];
+    char jsonBuffer[bufferLength];
+    const char *c1Filename = JIT_SPEW_DIR "/ion.cfg";
+    const char *jsonFilename = JIT_SPEW_DIR "/ion.json";
+
+    const char* usePid = getenv("ION_SPEW_BY_PID");
+    if (usePid && *usePid != 0) {
+#if defined(XP_WIN)
+        size_t pid = GetCurrentProcessId();
+#else
+        size_t pid = getpid();
+#endif
+
+        size_t len;
+        len = snprintf(jsonBuffer, bufferLength, JIT_SPEW_DIR "/ion%" PRIuSIZE ".json", pid);
+        if (bufferLength <= len) {
+            fprintf(stderr, "Warning: IonSpewer::init: Cannot serialize file name.");
+            return false;
+        }
+        jsonFilename = jsonBuffer;
+
+        len = snprintf(c1Buffer, bufferLength, JIT_SPEW_DIR "/ion%" PRIuSIZE ".cfg", pid);
+        if (bufferLength <= len) {
+            fprintf(stderr, "Warning: IonSpewer::init: Cannot serialize file name.");
+            return false;
+        }
+        c1Filename = c1Buffer;
+    }
+
+    if (!c1Output_.init(c1Filename) ||
+        !jsonOutput_.init(jsonFilename))
+    {
+        release();
+        return false;
+    }
+
+    jsonOutput_.printf("{\n  \"functions\": [\n");
+    firstFunction_ = true;
+
+    inited_ = true;
+    return true;
+}
+
+void
+IonSpewer::beginFunction()
+{
+    // If we are doing a synchronous logging then we spew everything as we go,
+    // as this is useful in case of failure during the compilation. On the other
+    // hand, it is recommended to disabled off main thread compilation.
+    if (!getAsyncLogging() && !firstFunction_) {
+        LockGuard<Mutex> guard(outputLock_);
+        jsonOutput_.put(","); // separate functions
+    }
+}
+
+void
+IonSpewer::spewPass(GraphSpewer* gs)
+{
+    if (!getAsyncLogging()) {
+        LockGuard<Mutex> guard(outputLock_);
+        gs->dump(c1Output_, jsonOutput_);
+    }
+}
+
+void
+IonSpewer::endFunction(GraphSpewer* gs)
+{
+    LockGuard<Mutex> guard(outputLock_);
+    if (getAsyncLogging() && !firstFunction_)
+        jsonOutput_.put(","); // separate functions
+
+    gs->dump(c1Output_, jsonOutput_);
+    firstFunction_ = false;
+}
+
+IonSpewer::~IonSpewer()
+{
+    if (!inited_)
+        return;
+
+    jsonOutput_.printf("\n]}\n");
+    release();
+}
+
+GraphSpewer::GraphSpewer(TempAllocator *alloc)
+  : graph_(nullptr),
+    c1Printer_(alloc->lifoAlloc()),
+    jsonPrinter_(alloc->lifoAlloc()),
+    c1Spewer_(c1Printer_),
+    jsonSpewer_(jsonPrinter_)
+{
+}
+
+void
+GraphSpewer::init(MIRGraph* graph, JSScript* function)
+{
+    MOZ_ASSERT(!isSpewing());
+    if (!ionspewer.isEnabled())
+        return;
+
+    if (!FilterContainsLocation(function)) {
+        // filter out logs during the compilation.
+        filteredOutCompilations++;
+        MOZ_ASSERT(!isSpewing());
+        return;
+    }
+
+    graph_ = graph;
+    MOZ_ASSERT(isSpewing());
+}
+
+void
+GraphSpewer::beginFunction(JSScript* function)
+{
+    if (!isSpewing())
+        return;
+
+    c1Spewer_.beginFunction(graph_, function);
+    jsonSpewer_.beginFunction(function);
+
+    ionspewer.beginFunction();
+}
+
+void
+GraphSpewer::spewPass(const char* pass)
+{
+    if (!isSpewing())
+        return;
+
+    c1Spewer_.spewPass(pass);
+
+    jsonSpewer_.beginPass(pass);
+    jsonSpewer_.spewMIR(graph_);
+    jsonSpewer_.spewLIR(graph_);
+    jsonSpewer_.endPass();
+
+    ionspewer.spewPass(this);
+
+    // As this function is used for debugging, we ignore any of the previous
+    // failures and ensure there is enough ballast space, such that we do not
+    // exhaust the ballast space before running the next phase.
+    AutoEnterOOMUnsafeRegion oomUnsafe;
+    if (!graph_->alloc().ensureBallast())
+        oomUnsafe.crash("Could not ensure enough ballast space after spewing graph information.");
+}
+
+void
+GraphSpewer::spewPass(const char* pass, BacktrackingAllocator* ra)
+{
+    if (!isSpewing())
+        return;
+
+    c1Spewer_.spewPass(pass);
+    c1Spewer_.spewRanges(pass, ra);
+
+    jsonSpewer_.beginPass(pass);
+    jsonSpewer_.spewMIR(graph_);
+    jsonSpewer_.spewLIR(graph_);
+    jsonSpewer_.spewRanges(ra);
+    jsonSpewer_.endPass();
+
+    ionspewer.spewPass(this);
+}
+
+void
+GraphSpewer::endFunction()
+{
+    if (!ionspewer.isEnabled())
+        return;
+
+    if (!isSpewing()) {
+        MOZ_ASSERT(filteredOutCompilations != 0);
+        filteredOutCompilations--;
+        return;
+    }
+
+    c1Spewer_.endFunction();
+    jsonSpewer_.endFunction();
+
+    ionspewer.endFunction(this);
+    graph_ = nullptr;
+}
+
+void
+GraphSpewer::dump(Fprinter& c1Out, Fprinter& jsonOut)
+{
+    if (!c1Printer_.hadOutOfMemory()) {
+        c1Printer_.exportInto(c1Out);
+        c1Out.flush();
+    }
+    c1Printer_.clear();
+
+    if (!jsonPrinter_.hadOutOfMemory())
+        jsonPrinter_.exportInto(jsonOut);
+    else
+        jsonOut.put("{}");
+    jsonOut.flush();
+    jsonPrinter_.clear();
+}
+
+void
+jit::SpewBeginFunction(MIRGenerator* mir, JSScript* function)
+{
+    MIRGraph* graph = &mir->graph();
+    mir->graphSpewer().init(graph, function);
+    mir->graphSpewer().beginFunction(function);
+}
+
+AutoSpewEndFunction::~AutoSpewEndFunction()
+{
+    mir_->graphSpewer().endFunction();
+}
+
+Fprinter&
+jit::JitSpewPrinter()
+{
+    static Fprinter out;
+    return out;
+}
+
+
+static bool
+ContainsFlag(const char* str, const char* flag)
+{
+    size_t flaglen = strlen(flag);
+    const char* index = strstr(str, flag);
+    while (index) {
+        if ((index == str || index[-1] == ',') && (index[flaglen] == 0 || index[flaglen] == ','))
+            return true;
+        index = strstr(index + flaglen, flag);
+    }
+    return false;
+}
+
+void
+jit::CheckLogging()
+{
+    if (LoggingChecked)
+        return;
+    LoggingChecked = true;
+    const char* env = getenv("IONFLAGS");
+    if (!env)
+        return;
+    if (strstr(env, "help")) {
+        fflush(nullptr);
+        printf(
+            "\n"
+            "usage: IONFLAGS=option,option,option,... where options can be:\n"
+            "\n"
+            "  aborts        Compilation abort messages\n"
+            "  scripts       Compiled scripts\n"
+            "  mir           MIR information\n"
+            "  prune         Prune unused branches\n"
+            "  escape        Escape analysis\n"
+            "  alias         Alias analysis\n"
+            "  alias-sum     Alias analysis: shows summaries for every block\n"
+            "  gvn           Global Value Numbering\n"
+            "  licm          Loop invariant code motion\n"
+            "  flac          Fold linear arithmetic constants\n"
+            "  eaa           Effective address analysis\n"
+            "  sincos        Replace sin/cos by sincos\n"
+            "  sink          Sink transformation\n"
+            "  regalloc      Register allocation\n"
+            "  inline        Inlining\n"
+            "  snapshots     Snapshot information\n"
+            "  codegen       Native code generation\n"
+            "  bailouts      Bailouts\n"
+            "  caches        Inline caches\n"
+            "  osi           Invalidation\n"
+            "  safepoints    Safepoints\n"
+            "  pools         Literal Pools (ARM only for now)\n"
+            "  cacheflush    Instruction Cache flushes (ARM only for now)\n"
+            "  range         Range Analysis\n"
+            "  unroll        Loop unrolling\n"
+            "  logs          C1 and JSON visualization logging\n"
+            "  logs-sync     Same as logs, but flushes between each pass (sync. compiled functions only).\n"
+            "  profiling     Profiling-related information\n"
+            "  trackopts     Optimization tracking information\n"
+            "  dump-mir-expr Dump the MIR expressions\n"
+            "  all           Everything\n"
+            "\n"
+            "  bl-aborts     Baseline compiler abort messages\n"
+            "  bl-scripts    Baseline script-compilation\n"
+            "  bl-op         Baseline compiler detailed op-specific messages\n"
+            "  bl-ic         Baseline inline-cache messages\n"
+            "  bl-ic-fb      Baseline IC fallback stub messages\n"
+            "  bl-osr        Baseline IC OSR messages\n"
+            "  bl-bails      Baseline bailouts\n"
+            "  bl-dbg-osr    Baseline debug mode on stack recompile messages\n"
+            "  bl-all        All baseline spew\n"
+            "\n"
+        );
+        exit(0);
+        /*NOTREACHED*/
+    }
+    if (ContainsFlag(env, "aborts"))
+        EnableChannel(JitSpew_IonAbort);
+    if (ContainsFlag(env, "prune"))
+        EnableChannel(JitSpew_Prune);
+    if (ContainsFlag(env, "escape"))
+        EnableChannel(JitSpew_Escape);
+    if (ContainsFlag(env, "alias"))
+        EnableChannel(JitSpew_Alias);
+    if (ContainsFlag(env, "alias-sum"))
+        EnableChannel(JitSpew_AliasSummaries);
+    if (ContainsFlag(env, "scripts"))
+        EnableChannel(JitSpew_IonScripts);
+    if (ContainsFlag(env, "mir"))
+        EnableChannel(JitSpew_IonMIR);
+    if (ContainsFlag(env, "gvn"))
+        EnableChannel(JitSpew_GVN);
+    if (ContainsFlag(env, "range"))
+        EnableChannel(JitSpew_Range);
+    if (ContainsFlag(env, "unroll"))
+        EnableChannel(JitSpew_Unrolling);
+    if (ContainsFlag(env, "licm"))
+        EnableChannel(JitSpew_LICM);
+    if (ContainsFlag(env, "flac"))
+        EnableChannel(JitSpew_FLAC);
+    if (ContainsFlag(env, "eaa"))
+        EnableChannel(JitSpew_EAA);
+    if (ContainsFlag(env, "sincos"))
+        EnableChannel(JitSpew_Sincos);
+    if (ContainsFlag(env, "sink"))
+        EnableChannel(JitSpew_Sink);
+    if (ContainsFlag(env, "regalloc"))
+        EnableChannel(JitSpew_RegAlloc);
+    if (ContainsFlag(env, "inline"))
+        EnableChannel(JitSpew_Inlining);
+    if (ContainsFlag(env, "snapshots"))
+        EnableChannel(JitSpew_IonSnapshots);
+    if (ContainsFlag(env, "codegen"))
+        EnableChannel(JitSpew_Codegen);
+    if (ContainsFlag(env, "bailouts"))
+        EnableChannel(JitSpew_IonBailouts);
+    if (ContainsFlag(env, "osi"))
+        EnableChannel(JitSpew_IonInvalidate);
+    if (ContainsFlag(env, "caches"))
+        EnableChannel(JitSpew_IonIC);
+    if (ContainsFlag(env, "safepoints"))
+        EnableChannel(JitSpew_Safepoints);
+    if (ContainsFlag(env, "pools"))
+        EnableChannel(JitSpew_Pools);
+    if (ContainsFlag(env, "cacheflush"))
+        EnableChannel(JitSpew_CacheFlush);
+    if (ContainsFlag(env, "logs"))
+        EnableIonDebugAsyncLogging();
+    if (ContainsFlag(env, "logs-sync"))
+        EnableIonDebugSyncLogging();
+    if (ContainsFlag(env, "profiling"))
+        EnableChannel(JitSpew_Profiling);
+    if (ContainsFlag(env, "trackopts"))
+        EnableChannel(JitSpew_OptimizationTracking);
+    if (ContainsFlag(env, "dump-mir-expr"))
+        EnableChannel(JitSpew_MIRExpressions);
+    if (ContainsFlag(env, "all"))
+        LoggingBits = uint64_t(-1);
+
+    if (ContainsFlag(env, "bl-aborts"))
+        EnableChannel(JitSpew_BaselineAbort);
+    if (ContainsFlag(env, "bl-scripts"))
+        EnableChannel(JitSpew_BaselineScripts);
+    if (ContainsFlag(env, "bl-op"))
+        EnableChannel(JitSpew_BaselineOp);
+    if (ContainsFlag(env, "bl-ic"))
+        EnableChannel(JitSpew_BaselineIC);
+    if (ContainsFlag(env, "bl-ic-fb"))
+        EnableChannel(JitSpew_BaselineICFallback);
+    if (ContainsFlag(env, "bl-osr"))
+        EnableChannel(JitSpew_BaselineOSR);
+    if (ContainsFlag(env, "bl-bails"))
+        EnableChannel(JitSpew_BaselineBailouts);
+    if (ContainsFlag(env, "bl-dbg-osr"))
+        EnableChannel(JitSpew_BaselineDebugModeOSR);
+    if (ContainsFlag(env, "bl-all")) {
+        EnableChannel(JitSpew_BaselineAbort);
+        EnableChannel(JitSpew_BaselineScripts);
+        EnableChannel(JitSpew_BaselineOp);
+        EnableChannel(JitSpew_BaselineIC);
+        EnableChannel(JitSpew_BaselineICFallback);
+        EnableChannel(JitSpew_BaselineOSR);
+        EnableChannel(JitSpew_BaselineBailouts);
+        EnableChannel(JitSpew_BaselineDebugModeOSR);
+    }
+
+    JitSpewPrinter().init(stderr);
+}
+
+JitSpewIndent::JitSpewIndent(JitSpewChannel channel)
+  : channel_(channel)
+{
+    ChannelIndentLevel[channel]++;
+}
+
+JitSpewIndent::~JitSpewIndent()
+{
+    ChannelIndentLevel[channel_]--;
+}
+
+void
+jit::JitSpewStartVA(JitSpewChannel channel, const char* fmt, va_list ap)
+{
+    if (!JitSpewEnabled(channel))
+        return;
+
+    JitSpewHeader(channel);
+    Fprinter& out = JitSpewPrinter();
+    out.vprintf(fmt, ap);
+}
+
+void
+jit::JitSpewContVA(JitSpewChannel channel, const char* fmt, va_list ap)
+{
+    if (!JitSpewEnabled(channel))
+        return;
+
+    Fprinter& out = JitSpewPrinter();
+    out.vprintf(fmt, ap);
+}
+
+void
+jit::JitSpewFin(JitSpewChannel channel)
+{
+    if (!JitSpewEnabled(channel))
+        return;
+
+    Fprinter& out = JitSpewPrinter();
+    out.put("\n");
+}
+
+void
+jit::JitSpewVA(JitSpewChannel channel, const char* fmt, va_list ap)
+{
+    JitSpewStartVA(channel, fmt, ap);
+    JitSpewFin(channel);
+}
+
+void
+jit::JitSpew(JitSpewChannel channel, const char* fmt, ...)
+{
+    va_list ap;
+    va_start(ap, fmt);
+    JitSpewVA(channel, fmt, ap);
+    va_end(ap);
+}
+
+void
+jit::JitSpewDef(JitSpewChannel channel, const char* str, MDefinition* def)
+{
+    if (!JitSpewEnabled(channel))
+        return;
+
+    JitSpewHeader(channel);
+    Fprinter& out = JitSpewPrinter();
+    out.put(str);
+    def->dump(out);
+    def->dumpLocation(out);
+}
+
+void
+jit::JitSpewStart(JitSpewChannel channel, const char* fmt, ...)
+{
+    va_list ap;
+    va_start(ap, fmt);
+    JitSpewStartVA(channel, fmt, ap);
+    va_end(ap);
+}
+void
+jit::JitSpewCont(JitSpewChannel channel, const char* fmt, ...)
+{
+    va_list ap;
+    va_start(ap, fmt);
+    JitSpewContVA(channel, fmt, ap);
+    va_end(ap);
+}
+
+void
+jit::JitSpewHeader(JitSpewChannel channel)
+{
+    if (!JitSpewEnabled(channel))
+        return;
+
+    Fprinter& out = JitSpewPrinter();
+    out.printf("[%s] ", ChannelNames[channel]);
+    for (size_t i = ChannelIndentLevel[channel]; i != 0; i--)
+        out.put("  ");
+}
+
+bool
+jit::JitSpewEnabled(JitSpewChannel channel)
+{
+    MOZ_ASSERT(LoggingChecked);
+    return (LoggingBits & (uint64_t(1) << uint32_t(channel))) && !filteredOutCompilations;
+}
+
+void
+jit::EnableChannel(JitSpewChannel channel)
+{
+    MOZ_ASSERT(LoggingChecked);
+    LoggingBits |= uint64_t(1) << uint32_t(channel);
+}
+
+void
+jit::DisableChannel(JitSpewChannel channel)
+{
+    MOZ_ASSERT(LoggingChecked);
+    LoggingBits &= ~(uint64_t(1) << uint32_t(channel));
+}
+
+#endif /* JS_JITSPEW */
+