diff options
Diffstat (limited to 'js/src/vm/CodeCoverage.cpp')
| -rw-r--r-- | js/src/vm/CodeCoverage.cpp | 673 |
1 files changed, 673 insertions, 0 deletions
diff --git a/js/src/vm/CodeCoverage.cpp b/js/src/vm/CodeCoverage.cpp new file mode 100644 index 0000000000..120fe1da6d --- /dev/null +++ b/js/src/vm/CodeCoverage.cpp @@ -0,0 +1,673 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * vim: set ts=8 sts=2 et sw=2 tw=80: + * 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/CodeCoverage.h" + +#include "mozilla/Atomics.h" +#include "mozilla/IntegerPrintfMacros.h" + +#include <stdio.h> +#include <utility> + +#include "frontend/SourceNotes.h" // SrcNote, SrcNoteType, SrcNoteIterator +#include "gc/Zone.h" +#include "util/GetPidProvider.h" // getpid() +#include "util/Text.h" +#include "vm/BytecodeUtil.h" +#include "vm/JSScript.h" +#include "vm/Realm.h" +#include "vm/Runtime.h" +#include "vm/Time.h" + +// This file contains a few functions which are used to produce files understood +// by lcov tools. A detailed description of the format is available in the man +// page for "geninfo" [1]. To make it short, the following paraphrases what is +// commented in the man page by using curly braces prefixed by for-each to +// express repeated patterns. +// +// TN:<compartment name> +// for-each <source file> { +// SF:<filename> +// for-each <script> { +// FN:<line>,<name> +// } +// for-each <script> { +// FNDA:<hits>,<name> +// } +// FNF:<number of scripts> +// FNH:<sum of scripts hits> +// for-each <script> { +// for-each <branch> { +// BRDA:<line>,<block id>,<target id>,<taken> +// } +// } +// BRF:<number of branches> +// BRH:<sum of branches hits> +// for-each <script> { +// for-each <line> { +// DA:<line>,<hits> +// } +// } +// LF:<number of lines> +// LH:<sum of lines hits> +// } +// +// [1] http://ltp.sourceforge.net/coverage/lcov/geninfo.1.php +// +namespace js { +namespace coverage { + +LCovSource::LCovSource(LifoAlloc* alloc, UniqueChars name) + : name_(std::move(name)), + outFN_(alloc), + outFNDA_(alloc), + numFunctionsFound_(0), + numFunctionsHit_(0), + outBRDA_(alloc), + numBranchesFound_(0), + numBranchesHit_(0), + numLinesInstrumented_(0), + numLinesHit_(0), + maxLineHit_(0), + hasTopLevelScript_(false), + hadOOM_(false) {} + +void LCovSource::exportInto(GenericPrinter& out) { + if (hadOutOfMemory()) { + out.reportOutOfMemory(); + } else { + out.printf("SF:%s\n", name_.get()); + + outFN_.exportInto(out); + outFNDA_.exportInto(out); + out.printf("FNF:%zu\n", numFunctionsFound_); + out.printf("FNH:%zu\n", numFunctionsHit_); + + outBRDA_.exportInto(out); + out.printf("BRF:%zu\n", numBranchesFound_); + out.printf("BRH:%zu\n", numBranchesHit_); + + if (!linesHit_.empty()) { + for (size_t lineno = 1; lineno <= maxLineHit_; ++lineno) { + if (auto p = linesHit_.lookup(lineno)) { + out.printf("DA:%zu,%" PRIu64 "\n", lineno, p->value()); + } + } + } + + out.printf("LF:%zu\n", numLinesInstrumented_); + out.printf("LH:%zu\n", numLinesHit_); + + out.put("end_of_record\n"); + } + + outFN_.clear(); + outFNDA_.clear(); + numFunctionsFound_ = 0; + numFunctionsHit_ = 0; + outBRDA_.clear(); + numBranchesFound_ = 0; + numBranchesHit_ = 0; + linesHit_.clear(); + numLinesInstrumented_ = 0; + numLinesHit_ = 0; + maxLineHit_ = 0; +} + +void LCovSource::writeScript(JSScript* script, const char* scriptName) { + if (hadOutOfMemory()) { + return; + } + + numFunctionsFound_++; + outFN_.printf("FN:%u,%s\n", script->lineno(), scriptName); + + uint64_t hits = 0; + ScriptCounts* sc = nullptr; + if (script->hasScriptCounts()) { + sc = &script->getScriptCounts(); + numFunctionsHit_++; + const PCCounts* counts = + sc->maybeGetPCCounts(script->pcToOffset(script->main())); + outFNDA_.printf("FNDA:%" PRIu64 ",%s\n", counts->numExec(), scriptName); + + // Set the hit count of the pre-main code to 1, if the function ever got + // visited. + hits = 1; + } + + jsbytecode* snpc = script->code(); + const SrcNote* sn = script->notes(); + if (!sn->isTerminator()) { + snpc += sn->delta(); + } + + size_t lineno = script->lineno(); + jsbytecode* end = script->codeEnd(); + size_t branchId = 0; + bool firstLineHasBeenWritten = false; + for (jsbytecode* pc = script->code(); pc != end; pc = GetNextPc(pc)) { + MOZ_ASSERT(script->code() <= pc && pc < end); + JSOp op = JSOp(*pc); + bool jump = IsJumpOpcode(op) || op == JSOp::TableSwitch; + bool fallsthrough = BytecodeFallsThrough(op); + + // If the current script & pc has a hit-count report, then update the + // current number of hits. + if (sc) { + const PCCounts* counts = sc->maybeGetPCCounts(script->pcToOffset(pc)); + if (counts) { + hits = counts->numExec(); + } + } + + // If we have additional source notes, walk all the source notes of the + // current pc. + if (snpc <= pc || !firstLineHasBeenWritten) { + size_t oldLine = lineno; + SrcNoteIterator iter(sn); + while (!iter.atEnd() && snpc <= pc) { + sn = *iter; + SrcNoteType type = sn->type(); + if (type == SrcNoteType::SetLine) { + lineno = SrcNote::SetLine::getLine(sn, script->lineno()); + } else if (type == SrcNoteType::NewLine) { + lineno++; + } + ++iter; + snpc += (*iter)->delta(); + } + sn = *iter; + + if ((oldLine != lineno || !firstLineHasBeenWritten) && + pc >= script->main() && fallsthrough) { + auto p = linesHit_.lookupForAdd(lineno); + if (!p) { + if (!linesHit_.add(p, lineno, hits)) { + hadOOM_ = true; + return; + } + numLinesInstrumented_++; + if (hits != 0) { + numLinesHit_++; + } + maxLineHit_ = std::max(lineno, maxLineHit_); + } else { + if (p->value() == 0 && hits != 0) { + numLinesHit_++; + } + p->value() += hits; + } + + firstLineHasBeenWritten = true; + } + } + + // If the current instruction has thrown, then decrement the hit counts + // with the number of throws. + if (sc) { + const PCCounts* counts = sc->maybeGetThrowCounts(script->pcToOffset(pc)); + if (counts) { + hits -= counts->numExec(); + } + } + + // If the current pc corresponds to a conditional jump instruction, then + // reports branch hits. + if (jump && fallsthrough) { + jsbytecode* fallthroughTarget = GetNextPc(pc); + uint64_t fallthroughHits = 0; + if (sc) { + const PCCounts* counts = + sc->maybeGetPCCounts(script->pcToOffset(fallthroughTarget)); + if (counts) { + fallthroughHits = counts->numExec(); + } + } + + uint64_t taken = hits - fallthroughHits; + outBRDA_.printf("BRDA:%zu,%zu,0,", lineno, branchId); + if (hits) { + outBRDA_.printf("%" PRIu64 "\n", taken); + } else { + outBRDA_.put("-\n", 2); + } + + outBRDA_.printf("BRDA:%zu,%zu,1,", lineno, branchId); + if (hits) { + outBRDA_.printf("%" PRIu64 "\n", fallthroughHits); + } else { + outBRDA_.put("-\n", 2); + } + + // Count the number of branches, and the number of branches hit. + numBranchesFound_ += 2; + if (hits) { + numBranchesHit_ += !!taken + !!fallthroughHits; + } + branchId++; + } + + // If the current pc corresponds to a pre-computed switch case, then + // reports branch hits for each case statement. + if (jump && op == JSOp::TableSwitch) { + // Get the default pc. + jsbytecode* defaultpc = pc + GET_JUMP_OFFSET(pc); + MOZ_ASSERT(script->code() <= defaultpc && defaultpc < end); + MOZ_ASSERT(defaultpc > pc); + + // Get the low and high from the tableswitch + int32_t low = GET_JUMP_OFFSET(pc + JUMP_OFFSET_LEN * 1); + int32_t high = GET_JUMP_OFFSET(pc + JUMP_OFFSET_LEN * 2); + MOZ_ASSERT(high - low + 1 >= 0); + size_t numCases = high - low + 1; + + auto getCaseOrDefaultPc = [&](size_t index) { + if (index < numCases) { + return script->tableSwitchCasePC(pc, index); + } + MOZ_ASSERT(index == numCases); + return defaultpc; + }; + + jsbytecode* firstCaseOrDefaultPc = end; + for (size_t j = 0; j < numCases + 1; j++) { + jsbytecode* testpc = getCaseOrDefaultPc(j); + MOZ_ASSERT(script->code() <= testpc && testpc < end); + if (testpc < firstCaseOrDefaultPc) { + firstCaseOrDefaultPc = testpc; + } + } + + // Count the number of hits of the default branch, by subtracting + // the number of hits of each cases. + uint64_t defaultHits = hits; + + // Count the number of hits of the previous case entry. + uint64_t fallsThroughHits = 0; + + // Record branches for each case and default. + size_t caseId = 0; + for (size_t i = 0; i < numCases + 1; i++) { + jsbytecode* caseOrDefaultPc = getCaseOrDefaultPc(i); + MOZ_ASSERT(script->code() <= caseOrDefaultPc && caseOrDefaultPc < end); + + // PCs might not be in increasing order of case indexes. + jsbytecode* lastCaseOrDefaultPc = firstCaseOrDefaultPc - 1; + bool foundLastCaseOrDefault = false; + for (size_t j = 0; j < numCases + 1; j++) { + jsbytecode* testpc = getCaseOrDefaultPc(j); + MOZ_ASSERT(script->code() <= testpc && testpc < end); + if (lastCaseOrDefaultPc < testpc && + (testpc < caseOrDefaultPc || + (j < i && testpc == caseOrDefaultPc))) { + lastCaseOrDefaultPc = testpc; + foundLastCaseOrDefault = true; + } + } + + // If multiple case instruction have the same code block, only + // register the code coverage the first time we hit this case. + if (!foundLastCaseOrDefault || caseOrDefaultPc != lastCaseOrDefaultPc) { + uint64_t caseOrDefaultHits = 0; + if (sc) { + if (i < numCases) { + // Case (i + low) + const PCCounts* counts = + sc->maybeGetPCCounts(script->pcToOffset(caseOrDefaultPc)); + if (counts) { + caseOrDefaultHits = counts->numExec(); + } + + // Remove fallthrough. + fallsThroughHits = 0; + if (foundLastCaseOrDefault) { + // Walk from the previous case to the current one to + // check if it fallthrough into the current block. + MOZ_ASSERT(lastCaseOrDefaultPc != firstCaseOrDefaultPc - 1); + jsbytecode* endpc = lastCaseOrDefaultPc; + while (GetNextPc(endpc) < caseOrDefaultPc) { + endpc = GetNextPc(endpc); + MOZ_ASSERT(script->code() <= endpc && endpc < end); + } + + if (BytecodeFallsThrough(JSOp(*endpc))) { + fallsThroughHits = script->getHitCount(endpc); + } + } + caseOrDefaultHits -= fallsThroughHits; + } else { + caseOrDefaultHits = defaultHits; + } + } + + outBRDA_.printf("BRDA:%zu,%zu,%zu,", lineno, branchId, caseId); + if (hits) { + outBRDA_.printf("%" PRIu64 "\n", caseOrDefaultHits); + } else { + outBRDA_.put("-\n", 2); + } + + numBranchesFound_++; + numBranchesHit_ += !!caseOrDefaultHits; + if (i < numCases) { + defaultHits -= caseOrDefaultHits; + } + caseId++; + } + } + } + } + + if (outFN_.hadOutOfMemory() || outFNDA_.hadOutOfMemory() || + outBRDA_.hadOutOfMemory()) { + hadOOM_ = true; + return; + } + + // If this script is the top-level script, then record it such that we can + // assume that the code coverage report is complete, as this script has + // references on all inner scripts. + if (script->isTopLevel()) { + hasTopLevelScript_ = true; + } +} + +LCovRealm::LCovRealm(JS::Realm* realm) + : alloc_(4096), outTN_(&alloc_), sources_(alloc_) { + // Record realm name. If we wait until finalization, the embedding may not be + // able to provide us the name anymore. + writeRealmName(realm); +} + +LCovRealm::~LCovRealm() { + // The LCovSource are in the LifoAlloc but we must still manually invoke + // destructors to avoid leaks. + while (!sources_.empty()) { + LCovSource* source = sources_.popCopy(); + source->~LCovSource(); + } +} + +LCovSource* LCovRealm::lookupOrAdd(const char* name) { + // Find existing source if it exists. + for (LCovSource* source : sources_) { + if (source->match(name)) { + return source; + } + } + + UniqueChars source_name = DuplicateString(name); + if (!source_name) { + outTN_.reportOutOfMemory(); + return nullptr; + } + + // Allocate a new LCovSource for the current top-level. + LCovSource* source = alloc_.new_<LCovSource>(&alloc_, std::move(source_name)); + if (!source) { + outTN_.reportOutOfMemory(); + return nullptr; + } + + if (!sources_.emplaceBack(source)) { + outTN_.reportOutOfMemory(); + return nullptr; + } + + return source; +} + +void LCovRealm::exportInto(GenericPrinter& out, bool* isEmpty) const { + if (outTN_.hadOutOfMemory()) { + return; + } + + // If we only have cloned function, then do not serialize anything. + bool someComplete = false; + for (const LCovSource* sc : sources_) { + if (sc->isComplete()) { + someComplete = true; + break; + }; + } + + if (!someComplete) { + return; + } + + *isEmpty = false; + outTN_.exportInto(out); + for (LCovSource* sc : sources_) { + // Only write if everything got recorded. + if (sc->isComplete()) { + sc->exportInto(out); + } + } +} + +void LCovRealm::writeRealmName(JS::Realm* realm) { + JSContext* cx = TlsContext.get(); + + // lcov trace files are starting with an optional test case name, that we + // recycle to be a realm name. + // + // Note: The test case name has some constraint in terms of valid character, + // thus we escape invalid chracters with a "_" symbol in front of its + // hexadecimal code. + outTN_.put("TN:"); + if (cx->runtime()->realmNameCallback) { + char name[1024]; + { + // Hazard analysis cannot tell that the callback does not GC. + JS::AutoSuppressGCAnalysis nogc; + (*cx->runtime()->realmNameCallback)(cx, realm, name, sizeof(name), nogc); + } + for (char* s = name; s < name + sizeof(name) && *s; s++) { + if (('a' <= *s && *s <= 'z') || ('A' <= *s && *s <= 'Z') || + ('0' <= *s && *s <= '9')) { + outTN_.put(s, 1); + continue; + } + outTN_.printf("_%p", (void*)size_t(*s)); + } + outTN_.put("\n", 1); + } else { + outTN_.printf("Realm_%p%p\n", (void*)size_t('_'), realm); + } +} + +const char* LCovRealm::getScriptName(JSScript* script) { + JSFunction* fun = script->function(); + if (fun && fun->displayAtom()) { + JSAtom* atom = fun->displayAtom(); + size_t lenWithNull = js::PutEscapedString(nullptr, 0, atom, 0) + 1; + char* name = alloc_.newArray<char>(lenWithNull); + if (name) { + js::PutEscapedString(name, lenWithNull, atom, 0); + } + return name; + } + return "top-level"; +} + +bool gLCovIsEnabled = false; + +void InitLCov() { + const char* outDir = getenv("JS_CODE_COVERAGE_OUTPUT_DIR"); + if (outDir && *outDir != 0) { + EnableLCov(); + } +} + +void EnableLCov() { + MOZ_ASSERT(!JSRuntime::hasLiveRuntimes(), + "EnableLCov must not be called after creating a runtime!"); + gLCovIsEnabled = true; +} + +LCovRuntime::LCovRuntime() : out_(), pid_(getpid()), isEmpty_(true) {} + +LCovRuntime::~LCovRuntime() { + if (out_.isInitialized()) { + finishFile(); + } +} + +bool LCovRuntime::fillWithFilename(char* name, size_t length) { + const char* outDir = getenv("JS_CODE_COVERAGE_OUTPUT_DIR"); + if (!outDir || *outDir == 0) { + return false; + } + + int64_t timestamp = static_cast<double>(PRMJ_Now()) / PRMJ_USEC_PER_SEC; + static mozilla::Atomic<size_t> globalRuntimeId(0); + size_t rid = globalRuntimeId++; + + int len = snprintf(name, length, "%s/%" PRId64 "-%" PRIu32 "-%zu.info", + outDir, timestamp, pid_, rid); + if (len < 0 || size_t(len) >= length) { + fprintf(stderr, + "Warning: LCovRuntime::init: Cannot serialize file name.\n"); + return false; + } + + return true; +} + +void LCovRuntime::init() { + char name[1024]; + if (!fillWithFilename(name, sizeof(name))) { + return; + } + + // If we cannot open the file, report a warning. + if (!out_.init(name)) { + fprintf(stderr, + "Warning: LCovRuntime::init: Cannot open file named '%s'.\n", name); + } + isEmpty_ = true; +} + +void LCovRuntime::finishFile() { + MOZ_ASSERT(out_.isInitialized()); + out_.finish(); + + if (isEmpty_) { + char name[1024]; + if (!fillWithFilename(name, sizeof(name))) { + return; + } + remove(name); + } +} + +void LCovRuntime::writeLCovResult(LCovRealm& realm) { + if (!out_.isInitialized()) { + init(); + if (!out_.isInitialized()) { + return; + } + } + + uint32_t p = getpid(); + if (pid_ != p) { + pid_ = p; + finishFile(); + init(); + if (!out_.isInitialized()) { + return; + } + } + + realm.exportInto(out_, &isEmpty_); + out_.flush(); + finishFile(); +} + +bool InitScriptCoverage(JSContext* cx, JSScript* script) { + MOZ_ASSERT(IsLCovEnabled()); + MOZ_ASSERT(script->hasBytecode(), + "Only initialize coverage data for fully initialized scripts."); + + MOZ_ASSERT(!cx->isHelperThreadContext()); + + const char* filename = script->filename(); + if (!filename) { + return true; + } + + // Create LCovRealm if necessary. + LCovRealm* lcovRealm = script->realm()->lcovRealm(); + if (!lcovRealm) { + ReportOutOfMemory(cx); + return false; + } + + // Create LCovSource if necessary. + LCovSource* source = lcovRealm->lookupOrAdd(filename); + if (!source) { + ReportOutOfMemory(cx); + return false; + } + + // Computed the formated script name. + const char* scriptName = lcovRealm->getScriptName(script); + if (!scriptName) { + ReportOutOfMemory(cx); + return false; + } + + // Create Zone::scriptLCovMap if necessary. + JS::Zone* zone = script->zone(); + if (!zone->scriptLCovMap) { + zone->scriptLCovMap = cx->make_unique<ScriptLCovMap>(); + } + if (!zone->scriptLCovMap) { + return false; + } + + MOZ_ASSERT(script->hasBytecode()); + + // Save source in map for when we collect coverage. + if (!zone->scriptLCovMap->putNew(script, + std::make_tuple(source, scriptName))) { + ReportOutOfMemory(cx); + return false; + } + + return true; +} + +bool CollectScriptCoverage(JSScript* script, bool finalizing) { + MOZ_ASSERT(IsLCovEnabled()); + + ScriptLCovMap* map = script->zone()->scriptLCovMap.get(); + if (!map) { + return false; + } + + auto p = map->lookup(script); + if (!p.found()) { + return false; + } + + auto [source, scriptName] = p->value(); + + if (script->hasBytecode()) { + source->writeScript(script, scriptName); + } + + if (finalizing) { + map->remove(p); + } + + // Propagate the failure in case caller wants to terminate early. + return !source->hadOutOfMemory(); +} + +} // namespace coverage +} // namespace js |