summaryrefslogtreecommitdiffstats
path: root/toolkit/components/extensions/profiler_get_symbols.js
diff options
context:
space:
mode:
Diffstat (limited to 'toolkit/components/extensions/profiler_get_symbols.js')
-rw-r--r--toolkit/components/extensions/profiler_get_symbols.js426
1 files changed, 426 insertions, 0 deletions
diff --git a/toolkit/components/extensions/profiler_get_symbols.js b/toolkit/components/extensions/profiler_get_symbols.js
new file mode 100644
index 0000000000..5f498a5a73
--- /dev/null
+++ b/toolkit/components/extensions/profiler_get_symbols.js
@@ -0,0 +1,426 @@
+/* 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/. */
+
+//
+// THIS FILE IS AUTOGENERATED by wasm-bindgen.
+//
+// Generated from:
+// https://github.com/mstange/profiler-get-symbols/commit/90ee39f1d18d2727f07dc57bd93cff6bc73ce8a0
+// by following the instructions in that repository's Readme.md
+//
+
+(function() {
+ const __exports = {};
+ let wasm;
+
+ let cachegetInt32Memory = null;
+ function getInt32Memory() {
+ if (cachegetInt32Memory === null || cachegetInt32Memory.buffer !== wasm.memory.buffer) {
+ cachegetInt32Memory = new Int32Array(wasm.memory.buffer);
+ }
+ return cachegetInt32Memory;
+ }
+
+ let cachegetUint32Memory = null;
+ function getUint32Memory() {
+ if (cachegetUint32Memory === null || cachegetUint32Memory.buffer !== wasm.memory.buffer) {
+ cachegetUint32Memory = new Uint32Array(wasm.memory.buffer);
+ }
+ return cachegetUint32Memory;
+ }
+
+ function getArrayU32FromWasm(ptr, len) {
+ return getUint32Memory().subarray(ptr / 4, ptr / 4 + len);
+ }
+
+ let cachegetUint8Memory = null;
+ function getUint8Memory() {
+ if (cachegetUint8Memory === null || cachegetUint8Memory.buffer !== wasm.memory.buffer) {
+ cachegetUint8Memory = new Uint8Array(wasm.memory.buffer);
+ }
+ return cachegetUint8Memory;
+ }
+
+ function getArrayU8FromWasm(ptr, len) {
+ return getUint8Memory().subarray(ptr / 1, ptr / 1 + len);
+ }
+
+ const heap = new Array(32);
+
+ heap.fill(undefined);
+
+ heap.push(undefined, null, true, false);
+
+ let stack_pointer = 32;
+
+ function addBorrowedObject(obj) {
+ if (stack_pointer == 1) throw new Error('out of js stack');
+ heap[--stack_pointer] = obj;
+ return stack_pointer;
+ }
+
+ function _assertClass(instance, klass) {
+ if (!(instance instanceof klass)) {
+ throw new Error(`expected instance of ${klass.name}`);
+ }
+ return instance.ptr;
+ }
+
+ let WASM_VECTOR_LEN = 0;
+
+ let cachedTextEncoder = new TextEncoder('utf-8');
+
+ let passStringToWasm;
+ if (typeof cachedTextEncoder.encodeInto === 'function') {
+ passStringToWasm = function(arg) {
+
+
+ let size = arg.length;
+ let ptr = wasm.__wbindgen_malloc(size);
+ let offset = 0;
+ {
+ const mem = getUint8Memory();
+ for (; offset < arg.length; offset++) {
+ const code = arg.charCodeAt(offset);
+ if (code > 0x7F) break;
+ mem[ptr + offset] = code;
+ }
+ }
+
+ if (offset !== arg.length) {
+ arg = arg.slice(offset);
+ ptr = wasm.__wbindgen_realloc(ptr, size, size = offset + arg.length * 3);
+ const view = getUint8Memory().subarray(ptr + offset, ptr + size);
+ const ret = cachedTextEncoder.encodeInto(arg, view);
+
+ offset += ret.written;
+ }
+ WASM_VECTOR_LEN = offset;
+ return ptr;
+ };
+ } else {
+ passStringToWasm = function(arg) {
+
+
+ let size = arg.length;
+ let ptr = wasm.__wbindgen_malloc(size);
+ let offset = 0;
+ {
+ const mem = getUint8Memory();
+ for (; offset < arg.length; offset++) {
+ const code = arg.charCodeAt(offset);
+ if (code > 0x7F) break;
+ mem[ptr + offset] = code;
+ }
+ }
+
+ if (offset !== arg.length) {
+ const buf = cachedTextEncoder.encode(arg.slice(offset));
+ ptr = wasm.__wbindgen_realloc(ptr, size, size = offset + buf.length);
+ getUint8Memory().set(buf, ptr + offset);
+ offset += buf.length;
+ }
+ WASM_VECTOR_LEN = offset;
+ return ptr;
+ };
+ }
+ /**
+ * @param {WasmMemBuffer} binary_data
+ * @param {WasmMemBuffer} debug_data
+ * @param {string} breakpad_id
+ * @returns {CompactSymbolTable}
+ */
+ __exports.get_compact_symbol_table = function(binary_data, debug_data, breakpad_id) {
+ _assertClass(binary_data, WasmMemBuffer);
+ _assertClass(debug_data, WasmMemBuffer);
+ const ret = wasm.get_compact_symbol_table(binary_data.ptr, debug_data.ptr, passStringToWasm(breakpad_id), WASM_VECTOR_LEN);
+ return CompactSymbolTable.__wrap(ret);
+ };
+
+function getObject(idx) { return heap[idx]; }
+
+function debugString(val) {
+ // primitive types
+ const type = typeof val;
+ if (type == 'number' || type == 'boolean' || val == null) {
+ return `${val}`;
+ }
+ if (type == 'string') {
+ return `"${val}"`;
+ }
+ if (type == 'symbol') {
+ const description = val.description;
+ if (description == null) {
+ return 'Symbol';
+ } else {
+ return `Symbol(${description})`;
+ }
+ }
+ if (type == 'function') {
+ const name = val.name;
+ if (typeof name == 'string' && name.length > 0) {
+ return `Function(${name})`;
+ } else {
+ return 'Function';
+ }
+ }
+ // objects
+ if (Array.isArray(val)) {
+ const length = val.length;
+ let debug = '[';
+ if (length > 0) {
+ debug += debugString(val[0]);
+ }
+ for(let i = 1; i < length; i++) {
+ debug += ', ' + debugString(val[i]);
+ }
+ debug += ']';
+ return debug;
+ }
+ // Test for built-in
+ const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+ let className;
+ if (builtInMatches.length > 1) {
+ className = builtInMatches[1];
+ } else {
+ // Failed to match the standard '[object ClassName]'
+ return toString.call(val);
+ }
+ if (className == 'Object') {
+ // we're a user defined class or Object
+ // JSON.stringify avoids problems with cycles, and is generally much
+ // easier than looping through ownProperties of `val`.
+ try {
+ return 'Object(' + JSON.stringify(val) + ')';
+ } catch (_) {
+ return 'Object';
+ }
+ }
+ // errors
+ if (val instanceof Error) {
+ return `${val.name}: ${val.message}\n${val.stack}`;
+ }
+ // TODO we could test for more things here, like `Set`s and `Map`s.
+ return className;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8');
+
+function getStringFromWasm(ptr, len) {
+ return cachedTextDecoder.decode(getUint8Memory().subarray(ptr, ptr + len));
+}
+
+let heap_next = heap.length;
+
+function dropObject(idx) {
+ if (idx < 36) return;
+ heap[idx] = heap_next;
+ heap_next = idx;
+}
+
+function takeObject(idx) {
+ const ret = getObject(idx);
+ dropObject(idx);
+ return ret;
+}
+
+function addHeapObject(obj) {
+ if (heap_next === heap.length) heap.push(heap.length + 1);
+ const idx = heap_next;
+ heap_next = heap[idx];
+
+ heap[idx] = obj;
+ return idx;
+}
+
+function handleError(e) {
+ wasm.__wbindgen_exn_store(addHeapObject(e));
+}
+/**
+*/
+class CompactSymbolTable {
+
+ static __wrap(ptr) {
+ const obj = Object.create(CompactSymbolTable.prototype);
+ obj.ptr = ptr;
+
+ return obj;
+ }
+
+ free() {
+ const ptr = this.ptr;
+ this.ptr = 0;
+
+ wasm.__wbg_compactsymboltable_free(ptr);
+ }
+ /**
+ * @returns {CompactSymbolTable}
+ */
+ constructor() {
+ const ret = wasm.compactsymboltable_new();
+ return CompactSymbolTable.__wrap(ret);
+ }
+ /**
+ * @returns {Uint32Array}
+ */
+ take_addr() {
+ const retptr = 8;
+ const ret = wasm.compactsymboltable_take_addr(retptr, this.ptr);
+ const memi32 = getInt32Memory();
+ const v0 = getArrayU32FromWasm(memi32[retptr / 4 + 0], memi32[retptr / 4 + 1]).slice();
+ wasm.__wbindgen_free(memi32[retptr / 4 + 0], memi32[retptr / 4 + 1] * 4);
+ return v0;
+ }
+ /**
+ * @returns {Uint32Array}
+ */
+ take_index() {
+ const retptr = 8;
+ const ret = wasm.compactsymboltable_take_index(retptr, this.ptr);
+ const memi32 = getInt32Memory();
+ const v0 = getArrayU32FromWasm(memi32[retptr / 4 + 0], memi32[retptr / 4 + 1]).slice();
+ wasm.__wbindgen_free(memi32[retptr / 4 + 0], memi32[retptr / 4 + 1] * 4);
+ return v0;
+ }
+ /**
+ * @returns {Uint8Array}
+ */
+ take_buffer() {
+ const retptr = 8;
+ const ret = wasm.compactsymboltable_take_buffer(retptr, this.ptr);
+ const memi32 = getInt32Memory();
+ const v0 = getArrayU8FromWasm(memi32[retptr / 4 + 0], memi32[retptr / 4 + 1]).slice();
+ wasm.__wbindgen_free(memi32[retptr / 4 + 0], memi32[retptr / 4 + 1] * 1);
+ return v0;
+ }
+}
+__exports.CompactSymbolTable = CompactSymbolTable;
+/**
+* WasmMemBuffer lets you allocate a chunk of memory on the wasm heap and
+* directly initialize it from JS without a copy. The constructor takes the
+* allocation size and a callback function which does the initialization.
+* This is useful if you need to get very large amounts of data from JS into
+* wasm (for example, the contents of a 1.7GB libxul.so).
+*/
+class WasmMemBuffer {
+
+ static __wrap(ptr) {
+ const obj = Object.create(WasmMemBuffer.prototype);
+ obj.ptr = ptr;
+
+ return obj;
+ }
+
+ free() {
+ const ptr = this.ptr;
+ this.ptr = 0;
+
+ wasm.__wbg_wasmmembuffer_free(ptr);
+ }
+ /**
+ * Create the buffer and initialize it synchronously in the callback function.
+ * f is called with one argument: the Uint8Array that wraps our buffer.
+ * f should not return anything; its return value is ignored.
+ * f must not call any exported wasm functions! Anything that causes the
+ * wasm heap to resize will invalidate the typed array\'s internal buffer!
+ * Do not hold on to the array that is passed to f after f completes.
+ * @param {number} byte_length
+ * @param {any} f
+ * @returns {WasmMemBuffer}
+ */
+ constructor(byte_length, f) {
+ try {
+ const ret = wasm.wasmmembuffer_new(byte_length, addBorrowedObject(f));
+ return WasmMemBuffer.__wrap(ret);
+ } finally {
+ heap[stack_pointer++] = undefined;
+ }
+ }
+}
+__exports.WasmMemBuffer = WasmMemBuffer;
+
+function init(module) {
+
+ let result;
+ const imports = {};
+ imports.wbg = {};
+ imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {
+ const ret = debugString(getObject(arg1));
+ const ret0 = passStringToWasm(ret);
+ const ret1 = WASM_VECTOR_LEN;
+ getInt32Memory()[arg0 / 4 + 0] = ret0;
+ getInt32Memory()[arg0 / 4 + 1] = ret1;
+ };
+ imports.wbg.__wbindgen_throw = function(arg0, arg1) {
+ throw new Error(getStringFromWasm(arg0, arg1));
+ };
+ imports.wbg.__wbindgen_rethrow = function(arg0) {
+ throw takeObject(arg0);
+ };
+ imports.wbg.__wbindgen_memory = function() {
+ const ret = wasm.memory;
+ return addHeapObject(ret);
+ };
+ imports.wbg.__wbg_buffer_aa8ebea80955a01a = function(arg0) {
+ const ret = getObject(arg0).buffer;
+ return addHeapObject(ret);
+ };
+ imports.wbg.__wbg_newwithbyteoffsetandlength_3e607c21646a8aef = function(arg0, arg1, arg2) {
+ const ret = new Uint8Array(getObject(arg0), arg1 >>> 0, arg2 >>> 0);
+ return addHeapObject(ret);
+ };
+ imports.wbg.__wbindgen_object_drop_ref = function(arg0) {
+ takeObject(arg0);
+ };
+ imports.wbg.__wbg_call_9c879b23724d007e = function(arg0, arg1, arg2) {
+ try {
+ const ret = getObject(arg0).call(getObject(arg1), getObject(arg2));
+ return addHeapObject(ret);
+ } catch (e) {
+ handleError(e)
+ }
+ };
+ imports.wbg.__wbindgen_json_parse = function(arg0, arg1) {
+ const ret = JSON.parse(getStringFromWasm(arg0, arg1));
+ return addHeapObject(ret);
+ };
+
+ if (module instanceof URL || typeof module === 'string' || module instanceof Request) {
+
+ const response = fetch(module);
+ if (typeof WebAssembly.instantiateStreaming === 'function') {
+ result = WebAssembly.instantiateStreaming(response, imports)
+ .catch(e => {
+ console.warn("`WebAssembly.instantiateStreaming` failed. Assuming this is because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+ return response
+ .then(r => r.arrayBuffer())
+ .then(bytes => WebAssembly.instantiate(bytes, imports));
+ });
+ } else {
+ result = response
+ .then(r => r.arrayBuffer())
+ .then(bytes => WebAssembly.instantiate(bytes, imports));
+ }
+ } else {
+
+ result = WebAssembly.instantiate(module, imports)
+ .then(result => {
+ if (result instanceof WebAssembly.Instance) {
+ return { instance: result, module };
+ } else {
+ return result;
+ }
+ });
+ }
+ return result.then(({instance, module}) => {
+ wasm = instance.exports;
+ init.__wbindgen_wasm_module = module;
+
+ return wasm;
+ });
+}
+
+self.wasm_bindgen = Object.assign(init, __exports);
+
+})();