/* 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/. */
#ifndef js_ProfilingSources_h
#define js_ProfilingSources_h
#include "mozilla/HashFunctions.h"
#include "mozilla/Variant.h"
#include <stdint.h>
#include "jstypes.h"
#include "js/TypeDecls.h"
#include "js/Utility.h"
#include "js/Vector.h"
/*
* Struct to pass JS source data with content type information for profiler use.
*/
struct JS_PUBLIC_API ProfilerJSSourceData {
public:
struct SourceTextUTF16 {
public:
SourceTextUTF16(JS::UniqueTwoByteChars&& c, size_t l)
: chars_(std::move(c)), length_(l) {}
const JS::UniqueTwoByteChars& chars()
const {
return chars_; }
size_t length()
const {
return length_; }
private:
// Not null-terminated string for source text. Always use it with the
// length.
JS::UniqueTwoByteChars chars_;
size_t length_;
};
struct SourceTextUTF8 {
public:
SourceTextUTF8(JS::UniqueChars&& c, size_t l)
: chars_(std::move(c)), length_(l) {}
const JS::UniqueChars& chars()
const {
return chars_; }
size_t length()
const {
return length_; }
private:
// Not null-terminated string for source text. Always use it with the
// length.
JS::UniqueChars chars_;
size_t length_;
};
/*
* Represents a source file that can be retrieved later in the parent process.
* Used when source text is not immediately available in the current process
* but can be fetched using the file path information.
*/
struct RetrievableFile {};
struct Unavailable {};
using ProfilerSourceVariant =
mozilla::Variant<SourceTextUTF16, SourceTextUTF8, RetrievableFile,
Unavailable>;
// Constructors
ProfilerJSSourceData(uint32_t sourceId, JS::UniqueChars&& filePath,
size_t pathLen, uint32_t startLine, uint32_t startColumn,
JS::UniqueTwoByteChars&& sourceMapURL,
size_t sourceMapURLLen)
: sourceId_(sourceId),
filePath_(std::move(filePath)),
filePathLength_(pathLen),
data_(Unavailable{}),
startLine_(startLine),
startColumn_(startColumn),
sourceMapURL_(std::move(sourceMapURL)),
sourceMapURLLength_(sourceMapURLLen) {}
// UTF-8 source text with filePath
ProfilerJSSourceData(uint32_t sourceId, JS::UniqueChars&& chars,
size_t length, JS::UniqueChars&& filePath,
size_t pathLen, uint32_t startLine, uint32_t startColumn,
JS::UniqueTwoByteChars&& sourceMapURL,
size_t sourceMapURLLen)
: sourceId_(sourceId),
filePath_(std::move(filePath)),
filePathLength_(pathLen),
data_(SourceTextUTF8{std::move(chars), length}),
startLine_(startLine),
startColumn_(startColumn),
sourceMapURL_(std::move(sourceMapURL)),
sourceMapURLLength_(sourceMapURLLen) {}
// UTF-16 source text with filePath
ProfilerJSSourceData(uint32_t sourceId, JS::UniqueTwoByteChars&& chars,
size_t length, JS::UniqueChars&& filePath,
size_t pathLen, uint32_t startLine, uint32_t startColumn,
JS::UniqueTwoByteChars&& sourceMapURL,
size_t sourceMapURLLen)
: sourceId_(sourceId),
filePath_(std::move(filePath)),
filePathLength_(pathLen),
data_(SourceTextUTF16{std::move(chars), length}),
startLine_(startLine),
startColumn_(startColumn),
sourceMapURL_(std::move(sourceMapURL)),
sourceMapURLLength_(sourceMapURLLen) {}
// For the cases where no sourceId and filepath are needed.
ProfilerJSSourceData(JS::UniqueChars&& chars, size_t length)
: sourceId_(
0),
filePath_(nullptr),
filePathLength_(
0),
data_(SourceTextUTF8{std::move(chars), length}),
sourceMapURL_(nullptr),
sourceMapURLLength_(
0) {}
ProfilerJSSourceData()
: sourceId_(
0),
filePathLength_(
0),
data_(Unavailable{}),
sourceMapURLLength_(
0) {}
static ProfilerJSSourceData CreateRetrievableFile(
uint32_t sourceId, JS::UniqueChars&& filePath, size_t pathLength,
uint32_t startLine, uint32_t startColumn,
JS::UniqueTwoByteChars&& sourceMapURL, size_t sourceMapURLLength) {
ProfilerJSSourceData result(sourceId, std::move(filePath), pathLength,
startLine, startColumn, std::move(sourceMapURL),
sourceMapURLLength);
result.data_.emplace<RetrievableFile>();
return result;
}
ProfilerJSSourceData(ProfilerJSSourceData&&) =
default;
ProfilerJSSourceData&
operator=(ProfilerJSSourceData&&) =
default;
// No copy constructors as this class owns its string storage.
ProfilerJSSourceData(
const ProfilerJSSourceData& other) =
delete;
ProfilerJSSourceData&
operator=(
const ProfilerJSSourceData&) =
delete;
uint32_t sourceId()
const {
return sourceId_; }
// Consumer should always check for filePathLength before calling this.
const char* filePath()
const {
MOZ_ASSERT(filePath_);
return filePath_.get();
}
size_t filePathLength()
const {
return filePathLength_; }
// Consumer should always check for sourceMapURLLength before calling this.
const char16_t* sourceMapURL()
const {
MOZ_ASSERT(sourceMapURL_);
return sourceMapURL_.get();
}
size_t sourceMapURLLength()
const {
return sourceMapURLLength_; }
const ProfilerSourceVariant& data()
const {
return data_; }
uint32_t startLine()
const {
return startLine_; }
uint32_t startColumn()
const {
return startColumn_; }
// Used only for memory reporting.
size_t
SizeOf()
const {
// Size of sourceId + filepath + sourceMapURL + startLine + startColumn.
size_t size =
sizeof(uint32_t) + filePathLength_ *
sizeof(
char) +
sourceMapURLLength_ *
sizeof(char16_t) +
sizeof(uint32_t) +
sizeof(uint32_t);
data_.match(
[&](
const SourceTextUTF16& srcText) {
size += srcText.length() *
sizeof(char16_t);
},
[&](
const SourceTextUTF8& srcText) {
size += srcText.length() *
sizeof(
char);
},
[](
const RetrievableFile&) {}, [](
const Unavailable&) {});
return size;
}
mozilla::HashNumber hash()
const {
using mozilla::HashBytes;
using mozilla::HashNumber;
HashNumber hash =
0;
if (filePathLength_ >
0) {
hash = HashBytes(filePath_.get(), filePathLength_, hash);
}
hash = mozilla::AddToHash(hash, startLine_);
hash = mozilla::AddToHash(hash, startColumn_);
if (sourceMapURLLength_ >
0) {
hash = HashBytes(sourceMapURL_.get(),
sourceMapURLLength_ *
sizeof(char16_t), hash);
}
hash = data_.addTagToHash(hash);
data_.match(
[&](
const SourceTextUTF16& srcText) {
hash = HashBytes(srcText.chars().get(),
srcText.length() *
sizeof(char16_t), hash);
},
[&](
const SourceTextUTF8& srcText) {
hash = HashBytes(srcText.chars().get(), srcText.length(), hash);
},
[](
const RetrievableFile&) {}, [](
const Unavailable&) {});
return hash;
}
private:
// Unique identifier for this source across the process. This can be used
// to refer to this source from places that don't want to hold a strong
// reference on the source itself.
// Generated by ScriptSource and retrieved via ScriptSource::id(). See
// ScriptSource::id_ for more details.
uint32_t sourceId_;
// Null-terminated file path for the source.
// It can be nullptr if:
// - The source has no filename.
// - filename allocation fails during copy.
JS::UniqueChars filePath_;
size_t filePathLength_;
ProfilerSourceVariant data_;
// Line number within the file where this source starts (1-based).
// This is used for inline scripts within HTML pages.
uint32_t startLine_ =
1;
// Column number within the file where this source starts (1-based).
// This is used for inline scripts within HTML pages.
uint32_t startColumn_ =
1;
// Null-terminated source map URL for the source.
// It can be nullptr if:
// - The source has no sourceMapURL.
// - sourceMapURL allocation fails during copy.
JS::UniqueTwoByteChars sourceMapURL_;
size_t sourceMapURLLength_;
};
namespace js {
using ProfilerJSSources =
js::Vector<ProfilerJSSourceData,
0, js::SystemAllocPolicy>;
/*
* Main API for getting the profiled JS sources.
* If gatherSourceText is false, only metadata (filename, sourceMapURL) will
* be gathered, not the actual source text.
*/
JS_PUBLIC_API ProfilerJSSources GetProfilerScriptSources(JSRuntime* rt,
bool gatherSourceText);
/**
* Retrieve the JS sources that are only retrievable from the parent process.
* See RetrievableFile struct for more information.
* */
JS_PUBLIC_API ProfilerJSSourceData
RetrieveProfilerSourceContent(JSContext* cx,
const char* filename);
}
// namespace js
#endif /* js_ProfilingSources_h */
