The Tor Browser: js/src/vm/TraceLogging.cpp@129ffea94266 (annotated)

js/src/vm/TraceLogging.cpp@129ffea94266 (annotated)

js/src/vm/TraceLogging.cpp

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 /* -*- 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/. */
 #include "vm/TraceLogging.h"
 #include "mozilla/DebugOnly.h"
 #include <string.h>
 #include "jsapi.h"
 #include "jsscript.h"
 #include "jit/CompileWrappers.h"
 #include "vm/Runtime.h"
 using namespace js;
 #ifndef TRACE_LOG_DIR
 # if defined(_WIN32)
 #  define TRACE_LOG_DIR ""
 # else
 #  define TRACE_LOG_DIR "/tmp/"
 # endif
 #endif
 #if defined(__i386__)
 static __inline__ uint64_t
 rdtsc(void)
 {
     uint64_t x;
     __asm__ volatile (".byte 0x0f, 0x31" : "=A" (x));
     return x;
 }
 #elif defined(__x86_64__)
 static __inline__ uint64_t
 rdtsc(void)
 {
     unsigned hi, lo;
     __asm__ __volatile__ ("rdtsc" : "=a"(lo), "=d"(hi));
     return ( (uint64_t)lo)|( ((uint64_t)hi)<<32 );
 }
 #elif defined(__powerpc__)
 static __inline__ uint64_t
 rdtsc(void)
 {
     uint64_t result=0;
     uint32_t upper, lower,tmp;
     __asm__ volatile(
             "0:                  \n"
             "\tmftbu   %0           \n"
             "\tmftb    %1           \n"
             "\tmftbu   %2           \n"
             "\tcmpw    %2,%0        \n"
             "\tbne     0b         \n"
             : "=r"(upper),"=r"(lower),"=r"(tmp)
             );
     result = upper;
     result = result<<32;
     result = result|lower;
     return result;
 }
 #endif
 TraceLogging traceLoggers;
 static const char* const text[] =
 {
     "TraceLogger failed to process text",
 #define NAME(x) #x,
     TRACELOGGER_TEXT_ID_LIST(NAME)
 #undef NAME
 };
 TraceLogger::TraceLogger()
  : enabled(false),
    enabledTimes(0),
    failed(false),
    nextTextId(0),
    treeOffset(0),
    top(nullptr)
 { }
 bool
 TraceLogger::init(uint32_t loggerId)
 {
     if (!pointerMap.init())
         return false;
     if (!tree.init())
         return false;
     if (!stack.init())
         return false;
     if (!events.init())
         return false;
     MOZ_ASSERT(loggerId <= 999);
     char dictFilename[sizeof TRACE_LOG_DIR "tl-dict.100.json"];
     sprintf(dictFilename, TRACE_LOG_DIR "tl-dict.%d.json", loggerId);
     dictFile = fopen(dictFilename, "w");
     if (!dictFile)
         return false;
     char treeFilename[sizeof TRACE_LOG_DIR "tl-tree.100.tl"];
     sprintf(treeFilename, TRACE_LOG_DIR "tl-tree.%d.tl", loggerId);
     treeFile = fopen(treeFilename, "wb");
     if (!treeFile) {
         fclose(dictFile);
         dictFile = nullptr;
         return false;
     }
     char eventFilename[sizeof TRACE_LOG_DIR "tl-event.100.tl"];
     sprintf(eventFilename, TRACE_LOG_DIR "tl-event.%d.tl", loggerId);
     eventFile = fopen(eventFilename, "wb");
     if (!eventFile) {
         fclose(dictFile);
         fclose(treeFile);
         dictFile = nullptr;
         treeFile = nullptr;
         return false;
     }
     uint64_t start = rdtsc() - traceLoggers.startupTime;
     TreeEntry &treeEntry = tree.pushUninitialized();
     treeEntry.setStart(start);
     treeEntry.setStop(0);
     treeEntry.setTextId(0);
     treeEntry.setHasChildren(false);
     treeEntry.setNextId(0);
     StackEntry &stackEntry = stack.pushUninitialized();
     stackEntry.setTreeId(0);
     stackEntry.setLastChildId(0);
     stackEntry.setActive(true);
     int written = fprintf(dictFile, "[");
     if (written < 0)
         fprintf(stderr, "TraceLogging: Error while writing.\n");
     // Eagerly create the default textIds, to match their Tracelogger::TextId.
     for (uint32_t i = 0; i < LAST; i++) {
         mozilla::DebugOnly<uint32_t> textId = createTextId(text[i]);
         MOZ_ASSERT(textId == i);
     }
     enabled = true;
     enabledTimes = 1;
     return true;
 }
 bool
 TraceLogger::enable()
 {
     if (enabled) {
         enabledTimes++;
         return true;
     }
     if (failed)
         return false;
     if (!tree.ensureSpaceBeforeAdd(stack.size())) {
         if (!flush()) {
             fprintf(stderr, "TraceLogging: Couldn't write the data to disk.\n");
             failed = true;
             return false;
         }
         if (!tree.ensureSpaceBeforeAdd(stack.size())) {
             fprintf(stderr, "TraceLogging: Couldn't reserve enough space.\n");
             failed = true;
             return false;
         }
     }
     uint64_t start = rdtsc() - traceLoggers.startupTime;
     StackEntry *parent = &stack[0];
     for (uint32_t i = 1; i < stack.size(); i++) {
         if (!traceLoggers.isTextIdEnabled(stack[i].textId()))
             continue;
 #ifdef DEBUG
         TreeEntry entry;
         if (!getTreeEntry(parent->treeId(), &entry))
             return false;
 #endif
         if (parent->lastChildId() == 0) {
             MOZ_ASSERT(!entry.hasChildren());
             MOZ_ASSERT(parent->treeId() == tree.currentId() + treeOffset);
             if (!updateHasChildren(parent->treeId())) {
                 fprintf(stderr, "TraceLogging: Couldn't update an entry.\n");
                 failed = true;
                 return false;
             }
         } else {
             MOZ_ASSERT(entry.hasChildren() == 1);
             if (!updateNextId(parent->lastChildId(), tree.nextId() + treeOffset)) {
                 fprintf(stderr, "TraceLogging: Couldn't update an entry.\n");
                 failed = true;
                 return false;
             }
         }
         TreeEntry &treeEntry = tree.pushUninitialized();
         treeEntry.setStart(start);
         treeEntry.setStop(0);
         treeEntry.setTextId(stack[i].textId());
         treeEntry.setHasChildren(false);
         treeEntry.setNextId(0);
         stack[i].setActive(true);
         stack[i].setTreeId(tree.currentId() + treeOffset);
         parent->setLastChildId(tree.currentId() + treeOffset);
         parent = &stack[i];
     }
     enabled = true;
     enabledTimes = 1;
     return true;
 }
 bool
 TraceLogger::disable()
 {
     if (failed)
         return false;
     if (!enabled)
         return true;
     if (enabledTimes > 1) {
         enabledTimes--;
         return true;
     }
     uint64_t stop = rdtsc() - traceLoggers.startupTime;
     for (uint32_t i = 1; i < stack.size(); i++) {
         if (!stack[i].active())
             continue;
         if (!updateStop(stack[i].treeId(), stop)) {
             fprintf(stderr, "TraceLogging: Failed to stop an event.\n");
             failed = true;
             enabled = false;
             return false;
         }
         stack[i].setActive(false);
     }
     enabled = false;
     enabledTimes = 0;
     return true;
 }
 bool
 TraceLogger::flush()
 {
     MOZ_ASSERT(!failed);
     if (treeFile) {
         // Format data in big endian.
         for (size_t i = 0; i < tree.size(); i++)
             entryToBigEndian(&tree[i]);
         int success = fseek(treeFile, 0, SEEK_END);
         if (success != 0)
             return false;
         size_t bytesWritten = fwrite(tree.data(), sizeof(TreeEntry), tree.size(), treeFile);
         if (bytesWritten < tree.size())
             return false;
         treeOffset += tree.currentId();
         tree.clear();
     }
     if (eventFile) {
         // Format data in big endian
         for (size_t i = 0; i < events.size(); i++) {
             events[i].time = htobe64(events[i].time);
             events[i].textId = htobe64(events[i].textId);
         }
         size_t bytesWritten = fwrite(events.data(), sizeof(EventEntry), events.size(), eventFile);
         if (bytesWritten < events.size())
             return false;
         events.clear();
     }
     return true;
 }
 TraceLogger::~TraceLogger()
 {
     // Write dictionary to disk
     if (dictFile) {
         int written = fprintf(dictFile, "]");
         if (written < 0)
             fprintf(stderr, "TraceLogging: Error while writing.\n");
         fclose(dictFile);
         dictFile = nullptr;
     }
     if (!failed && treeFile) {
         // Make sure every start entry has a corresponding stop value.
         // We temporary enable logging for this. Stop doesn't need any extra data,
         // so is safe to do, even when we encountered OOM.
         enabled = true;
         while (stack.size() > 0)
             stopEvent();
         enabled = false;
     }
     if (!failed && !flush()) {
         fprintf(stderr, "TraceLogging: Couldn't write the data to disk.\n");
         enabled = false;
         failed = true;
     }
     if (treeFile) {
         fclose(treeFile);
         treeFile = nullptr;
     }
     if (eventFile) {
         fclose(eventFile);
         eventFile = nullptr;
     }
 }
 uint32_t
 TraceLogger::createTextId(const char *text)
 {
     assertNoQuotes(text);
     PointerHashMap::AddPtr p = pointerMap.lookupForAdd((const void *)text);
     if (p)
         return p->value();
     uint32_t textId = nextTextId++;
     if (!pointerMap.add(p, text, textId))
         return TraceLogger::TL_Error;
     int written;
     if (textId > 0)
         written = fprintf(dictFile, ",\n\"%s\"", text);
     else
         written = fprintf(dictFile, "\"%s\"", text);
     if (written < 0)
         return TraceLogger::TL_Error;
     return textId;
 }
 uint32_t
 TraceLogger::createTextId(JSScript *script)
 {
     assertNoQuotes(script->filename());
     PointerHashMap::AddPtr p = pointerMap.lookupForAdd(script);
     if (p)
         return p->value();
     uint32_t textId = nextTextId++;
     if (!pointerMap.add(p, script, textId))
         return TraceLogger::TL_Error;
     int written;
     if (textId > 0) {
         written = fprintf(dictFile, ",\n\"script %s:%d:%d\"", script->filename(),
                           script->lineno(), script->column());
     } else {
         written = fprintf(dictFile, "\"script %s:%d:%d\"", script->filename(),
                           script->lineno(), script->column());
     }
     if (written < 0)
         return TraceLogger::TL_Error;
     return textId;
 }
 uint32_t
 TraceLogger::createTextId(const JS::ReadOnlyCompileOptions &compileOptions)
 {
     assertNoQuotes(compileOptions.filename());
     PointerHashMap::AddPtr p = pointerMap.lookupForAdd(&compileOptions);
     if (p)
         return p->value();
     uint32_t textId = nextTextId++;
     if (!pointerMap.add(p, &compileOptions, textId))
         return TraceLogger::TL_Error;
     int written;
     if (textId > 0) {
         written = fprintf(dictFile, ",\n\"script %s:%d:%d\"", compileOptions.filename(),
                           compileOptions.lineno, compileOptions.column);
     } else {
         written = fprintf(dictFile, "\"script %s:%d:%d\"", compileOptions.filename(),
                           compileOptions.lineno, compileOptions.column);
     }
     if (written < 0)
         return TraceLogger::TL_Error;
     return textId;
 }
 void
 TraceLogger::logTimestamp(uint32_t id)
 {
     if (!enabled)
         return;
     if (!events.ensureSpaceBeforeAdd()) {
         fprintf(stderr, "TraceLogging: Disabled a tracelogger due to OOM.\n");
         enabled = false;
         return;
     }
     uint64_t time = rdtsc() - traceLoggers.startupTime;
     EventEntry &entry = events.pushUninitialized();
     entry.time = time;
     entry.textId = id;
 }
 void
 TraceLogger::entryToBigEndian(TreeEntry *entry)
 {
     entry->start_ = htobe64(entry->start_);
     entry->stop_ = htobe64(entry->stop_);
     entry->u.value_ = htobe32((entry->u.s.textId_ << 1) + entry->u.s.hasChildren_);
     entry->nextId_ = htobe32(entry->nextId_);
 }
 void
 TraceLogger::entryToSystemEndian(TreeEntry *entry)
 {
     entry->start_ = be64toh(entry->start_);
     entry->stop_ = be64toh(entry->stop_);
     uint32_t data = be32toh(entry->u.value_);
     entry->u.s.textId_ = data >> 1;
     entry->u.s.hasChildren_ = data & 0x1;
     entry->nextId_ = be32toh(entry->nextId_);
 }
 bool
 TraceLogger::getTreeEntry(uint32_t treeId, TreeEntry *entry)
 {
     // Entry is still in memory
     if (treeId >= treeOffset) {
         *entry = tree[treeId];
         return true;
     }
     int success = fseek(treeFile, treeId * sizeof(TreeEntry), SEEK_SET);
     if (success != 0)
         return false;
     size_t itemsRead = fread((void *)entry, sizeof(TreeEntry), 1, treeFile);
     if (itemsRead < 1)
         return false;
     entryToSystemEndian(entry);
     return true;
 }
 bool
 TraceLogger::saveTreeEntry(uint32_t treeId, TreeEntry *entry)
 {
     int success = fseek(treeFile, treeId * sizeof(TreeEntry), SEEK_SET);
     if (success != 0)
         return false;
     entryToBigEndian(entry);
     size_t itemsWritten = fwrite(entry, sizeof(TreeEntry), 1, treeFile);
     if (itemsWritten < 1)
         return false;
     return true;
 }
 bool
 TraceLogger::updateHasChildren(uint32_t treeId, bool hasChildren)
 {
     if (treeId < treeOffset) {
         TreeEntry entry;
         if (!getTreeEntry(treeId, &entry))
             return false;
         entry.setHasChildren(hasChildren);
         if (!saveTreeEntry(treeId, &entry))
             return false;
         return true;
     }
     tree[treeId - treeOffset].setHasChildren(hasChildren);
     return true;
 }
 bool
 TraceLogger::updateNextId(uint32_t treeId, uint32_t nextId)
 {
     if (treeId < treeOffset) {
         TreeEntry entry;
         if (!getTreeEntry(treeId, &entry))
             return false;
         entry.setNextId(nextId);
         if (!saveTreeEntry(treeId, &entry))
             return false;
         return true;
     }
     tree[treeId - treeOffset].setNextId(nextId);
     return true;
 }
 bool
 TraceLogger::updateStop(uint32_t treeId, uint64_t timestamp)
 {
     if (treeId < treeOffset) {
         TreeEntry entry;
         if (!getTreeEntry(treeId, &entry))
             return false;
         entry.setStop(timestamp);
         if (!saveTreeEntry(treeId, &entry))
             return false;
         return true;
     }
     tree[treeId - treeOffset].setStop(timestamp);
     return true;
 }
 void
 TraceLogger::startEvent(uint32_t id)
 {
     if (failed)
         return;
     if (!stack.ensureSpaceBeforeAdd()) {
         fprintf(stderr, "TraceLogging: Failed to allocate space to keep track of the stack.\n");
         enabled = false;
         failed = true;
         return;
     }
     if (!enabled) {
         StackEntry &stackEntry = stack.pushUninitialized();
         stackEntry.setTreeId(tree.currentId() + treeOffset);
         stackEntry.setLastChildId(0);
         stackEntry.setTextId(id);
         stackEntry.setActive(false);
         return;
     }
     if (!tree.ensureSpaceBeforeAdd()) {
         uint64_t start = rdtsc() - traceLoggers.startupTime;
         if (!flush()) {
             fprintf(stderr, "TraceLogging: Couldn't write the data to disk.\n");
             enabled = false;
             failed = true;
             return;
         }
         // Log the time it took to flush the events as being from the
         // Tracelogger.
         if (!startEvent(TraceLogger::TL, start)) {
             fprintf(stderr, "TraceLogging: Failed to start an event.\n");
             enabled = false;
             failed = true;
             return;
         }
         stopEvent();
     }
     uint64_t start = rdtsc() - traceLoggers.startupTime;
     if (!startEvent(id, start)) {
         fprintf(stderr, "TraceLogging: Failed to start an event.\n");
         enabled = false;
         failed = true;
         return;
     }
 }
 TraceLogger::StackEntry &
 TraceLogger::getActiveAncestor()
 {
     uint32_t parentId = stack.currentId();
     while (!stack[parentId].active())
         parentId--;
     return stack[parentId];
 }
 bool
 TraceLogger::startEvent(uint32_t id, uint64_t timestamp)
 {
     // When a textId is disabled, a stack entry still needs to be pushed,
     // together with an annotation that nothing needs to get done when receiving
     // the stop event.
     if (!traceLoggers.isTextIdEnabled(id)) {
         StackEntry &stackEntry = stack.pushUninitialized();
         stackEntry.setActive(false);
         return true;
     }
     // Patch up the tree to be correct. There are two scenarios:
     // 1) Parent has no children yet. So update parent to include children.
     // 2) Parent has already children. Update last child to link to the new
     //    child.
     StackEntry &parent = getActiveAncestor();
 #ifdef DEBUG
     TreeEntry entry;
     if (!getTreeEntry(parent.treeId(), &entry))
         return false;
 #endif
     if (parent.lastChildId() == 0) {
         MOZ_ASSERT(!entry.hasChildren());
         MOZ_ASSERT(parent.treeId() == tree.currentId() + treeOffset);
         if (!updateHasChildren(parent.treeId()))
             return false;
     } else {
         MOZ_ASSERT(entry.hasChildren());
         if (!updateNextId(parent.lastChildId(), tree.nextId() + treeOffset))
             return false;
     }
     // Add a new tree entry.
     TreeEntry &treeEntry = tree.pushUninitialized();
     treeEntry.setStart(timestamp);
     treeEntry.setStop(0);
     treeEntry.setTextId(id);
     treeEntry.setHasChildren(false);
     treeEntry.setNextId(0);
     // Add a new stack entry.
     StackEntry &stackEntry = stack.pushUninitialized();
     stackEntry.setTreeId(tree.currentId() + treeOffset);
     stackEntry.setLastChildId(0);
     stackEntry.setActive(true);
     // Set the last child of the parent to this newly added entry.
     parent.setLastChildId(tree.currentId() + treeOffset);
     return true;
 }
 void
 TraceLogger::stopEvent(uint32_t id)
 {
 #ifdef DEBUG
     TreeEntry entry;
     MOZ_ASSERT_IF(stack.current().active(), getTreeEntry(stack.current().treeId(), &entry));
     MOZ_ASSERT_IF(stack.current().active(), entry.textId() == id);
 #endif
     stopEvent();
 }
 void
 TraceLogger::stopEvent()
 {
     if (enabled && stack.current().active()) {
         uint64_t stop = rdtsc() - traceLoggers.startupTime;
         if (!updateStop(stack.current().treeId(), stop)) {
             fprintf(stderr, "TraceLogging: Failed to stop an event.\n");
             enabled = false;
             failed = true;
             return;
         }
     }
     stack.pop();
 }
 TraceLogging::TraceLogging()
 {
     initialized = false;
     enabled = false;
     mainThreadEnabled = true;
     offThreadEnabled = true;
     loggerId = 0;
 #ifdef JS_THREADSAFE
     lock = PR_NewLock();
     if (!lock)
         MOZ_CRASH();
 #endif // JS_THREADSAFE
 }
 TraceLogging::~TraceLogging()
 {
     if (out) {
         fprintf(out, "]");
         fclose(out);
         out = nullptr;
     }
     for (size_t i = 0; i < mainThreadLoggers.length(); i++)
         delete mainThreadLoggers[i];
     mainThreadLoggers.clear();
 #ifdef JS_THREADSAFE
     if (threadLoggers.initialized()) {
         for (ThreadLoggerHashMap::Range r = threadLoggers.all(); !r.empty(); r.popFront())
             delete r.front().value();
         threadLoggers.finish();
     }
     if (lock) {
         PR_DestroyLock(lock);
         lock = nullptr;
     }
 #endif // JS_THREADSAFE
     enabled = false;
 }
 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;
 }
 bool
 TraceLogging::lazyInit()
 {
     if (initialized)
         return enabled;
     initialized = true;
     out = fopen(TRACE_LOG_DIR "tl-data.json", "w");
     if (!out)
         return false;
     fprintf(out, "[");
 #ifdef JS_THREADSAFE
     if (!threadLoggers.init())
         return false;
 #endif // JS_THREADSAFE
     const char *env = getenv("TLLOG");
     if (!env)
         env = "";
     if (strstr(env, "help")) {
         fflush(nullptr);
         printf(
             "\n"
             "usage: TLLOG=option,option,option,... where options can be:\n"
             "\n"
             "Collections:\n"
             "  Default        Output all default\n"
             "  IonCompiler    Output all information about compilation\n"
             "\n"
             "Specific log items:\n"
         );
         for (uint32_t i = 1; i < TraceLogger::LAST; i++) {
             printf("  %s\n", text[i]);
         }
         printf("\n");
         exit(0);
         /*NOTREACHED*/
     }
     for (uint32_t i = 1; i < TraceLogger::LAST; i++)
         enabledTextIds[i] = ContainsFlag(env, text[i]);
     enabledTextIds[TraceLogger::TL_Error] = true;
     enabledTextIds[TraceLogger::TL] = true;
     if (ContainsFlag(env, "Default") || strlen(env) == 0) {
         enabledTextIds[TraceLogger::Bailout] = true;
         enabledTextIds[TraceLogger::Baseline] = true;
         enabledTextIds[TraceLogger::BaselineCompilation] = true;
         enabledTextIds[TraceLogger::GC] = true;
         enabledTextIds[TraceLogger::GCAllocation] = true;
         enabledTextIds[TraceLogger::GCSweeping] = true;
         enabledTextIds[TraceLogger::Interpreter] = true;
         enabledTextIds[TraceLogger::IonCompilation] = true;
         enabledTextIds[TraceLogger::IonLinking] = true;
         enabledTextIds[TraceLogger::IonMonkey] = true;
         enabledTextIds[TraceLogger::MinorGC] = true;
         enabledTextIds[TraceLogger::ParserCompileFunction] = true;
         enabledTextIds[TraceLogger::ParserCompileLazy] = true;
         enabledTextIds[TraceLogger::ParserCompileScript] = true;
         enabledTextIds[TraceLogger::YarrCompile] = true;
         enabledTextIds[TraceLogger::YarrInterpret] = true;
         enabledTextIds[TraceLogger::YarrJIT] = true;
     }
     if (ContainsFlag(env, "IonCompiler") || strlen(env) == 0) {
         enabledTextIds[TraceLogger::IonCompilation] = true;
         enabledTextIds[TraceLogger::IonLinking] = true;
         enabledTextIds[TraceLogger::SplitCriticalEdges] = true;
         enabledTextIds[TraceLogger::RenumberBlocks] = true;
         enabledTextIds[TraceLogger::DominatorTree] = true;
         enabledTextIds[TraceLogger::PhiAnalysis] = true;
         enabledTextIds[TraceLogger::ApplyTypes] = true;
         enabledTextIds[TraceLogger::ParallelSafetyAnalysis] = true;
         enabledTextIds[TraceLogger::AliasAnalysis] = true;
         enabledTextIds[TraceLogger::GVN] = true;
         enabledTextIds[TraceLogger::UCE] = true;
         enabledTextIds[TraceLogger::LICM] = true;
         enabledTextIds[TraceLogger::RangeAnalysis] = true;
         enabledTextIds[TraceLogger::EffectiveAddressAnalysis] = true;
         enabledTextIds[TraceLogger::EliminateDeadCode] = true;
         enabledTextIds[TraceLogger::EdgeCaseAnalysis] = true;
         enabledTextIds[TraceLogger::EliminateRedundantChecks] = true;
     }
     const char *options = getenv("TLOPTIONS");
     if (options) {
         if (strstr(options, "help")) {
             fflush(nullptr);
             printf(
                 "\n"
                 "usage: TLOPTIONS=option,option,option,... where options can be:\n"
                 "\n"
                 "  DisableMainThread        Don't start logging the mainThread automatically.\n"
                 "  DisableOffThread         Don't start logging the off mainThread automatically.\n"
             );
             printf("\n");
             exit(0);
             /*NOTREACHED*/
         }
         if (strstr(options, "DisableMainThread"))
            mainThreadEnabled = false;
         if (strstr(options, "DisableOffThread"))
            offThreadEnabled = false;
     }
     startupTime = rdtsc();
     enabled = true;
     return true;
 }
 TraceLogger *
 js::TraceLoggerForMainThread(jit::CompileRuntime *runtime)
 {
     return traceLoggers.forMainThread(runtime);
 }
 TraceLogger *
 TraceLogging::forMainThread(jit::CompileRuntime *runtime)
 {
     return forMainThread(runtime->mainThread());
 }
 TraceLogger *
 js::TraceLoggerForMainThread(JSRuntime *runtime)
 {
     return traceLoggers.forMainThread(runtime);
 }
 TraceLogger *
 TraceLogging::forMainThread(JSRuntime *runtime)
 {
     return forMainThread(&runtime->mainThread);
 }
 TraceLogger *
 TraceLogging::forMainThread(PerThreadData *mainThread)
 {
     if (!mainThread->traceLogger) {
         AutoTraceLoggingLock lock(this);
         if (!lazyInit())
             return nullptr;
         TraceLogger *logger = create();
         mainThread->traceLogger = logger;
         if (!mainThreadLoggers.append(logger))
             return nullptr;
         if (!mainThreadEnabled)
             logger->disable();
     }
     return mainThread->traceLogger;
 }
 TraceLogger *
 js::TraceLoggerForCurrentThread()
 {
 #ifdef JS_THREADSAFE
     PRThread *thread = PR_GetCurrentThread();
     return traceLoggers.forThread(thread);
 #else
     MOZ_ASSUME_UNREACHABLE("No threads supported. Use TraceLoggerForMainThread for the main thread.");
 #endif // JS_THREADSAFE
 }
 #ifdef JS_THREADSAFE
 TraceLogger *
 TraceLogging::forThread(PRThread *thread)
 {
     AutoTraceLoggingLock lock(this);
     if (!lazyInit())
         return nullptr;
     ThreadLoggerHashMap::AddPtr p = threadLoggers.lookupForAdd(thread);
     if (p)
         return p->value();
     TraceLogger *logger = create();
     if (!logger)
         return nullptr;
     if (!threadLoggers.add(p, thread, logger)) {
         delete logger;
         return nullptr;
     }
     if (!offThreadEnabled)
         logger->disable();
     return logger;
 }
 #endif // JS_THREADSAFE
 TraceLogger *
 TraceLogging::create()
 {
     if (loggerId > 999) {
         fprintf(stderr, "TraceLogging: Can't create more than 999 different loggers.");
         return nullptr;
     }
     if (loggerId > 0) {
         int written = fprintf(out, ",\n");
         if (written < 0)
             fprintf(stderr, "TraceLogging: Error while writing.\n");
     }
     loggerId++;
     int written = fprintf(out, "{\"tree\":\"tl-tree.%d.tl\", \"events\":\"tl-event.%d.tl\", \"dict\":\"tl-dict.%d.json\", \"treeFormat\":\"64,64,31,1,32\"}",
                           loggerId, loggerId, loggerId);
     if (written < 0)
         fprintf(stderr, "TraceLogging: Error while writing.\n");
     TraceLogger *logger = new TraceLogger();
     if (!logger)
         return nullptr;
     if (!logger->init(loggerId)) {
         delete logger;
         return nullptr;
     }
     return logger;
 }
 bool
 js::TraceLogTextIdEnabled(uint32_t textId)
 {
     return traceLoggers.isTextIdEnabled(textId);
 }

The Tor Browser / annotate

js/src/vm/TraceLogging.cpp@129ffea94266 (annotated)

js/src/vm/TraceLogging.cpp