From 2b957ee9722769b66b294b6630e2cb8b0bed9318 Mon Sep 17 00:00:00 2001 From: milisarge Date: Mon, 26 Jun 2017 19:09:20 +0300 Subject: [PATCH] js38.paketlendi --- talimatname/genel/js38/mozjs38-1269317.patch | 122 ++++ .../genel/js38/mozjs38-add-bracket.patch | 16 + .../genel/js38/mozjs38-copy-headers.patch | 20 + .../genel/js38/mozjs38-fix-tracelogger.patch | 603 ++++++++++++++++++ .../genel/js38/mozjs38-install-name.patch | 11 + .../js38/mozjs38-pkg-config-version.patch | 22 + .../genel/js38/mozjs38-shell-version.patch | 65 ++ talimatname/genel/js38/talimat | 41 ++ 8 files changed, 900 insertions(+) create mode 100644 talimatname/genel/js38/mozjs38-1269317.patch create mode 100644 talimatname/genel/js38/mozjs38-add-bracket.patch create mode 100644 talimatname/genel/js38/mozjs38-copy-headers.patch create mode 100644 talimatname/genel/js38/mozjs38-fix-tracelogger.patch create mode 100644 talimatname/genel/js38/mozjs38-install-name.patch create mode 100644 talimatname/genel/js38/mozjs38-pkg-config-version.patch create mode 100644 talimatname/genel/js38/mozjs38-shell-version.patch create mode 100644 talimatname/genel/js38/talimat diff --git a/talimatname/genel/js38/mozjs38-1269317.patch b/talimatname/genel/js38/mozjs38-1269317.patch new file mode 100644 index 000000000..a3a57d544 --- /dev/null +++ b/talimatname/genel/js38/mozjs38-1269317.patch @@ -0,0 +1,122 @@ +--- a/js/src/jit/RegisterSets.h 2017-02-10 17:33:06.210702431 -0800 ++++ b/js/src/jit/RegisterSets.h 2017-02-10 17:43:52.877514146 -0800 +@@ -7,7 +7,6 @@ + #ifndef jit_RegisterSets_h + #define jit_RegisterSets_h + +-#include "mozilla/Alignment.h" + #include "mozilla/MathAlgorithms.h" + + #include "jit/JitAllocPolicy.h" +@@ -26,8 +25,8 @@ + Code code_; + + public: +- AnyRegister() +- { } ++ AnyRegister() = default; ++ + explicit AnyRegister(Register gpr) { + code_ = gpr.code(); + } +@@ -156,7 +155,7 @@ + } + #endif + +- ValueOperand() {} ++ ValueOperand() = default; + }; + + // Registers to hold either either a typed or untyped value. +@@ -165,46 +164,25 @@ + // Type of value being stored. + MIRType type_; + +- // Space to hold either an AnyRegister or a ValueOperand. + union U { +- mozilla::AlignedStorage2 typed; +- mozilla::AlignedStorage2 value; ++ AnyRegister typed; ++ ValueOperand value; + } data; + +- AnyRegister& dataTyped() { +- MOZ_ASSERT(hasTyped()); +- return *data.typed.addr(); +- } +- ValueOperand& dataValue() { +- MOZ_ASSERT(hasValue()); +- return *data.value.addr(); +- } +- +- AnyRegister dataTyped() const { +- MOZ_ASSERT(hasTyped()); +- return *data.typed.addr(); +- } +- const ValueOperand& dataValue() const { +- MOZ_ASSERT(hasValue()); +- return *data.value.addr(); +- } +- + public: + +- TypedOrValueRegister() +- : type_(MIRType_None) +- {} ++ TypedOrValueRegister() = default; + + TypedOrValueRegister(MIRType type, AnyRegister reg) + : type_(type) + { +- dataTyped() = reg; ++ data.typed = reg; + } + + MOZ_IMPLICIT TypedOrValueRegister(ValueOperand value) + : type_(MIRType_Value) + { +- dataValue() = value; ++ data.value = value; + } + + MIRType type() const { +@@ -220,11 +198,13 @@ + } + + AnyRegister typedReg() const { +- return dataTyped(); ++ MOZ_ASSERT(hasTyped()); ++ return data.typed; + } + + ValueOperand valueReg() const { +- return dataValue(); ++ MOZ_ASSERT(hasValue()); ++ return data.value; + } + + AnyRegister scratchReg() { +@@ -240,19 +220,18 @@ + // Whether a constant value is being stored. + bool constant_; + +- // Space to hold either a Value or a TypedOrValueRegister. + union U { +- mozilla::AlignedStorage2 constant; +- mozilla::AlignedStorage2 reg; ++ Value constant; ++ TypedOrValueRegister reg; + } data; + + Value& dataValue() { + MOZ_ASSERT(constant()); +- return *data.constant.addr(); ++ return data.constant; + } + TypedOrValueRegister& dataReg() { + MOZ_ASSERT(!constant()); +- return *data.reg.addr(); ++ return data.reg; + } + + public: diff --git a/talimatname/genel/js38/mozjs38-add-bracket.patch b/talimatname/genel/js38/mozjs38-add-bracket.patch new file mode 100644 index 000000000..873697d18 --- /dev/null +++ b/talimatname/genel/js38/mozjs38-add-bracket.patch @@ -0,0 +1,16 @@ +Add bracket for sed 4.3 compliance + +Based on upstream fix by Daniel Stenberg in 09 jan 2017 +See: https://hg.mozilla.org/mozilla-central/rev/ebcbf47a83e7 + +--- a/js/src/configure 2017-02-21 16:56:42.350105741 -0300 ++++ b/js/src/configure 2017-02-21 17:33:13.183493978 -0300 +@@ -15231,7 +15231,7 @@ + fi + fi + +- version=`sed -n 's/^[:space:]*#[[:space:]]*define[[:space:]][[:space:]]*U_ICU_VERSION_MAJOR_NUM[[:space:]][[:space:]]*\([0-9][0-9]*\)[[:space:]]*$/\1/p' "$icudir/common/unicode/uvernum.h"` ++ version=`sed -n 's/^[[:space:]]*#[[:space:]]*define[[:space:]][[:space:]]*U_ICU_VERSION_MAJOR_NUM[[:space:]][[:space:]]*\([0-9][0-9]*\)[[:space:]]*$/\1/p' "$icudir/common/unicode/uvernum.h"` + if test x"$version" = x; then + { echo "configure: error: cannot determine icu version number from uvernum.h header file $lineno" 1>&2; echo "configure: error: cannot determine icu version number from uvernum.h header file $lineno" 1>&5; exit 1; } + fi diff --git a/talimatname/genel/js38/mozjs38-copy-headers.patch b/talimatname/genel/js38/mozjs38-copy-headers.patch new file mode 100644 index 000000000..7f352a795 --- /dev/null +++ b/talimatname/genel/js38/mozjs38-copy-headers.patch @@ -0,0 +1,20 @@ +Description: Copy headers on install instead of symlinking +Author: Rico Tzschichholz +Forwarded: no +Last-Update: 2014-10-29 + +--- + +Index: b/python/mozbuild/mozbuild/backend/recursivemake.py +=================================================================== +--- a/python/mozbuild/mozbuild/backend/recursivemake.py ++++ b/python/mozbuild/mozbuild/backend/recursivemake.py +@@ -796,7 +796,7 @@ + return + + for source, dest, _ in self._walk_hierarchy(obj, exports): +- self._install_manifests['dist_include'].add_symlink(source, dest) ++ self._install_manifests['dist_include'].add_copy(source, dest) + + if not os.path.exists(source): + raise Exception('File listed in EXPORTS does not exist: %s' % source) diff --git a/talimatname/genel/js38/mozjs38-fix-tracelogger.patch b/talimatname/genel/js38/mozjs38-fix-tracelogger.patch new file mode 100644 index 000000000..6798d24a3 --- /dev/null +++ b/talimatname/genel/js38/mozjs38-fix-tracelogger.patch @@ -0,0 +1,603 @@ +# === Fix the SM38 tracelogger === +# This patch is a squashed version of several patches that were adapted +# to fix failing hunks. +# +# Applied in the following order, they are: +# * https://bugzilla.mozilla.org/show_bug.cgi?id=1223767 +# Assertion failure: i < size_, at js/src/vm/TraceLoggingTypes.h:210 +# Also fix stop-information to make reduce.py work correctly. +# * https://bugzilla.mozilla.org/show_bug.cgi?id=1227914 +# Limit the memory tracelogger can take. +# This causes tracelogger to flush data to the disk regularly and prevents out of +# memory issues if a lot of data gets logged. +# * https://bugzilla.mozilla.org/show_bug.cgi?id=1155618 +# Fix tracelogger destructor that touches possibly uninitialised hash table. +# * https://bugzilla.mozilla.org/show_bug.cgi?id=1223636 +# Don't treat extraTextId as containing only extra ids. +# This fixes an assertion failure: id == nextTextId at js/src/vm/TraceLoggingGraph.cpp +# * https://bugzilla.mozilla.org/show_bug.cgi?id=1227028 +# Fix when to keep the payload of a TraceLogger event. +# This fixes an assertion failure: textId < uint32_t(1 << 31) at js/src/vm/TraceLoggingGraph.h +# * https://bugzilla.mozilla.org/show_bug.cgi?id=1266649 +# Handle failing to add to pointermap gracefully. +# * https://bugzilla.mozilla.org/show_bug.cgi?id=1280648 +# Don't cache based on pointers to movable GC things. +# * https://bugzilla.mozilla.org/show_bug.cgi?id=1224123 +# Fix the use of LastEntryId in tracelogger.h. +# * https://bugzilla.mozilla.org/show_bug.cgi?id=1231170 +# Use size in debugger instead of the current id to track last logged item. +# * https://bugzilla.mozilla.org/show_bug.cgi?id=1221844 +# Move TraceLogger_Invalidation to LOG_ITEM. +# Add some debug checks to logTimestamp. +# * https://bugzilla.mozilla.org/show_bug.cgi?id=1255766 +# Also mark resizing of memory. +# * https://bugzilla.mozilla.org/show_bug.cgi?id=1259403 +# Only increase capacity by multiples of 2. +# Always make sure there are 3 free slots for events. +# === + +diff --git a/js/src/jit-test/tests/tracelogger/bug1231170.js b/js/src/jit-test/tests/tracelogger/bug1231170.js +new file mode 100644 +index 0000000..023e93e +--- /dev/null ++++ b/js/src/jit-test/tests/tracelogger/bug1231170.js +@@ -0,0 +1,3 @@ ++var du = new Debugger(); ++if (typeof du.drainTraceLogger === "function") ++ du.drainTraceLogger(); +diff --git a/js/src/jit-test/tests/tracelogger/bug1266649.js b/js/src/jit-test/tests/tracelogger/bug1266649.js +new file mode 100644 +index 0000000..81ae7ad +--- /dev/null ++++ b/js/src/jit-test/tests/tracelogger/bug1266649.js +@@ -0,0 +1,10 @@ ++ ++var du = new Debugger(); ++if (typeof du.setupTraceLogger === "function" && ++ typeof oomTest === 'function') ++{ ++ du.setupTraceLogger({ ++ Scripts: true ++ }) ++ oomTest(() => function(){}); ++} +diff --git a/js/src/jit/Ion.cpp b/js/src/jit/Ion.cpp +index 93e2fda..09049d6 100644 +--- a/js/src/jit/Ion.cpp ++++ b/js/src/jit/Ion.cpp +@@ -1055,6 +1055,8 @@ IonScript::Destroy(FreeOp* fop, IonScript* script) + + script->destroyCaches(); + script->unlinkFromRuntime(fop); ++ // Frees the potential event we have set. ++ script->traceLoggerScriptEvent_ = TraceLoggerEvent(); + fop->free_(script); + } + +diff --git a/js/src/vm/Debugger.cpp b/js/src/vm/Debugger.cpp +index 26262fd..af7f313 100644 +--- a/js/src/vm/Debugger.cpp ++++ b/js/src/vm/Debugger.cpp +@@ -369,10 +369,10 @@ Debugger::Debugger(JSContext* cx, NativeObject* dbg) + objects(cx), + environments(cx), + #ifdef NIGHTLY_BUILD +- traceLoggerLastDrainedId(0), ++ traceLoggerLastDrainedSize(0), + traceLoggerLastDrainedIteration(0), + #endif +- traceLoggerScriptedCallsLastDrainedId(0), ++ traceLoggerScriptedCallsLastDrainedSize(0), + traceLoggerScriptedCallsLastDrainedIteration(0) + { + assertSameCompartment(cx, dbg); +@@ -3907,9 +3907,9 @@ Debugger::drainTraceLogger(JSContext* cx, unsigned argc, Value* vp) + size_t num; + TraceLoggerThread* logger = TraceLoggerForMainThread(cx->runtime()); + bool lostEvents = logger->lostEvents(dbg->traceLoggerLastDrainedIteration, +- dbg->traceLoggerLastDrainedId); ++ dbg->traceLoggerLastDrainedSize); + EventEntry* events = logger->getEventsStartingAt(&dbg->traceLoggerLastDrainedIteration, +- &dbg->traceLoggerLastDrainedId, ++ &dbg->traceLoggerLastDrainedSize, + &num); + + RootedObject array(cx, NewDenseEmptyArray(cx)); +@@ -4002,10 +4002,10 @@ Debugger::drainTraceLoggerScriptCalls(JSContext* cx, unsigned argc, Value* vp) + size_t num; + TraceLoggerThread* logger = TraceLoggerForMainThread(cx->runtime()); + bool lostEvents = logger->lostEvents(dbg->traceLoggerScriptedCallsLastDrainedIteration, +- dbg->traceLoggerScriptedCallsLastDrainedId); ++ dbg->traceLoggerScriptedCallsLastDrainedSize); + EventEntry* events = logger->getEventsStartingAt( + &dbg->traceLoggerScriptedCallsLastDrainedIteration, +- &dbg->traceLoggerScriptedCallsLastDrainedId, ++ &dbg->traceLoggerScriptedCallsLastDrainedSize, + &num); + + RootedObject array(cx, NewDenseEmptyArray(cx)); +diff --git a/js/src/vm/Debugger.h b/js/src/vm/Debugger.h +index 8cac36a..c92d685 100644 +--- a/js/src/vm/Debugger.h ++++ b/js/src/vm/Debugger.h +@@ -314,10 +314,10 @@ class Debugger : private mozilla::LinkedListElement + * lost events. + */ + #ifdef NIGHTLY_BUILD +- uint32_t traceLoggerLastDrainedId; ++ uint32_t traceLoggerLastDrainedSize; + uint32_t traceLoggerLastDrainedIteration; + #endif +- uint32_t traceLoggerScriptedCallsLastDrainedId; ++ uint32_t traceLoggerScriptedCallsLastDrainedSize; + uint32_t traceLoggerScriptedCallsLastDrainedIteration; + + class FrameRange; +diff --git a/js/src/vm/TraceLogging.cpp b/js/src/vm/TraceLogging.cpp +index 6715b36..9766a6f 100644 +--- a/js/src/vm/TraceLogging.cpp ++++ b/js/src/vm/TraceLogging.cpp +@@ -131,7 +131,7 @@ TraceLoggerThread::init() + { + if (!pointerMap.init()) + return false; +- if (!extraTextId.init()) ++ if (!textIdPayloads.init()) + return false; + if (!events.init()) + return false; +@@ -185,10 +185,10 @@ TraceLoggerThread::~TraceLoggerThread() + graph = nullptr; + } + +- for (TextIdHashMap::Range r = extraTextId.all(); !r.empty(); r.popFront()) +- js_delete(r.front().value()); +- extraTextId.finish(); +- pointerMap.finish(); ++ if (textIdPayloads.initialized()) { ++ for (TextIdHashMap::Range r = textIdPayloads.all(); !r.empty(); r.popFront()) ++ js_delete(r.front().value()); ++ } + } + + bool +@@ -287,7 +287,7 @@ TraceLoggerThread::eventText(uint32_t id) + if (id < TraceLogger_Last) + return TLTextIdString(static_cast(id)); + +- TextIdHashMap::Ptr p = extraTextId.lookup(id); ++ TextIdHashMap::Ptr p = textIdPayloads.lookup(id); + MOZ_ASSERT(p); + + return p->value()->string(); +@@ -341,13 +341,15 @@ TraceLoggerThread::extractScriptDetails(uint32_t textId, const char** filename, + TraceLoggerEventPayload* + TraceLoggerThread::getOrCreateEventPayload(TraceLoggerTextId textId) + { +- TextIdHashMap::AddPtr p = extraTextId.lookupForAdd(textId); +- if (p) ++ TextIdHashMap::AddPtr p = textIdPayloads.lookupForAdd(textId); ++ if (p) { ++ MOZ_ASSERT(p->value()->textId() == textId); // Sanity check. + return p->value(); ++ } + + TraceLoggerEventPayload* payload = js_new(textId, (char*)nullptr); + +- if (!extraTextId.add(p, textId, payload)) ++ if (!textIdPayloads.add(p, textId, payload)) + return nullptr; + + return payload; +@@ -357,8 +359,10 @@ TraceLoggerEventPayload* + TraceLoggerThread::getOrCreateEventPayload(const char* text) + { + PointerHashMap::AddPtr p = pointerMap.lookupForAdd((const void*)text); +- if (p) ++ if (p) { ++ MOZ_ASSERT(p->value()->textId() < nextTextId); // Sanity check. + return p->value(); ++ } + + size_t len = strlen(text); + char* str = js_pod_malloc(len + 1); +@@ -369,7 +373,7 @@ TraceLoggerThread::getOrCreateEventPayload(const char* text) + MOZ_ASSERT(ret == len); + MOZ_ASSERT(strlen(str) == len); + +- uint32_t textId = extraTextId.count() + TraceLogger_Last; ++ uint32_t textId = nextTextId; + + TraceLoggerEventPayload* payload = js_new(textId, str); + if (!payload) { +@@ -377,17 +381,19 @@ TraceLoggerThread::getOrCreateEventPayload(const char* text) + return nullptr; + } + +- if (!extraTextId.putNew(textId, payload)) { ++ if (!textIdPayloads.putNew(textId, payload)) { + js_delete(payload); + return nullptr; + } + +- if (!pointerMap.add(p, text, payload)) +- return nullptr; +- + if (graph.get()) + graph->addTextId(textId, str); + ++ nextTextId++; ++ ++ if (!pointerMap.add(p, text, payload)) ++ return nullptr; ++ + return payload; + } + +@@ -407,9 +413,14 @@ TraceLoggerThread::getOrCreateEventPayload(TraceLoggerTextId type, const char* f + if (!traceLoggerState->isTextIdEnabled(type)) + return getOrCreateEventPayload(type); + +- PointerHashMap::AddPtr p = pointerMap.lookupForAdd(ptr); +- if (p) +- return p->value(); ++ PointerHashMap::AddPtr p; ++ if (ptr) { ++ p = pointerMap.lookupForAdd(ptr); ++ if (p) { ++ MOZ_ASSERT(p->value()->textId() < nextTextId); // Sanity check. ++ return p->value(); ++ } ++ } + + // Compute the length of the string to create. + size_t lenFilename = strlen(filename); +@@ -428,24 +439,28 @@ TraceLoggerThread::getOrCreateEventPayload(TraceLoggerTextId type, const char* f + MOZ_ASSERT(ret == len); + MOZ_ASSERT(strlen(str) == len); + +- uint32_t textId = extraTextId.count() + TraceLogger_Last; ++ uint32_t textId = nextTextId; + TraceLoggerEventPayload* payload = js_new(textId, str); + if (!payload) { + js_free(str); + return nullptr; + } + +- if (!extraTextId.putNew(textId, payload)) { ++ if (!textIdPayloads.putNew(textId, payload)) { + js_delete(payload); + return nullptr; + } + +- if (!pointerMap.add(p, ptr, payload)) +- return nullptr; +- + if (graph.get()) + graph->addTextId(textId, str); + ++ nextTextId++; ++ ++ if (ptr) { ++ if (!pointerMap.add(p, ptr, payload)) ++ return nullptr; ++ } ++ + return payload; + } + +@@ -453,14 +468,14 @@ TraceLoggerEventPayload* + TraceLoggerThread::getOrCreateEventPayload(TraceLoggerTextId type, JSScript* script) + { + return getOrCreateEventPayload(type, script->filename(), script->lineno(), script->column(), +- script); ++ nullptr); + } + + TraceLoggerEventPayload* + TraceLoggerThread::getOrCreateEventPayload(TraceLoggerTextId type, + const JS::ReadOnlyCompileOptions& script) + { +- return getOrCreateEventPayload(type, script.filename(), script.lineno, script.column, &script); ++ return getOrCreateEventPayload(type, script.filename(), script.lineno, script.column, nullptr); + } + + void +@@ -485,7 +500,7 @@ TraceLoggerThread::startEvent(uint32_t id) + if (!traceLoggerState->isTextIdEnabled(id)) + return; + +- logTimestamp(id); ++ log(id); + } + + void +@@ -510,7 +525,7 @@ TraceLoggerThread::stopEvent(uint32_t id) + if (!traceLoggerState->isTextIdEnabled(id)) + return; + +- logTimestamp(TraceLogger_Stop); ++ log(TraceLogger_Stop); + } + + void +@@ -522,23 +537,57 @@ TraceLoggerThread::logTimestamp(TraceLoggerTextId id) + void + TraceLoggerThread::logTimestamp(uint32_t id) + { ++ MOZ_ASSERT(id > TraceLogger_LastTreeItem && id < TraceLogger_Last); ++ log(id); ++} ++ ++void ++TraceLoggerThread::log(uint32_t id) ++{ + if (enabled == 0) + return; + + MOZ_ASSERT(traceLoggerState); +- if (!events.ensureSpaceBeforeAdd()) { ++ ++ // We request for 3 items to add, since if we don't have enough room ++ // we record the time it took to make more place. To log this information ++ // we need 2 extra free entries. ++ if (!events.hasSpaceForAdd(3)) { + uint64_t start = rdtsc() - traceLoggerState->startupTime; + +- if (graph.get()) +- graph->log(events); ++ if (!events.ensureSpaceBeforeAdd(3)) { ++ if (graph.get()) ++ graph->log(events); ++ ++ iteration_++; ++ events.clear(); ++ ++ // Remove the item in the pointerMap for which the payloads ++ // have no uses anymore ++ for (PointerHashMap::Enum e(pointerMap); !e.empty(); e.popFront()) { ++ if (e.front().value()->uses() != 0) ++ continue; ++ ++ TextIdHashMap::Ptr p = textIdPayloads.lookup(e.front().value()->textId()); ++ MOZ_ASSERT(p); ++ textIdPayloads.remove(p); ++ ++ e.removeFront(); ++ } + +- iteration_++; +- events.clear(); ++ // Free all payloads that have no uses anymore. ++ for (TextIdHashMap::Enum e(textIdPayloads); !e.empty(); e.popFront()) { ++ if (e.front().value()->uses() == 0) { ++ js_delete(e.front().value()); ++ e.removeFront(); ++ } ++ } ++ } + + // Log the time it took to flush the events as being from the + // Tracelogger. + if (graph.get()) { +- MOZ_ASSERT(events.capacity() > 2); ++ MOZ_ASSERT(events.hasSpaceForAdd(2)); + EventEntry& entryStart = events.pushUninitialized(); + entryStart.time = start; + entryStart.textId = TraceLogger_Internal; +@@ -548,13 +597,6 @@ TraceLoggerThread::logTimestamp(uint32_t id) + entryStop.textId = TraceLogger_Stop; + } + +- // Free all TextEvents that have no uses anymore. +- for (TextIdHashMap::Enum e(extraTextId); !e.empty(); e.popFront()) { +- if (e.front().value()->uses() == 0) { +- js_delete(e.front().value()); +- e.removeFront(); +- } +- } + } + + uint64_t time = rdtsc() - traceLoggerState->startupTime; +@@ -956,3 +998,16 @@ TraceLoggerEvent::~TraceLoggerEvent() + if (payload_) + payload_->release(); + } ++ ++TraceLoggerEvent& ++TraceLoggerEvent::operator=(const TraceLoggerEvent& other) ++{ ++ if (hasPayload()) ++ payload()->release(); ++ if (other.hasPayload()) ++ other.payload()->use(); ++ ++ payload_ = other.payload_; ++ ++ return *this; ++} +diff --git a/js/src/vm/TraceLogging.h b/js/src/vm/TraceLogging.h +index a124dcb..91a1eb0 100644 +--- a/js/src/vm/TraceLogging.h ++++ b/js/src/vm/TraceLogging.h +@@ -110,6 +110,9 @@ class TraceLoggerEvent { + bool hasPayload() const { + return !!payload_; + } ++ ++ TraceLoggerEvent& operator=(const TraceLoggerEvent& other); ++ TraceLoggerEvent(const TraceLoggerEvent& event) = delete; + }; + + /** +@@ -130,6 +133,10 @@ class TraceLoggerEventPayload { + uses_(0) + { } + ++ ~TraceLoggerEventPayload() { ++ MOZ_ASSERT(uses_ == 0); ++ } ++ + uint32_t textId() { + return textId_; + } +@@ -166,7 +173,8 @@ class TraceLoggerThread + mozilla::UniquePtr graph; + + PointerHashMap pointerMap; +- TextIdHashMap extraTextId; ++ TextIdHashMap textIdPayloads; ++ uint32_t nextTextId; + + ContinuousSpace events; + +@@ -181,6 +189,7 @@ class TraceLoggerThread + : enabled(0), + failed(false), + graph(), ++ nextTextId(TraceLogger_Last), + iteration_(0), + top(nullptr) + { } +@@ -195,22 +204,22 @@ class TraceLoggerThread + bool enable(JSContext* cx); + bool disable(); + +- // Given the previous iteration and lastEntryId, return an array of events ++ // Given the previous iteration and size, return an array of events + // (there could be lost events). At the same time update the iteration and +- // lastEntry and gives back how many events there are. +- EventEntry* getEventsStartingAt(uint32_t* lastIteration, uint32_t* lastEntryId, size_t* num) { ++ // 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(events.lastEntryId() >= *lastEntryId); +- *num = events.lastEntryId() - *lastEntryId; +- start = events.data() + *lastEntryId + 1; ++ MOZ_ASSERT(*lastSize <= events.size()); ++ *num = events.size() - *lastSize; ++ start = events.data() + *lastSize; + } else { +- *num = events.lastEntryId() + 1; ++ *num = events.size(); + start = events.data(); + } + + *lastIteration = iteration_; +- *lastEntryId = events.lastEntryId(); ++ *lastSize = events.size(); + return start; + } + +@@ -220,16 +229,16 @@ class TraceLoggerThread + const char** lineno, size_t* lineno_len, const char** colno, + size_t* colno_len); + +- bool lostEvents(uint32_t lastIteration, uint32_t lastEntryId) { ++ 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(lastEntryId <= events.lastEntryId()); ++ MOZ_ASSERT(lastSize <= events.size()); + return false; + } + +- // When proceeded to the next iteration and lastEntryId points to +- // the maximum capacity there are no logs that are lost. +- if (lastIteration + 1 == iteration_ && lastEntryId == events.capacity()) ++ // If we are in a 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; +@@ -268,6 +277,7 @@ class TraceLoggerThread + void stopEvent(uint32_t id); + private: + void stopEvent(); ++ void log(uint32_t id); + + public: + static unsigned offsetOfEnabled() { +diff --git a/js/src/vm/TraceLoggingGraph.cpp b/js/src/vm/TraceLoggingGraph.cpp +index d1b7f2e..a4eb273 100644 +--- a/js/src/vm/TraceLoggingGraph.cpp ++++ b/js/src/vm/TraceLoggingGraph.cpp +@@ -276,7 +276,7 @@ TraceLoggerGraph::flush() + if (bytesWritten < tree.size()) + return false; + +- treeOffset += tree.lastEntryId(); ++ treeOffset += tree.size(); + tree.clear(); + } + +@@ -359,7 +359,7 @@ TraceLoggerGraph::startEventInternal(uint32_t id, uint64_t timestamp) + + if (parent.lastChildId() == 0) { + MOZ_ASSERT(!entry.hasChildren()); +- MOZ_ASSERT(parent.treeId() == tree.lastEntryId() + treeOffset); ++ MOZ_ASSERT(parent.treeId() == treeOffset + tree.size() - 1); + + if (!updateHasChildren(parent.treeId())) + return false; +diff --git a/js/src/vm/TraceLoggingTypes.h b/js/src/vm/TraceLoggingTypes.h +index f1c9d0c..10b76d6 100644 +--- a/js/src/vm/TraceLoggingTypes.h ++++ b/js/src/vm/TraceLoggingTypes.h +@@ -21,7 +21,6 @@ + _(Internal) \ + _(Interpreter) \ + _(InlinedScripts) \ +- _(Invalidation) \ + _(IonCompilation) \ + _(IonCompilationPaused) \ + _(IonLinking) \ +@@ -60,6 +59,7 @@ + + #define TRACELOGGER_LOG_ITEMS(_) \ + _(Bailout) \ ++ _(Invalidation) \ + _(Disable) \ + _(Enable) \ + _(Stop) +@@ -130,6 +130,9 @@ class ContinuousSpace { + uint32_t size_; + uint32_t capacity_; + ++ // The maximum amount of ram memory a continuous space structure can take (in bytes). ++ static const uint32_t LIMIT = 200 * 1024 * 1024; ++ + public: + ContinuousSpace () + : data_(nullptr) +@@ -151,6 +154,10 @@ class ContinuousSpace { + data_ = nullptr; + } + ++ static uint32_t maxSize() { ++ return LIMIT / sizeof(T); ++ } ++ + T* data() { + return data_; + } +@@ -187,11 +194,14 @@ class ContinuousSpace { + if (hasSpaceForAdd(count)) + return true; + ++ // Limit the size of a continuous buffer. ++ if (size_ + count > maxSize()) ++ return false; ++ + uint32_t nCapacity = capacity_ * 2; +- if (size_ + count > nCapacity) +- nCapacity = size_ + count; +- T* entries = (T*) js_realloc(data_, nCapacity * sizeof(T)); ++ nCapacity = (nCapacity < maxSize()) ? nCapacity : maxSize(); + ++ T* entries = (T*) js_realloc(data_, nCapacity * sizeof(T)); + if (!entries) + return false; + diff --git a/talimatname/genel/js38/mozjs38-install-name.patch b/talimatname/genel/js38/mozjs38-install-name.patch new file mode 100644 index 000000000..b6f25b266 --- /dev/null +++ b/talimatname/genel/js38/mozjs38-install-name.patch @@ -0,0 +1,11 @@ +--- a/config/rules.mk 2016-11-09 23:51:17.000000000 -0800 ++++ b/config/rules.mk 2016-11-09 23:54:23.000000000 -0800 +@@ -393,7 +393,7 @@ + ifdef IS_COMPONENT + EXTRA_DSO_LDOPTS += -bundle + else +-EXTRA_DSO_LDOPTS += -dynamiclib -install_name @executable_path/$(SHARED_LIBRARY) -compatibility_version 1 -current_version 1 -single_module ++EXTRA_DSO_LDOPTS += -dynamiclib -install_name $(abspath $(prefix))/lib/$(SHARED_LIBRARY) -compatibility_version 1 -current_version 1 -single_module + endif + endif + endif diff --git a/talimatname/genel/js38/mozjs38-pkg-config-version.patch b/talimatname/genel/js38/mozjs38-pkg-config-version.patch new file mode 100644 index 000000000..34a43d1f6 --- /dev/null +++ b/talimatname/genel/js38/mozjs38-pkg-config-version.patch @@ -0,0 +1,22 @@ +Add major version to pkg-config filename. +Author: Rico Tzschichholz +Forwarded: no +Last-Update: 2015-05-04 + +Index: b/js/src/Makefile.in +=================================================================== +--- a/js/src/Makefile.in ++++ b/js/src/Makefile.in +@@ -214,10 +214,10 @@ + $(JS_CONFIG_NAME): js-config + cp $^ $@ + +-$(LIBRARY_NAME).pc: js.pc ++$(JS_LIBRARY_NAME).pc: js.pc + cp $^ $@ + +-install:: $(LIBRARY_NAME).pc ++install:: $(JS_LIBRARY_NAME).pc + $(SYSINSTALL) $^ $(DESTDIR)$(libdir)/pkgconfig + + install:: js-config.h diff --git a/talimatname/genel/js38/mozjs38-shell-version.patch b/talimatname/genel/js38/mozjs38-shell-version.patch new file mode 100644 index 000000000..cc6b3d35b --- /dev/null +++ b/talimatname/genel/js38/mozjs38-shell-version.patch @@ -0,0 +1,65 @@ +# HG changeset patch +# Parent 4732a0e5d22bc7e5c1f1ace7a182d537d9cc2c6a +Add major version to shell and js-config filenames. +Author: Rico Tzschichholz +Forwarded: no +Last-Update: 2014-10-29 + +--- +diff --git a/js/src/configure b/js/src/configure +--- a/js/src/configure ++++ b/js/src/configure +@@ -1696,8 +1696,13 @@ + MOZJS_PATCH_VERSION=`echo $MOZILLA_VERSION | sed "s|^[0-9]*\.[0-9]*[^0-9]*||"` + IS_ALPHA=`echo $MOZILLA_VERSION | grep '[ab]'` + ++if test -n "$JS_STANDALONE"; then ++JS_SHELL_NAME=js$MOZJS_MAJOR_VERSION ++JS_CONFIG_NAME=js$MOZJS_MAJOR_VERSION-config ++else + JS_SHELL_NAME=js + JS_CONFIG_NAME=js-config ++fi + + + if test -n "$IS_ALPHA"; then + +diff --git a/js/src/configure.in b/js/src/configure.in +--- a/js/src/configure.in ++++ b/js/src/configure.in +@@ -234,16 +234,13 @@ MOZJS_MINOR_VERSION=`echo $MOZILLA_VERSI + MOZJS_PATCH_VERSION=`echo $MOZILLA_VERSION | sed "s|^[0-9]*\.[0-9]*[^0-9]*||"` + IS_ALPHA=`echo $MOZILLA_VERSION | grep '[ab]'` + +-dnl XXX in a temporary bid to avoid developer anger at renaming files +-dnl XXX before "js" symlinks exist, don't change names. +-dnl +-dnl if test -n "$JS_STANDALONE"; then +-dnl JS_SHELL_NAME=js$MOZJS_MAJOR_VERSION +-dnl JS_CONFIG_NAME=js$MOZJS_MAJOR_VERSION-config +-dnl else ++if test -n "$JS_STANDALONE"; then ++JS_SHELL_NAME=js$MOZJS_MAJOR_VERSION ++JS_CONFIG_NAME=js$MOZJS_MAJOR_VERSION-config ++else + JS_SHELL_NAME=js + JS_CONFIG_NAME=js-config +-dnl fi ++fi + + changequote([,]) + if test -n "$IS_ALPHA"; then + +diff -r 80a9e64d75f5 js/src/Makefile.in +--- a/js/src/Makefile.in Wed Jun 25 15:11:42 2014 +0200 ++++ b/js/src/Makefile.in Sat Jul 05 14:08:38 2014 +0200 +@@ -273,6 +273,9 @@ + SCRIPTS = $(JS_CONFIG_NAME) + SDK_BINARY = $(JS_CONFIG_NAME) + ++$(JS_CONFIG_NAME): js-config ++ cp $^ $@ ++ + $(LIBRARY_NAME).pc: js.pc + cp $^ $@ + diff --git a/talimatname/genel/js38/talimat b/talimatname/genel/js38/talimat new file mode 100644 index 000000000..b6176432a --- /dev/null +++ b/talimatname/genel/js38/talimat @@ -0,0 +1,41 @@ +# Description: JavaScript tercüman ve kütüphaneleri - Sürüm 38 +# URL: https://developer.mozilla.org/en-US/docs/Mozilla/Projects/SpiderMonkey/Releases/38 +# Packager: Cihan Alkan +# Depends on: nspr icu libffi python zip + +name=js38 +version=38.8.0 +release=1 +source=(https://ftp.mozilla.org/pub/firefox/releases/38.8.0esr/source/firefox-38.8.0esr.source.tar.bz2 + mozjs38-fix-tracelogger.patch + mozjs38-shell-version.patch + mozjs38-pkg-config-version.patch + mozjs38-install-name.patch + mozjs38-copy-headers.patch + mozjs38-add-bracket.patch + mozjs38-1269317.patch) + +build() { + cd mozilla-esr38 + patch -Np1 -i $SRC/mozjs38-fix-tracelogger.patch + patch -Np1 -i $SRC/mozjs38-shell-version.patch + patch -Np1 -i $SRC/mozjs38-pkg-config-version.patch + patch -Np1 -i $SRC/mozjs38-install-name.patch + patch -Np1 -i $SRC/mozjs38-copy-headers.patch + patch -Np1 -i $SRC/mozjs38-add-bracket.patch + patch -Np1 -i $SRC/mozjs38-1269317.patch + unset CPPFLAGS + CXXFLAGS+=' -fno-delete-null-pointer-checks -fpermissive -fno-tree-vrp -fno-strict-aliasing' + CFLAGS+=' -fno-delete-null-pointer-checks -fpermissive -fno-tree-vrp -fno-strict-aliasing' + export PYTHON=/usr/bin/python2 + export SHELL=$XTERM_SHELL + cd $SRC/mozilla-esr38/js/src + ./configure --prefix=/usr --with-system-nspr --enable-system-ffi \ + --with-system-zlib --with-system-icu --with-intl-api --enable-ctypes \ + --enable-threadsafe --enable-system-ffi --enable-shared-js --enable-gcgenerational --disable-optimize --enable-pie + SHELL=/bin/sh make + SHELL=/bin/sh make DESTDIR="$PKG" install + rm -f "$PKG"/usr/lib/*.ajs + rm -f "$PKG"/usr/bin/js38 + find "$PKG"/usr/{lib/pkgconfig,include} -type f -exec chmod -x {} + +}