fluencelabs/assemblyscript
1
0
Fork 0
mirror of https://github.com/fluencelabs/assemblyscript synced 2025-06-19 01:41:30 +00:00
Code Issues Projects Releases Wiki Activity

monkey-patch loader

Browse Source
This commit is contained in:
dcode
2019-05-23 04:15:05 +02:00
parent 71ea61e099
commit 81c212b208
7 changed files with 114 additions and 119 deletions
Download Patch File Download Diff File Expand all files Collapse all files

191
lib/loader/index.js
View File

@ -1,11 +1,15 @@
"use strict";
/** Size of the runtime header, in bytes. */
const HEADER_SIZE = 16;
/** Runtime header offset of `classId`. */
const CLASSID_OFFSET = -HEADER_SIZE;
/** Runtime header offset of `payloadLength`. */
const PAYLOADLENGTH_OFFSET = -HEADER_SIZE + 4;
/** Relative header `id` offset. */
const ID_OFFSET = -8;
/** Relative header `size` offset. */
const SIZE_OFFSET = -4;
/** Unique runtime id of an `ArrayBuffer`. */
const ARRAYBUFFER_ID = 0;
/** Unique runtime id of a `String`. */
const STRING_ID = 1;
/** Whether BigInt arrays are supported. */
const SUPPORTS_BIGINT = typeof BigUint64Array !== "undefined";
/** Unique symbol for memoized 'this'. */
@ -13,19 +17,18 @@ const THIS = Symbol();
/** Gets a string from an U32 and an U16 view on a memory. */
function getStringImpl(U32, U16, ptr) {
var size32 = U32[(ptr + PAYLOADLENGTH_OFFSET) >>> 2];
var offset16 = ptr >>> 1;
var remain32 = size32;
var length = U32[(ptr + SIZE_OFFSET) >>> 2] >>> 1;
var offset = ptr >>> 1;
var parts = [];
const chunkSize = 1024;
while (remain32 > chunkSize) {
let last = U16[offset16 + chunkSize - 1];
while (length > chunkSize) {
let last = U16[offset + chunkSize - 1];
let size = last >= 0xD800 && last < 0xDC00 ? chunkSize - 1 : chunkSize;
let part = U16.subarray(offset16, offset16 += size);
let part = U16.subarray(offset, offset += size);
parts.push(String.fromCharCode.apply(String, part));
remain32 -= size;
length -= size;
}
return parts.join("") + String.fromCharCode.apply(String, U16.subarray(offset16, offset16 + remain32));
return parts.join("") + String.fromCharCode.apply(String, U16.subarray(offset, offset + length));
}
/** Prepares the base module prior to instantiation. */
@ -58,11 +61,11 @@ function preInstantiate(imports) {
function postInstantiate(baseModule, instance) {
var rawExports = instance.exports;
var memory = rawExports.memory;
var memory_allocate = rawExports["memory.allocate"];
var alloc = rawExports["__alloc"];
var free = rawExports["__free"];
var setargc = rawExports["__setargc"] || function() {};
var memory_fill = rawExports["memory.fill"];
var memory_free = rawExports["memory.free"];
var table = rawExports.table;
var setargc = rawExports["$.setArgc"] || function() {};
// Provide views for all sorts of basic values
var buffer, I8, U8, I16, U16, I32, U32, F32, F64, I64, U64;
@ -90,12 +93,10 @@ function postInstantiate(baseModule, instance) {
/** Allocates a new string in the module's memory and returns its pointer. */
function newString(str) {
var dataLength = str.length;
var ptr = memory_allocate(4 + (dataLength << 1));
var dataOffset = (4 + ptr) >>> 1;
var length = str.length;
var ptr = alloc(length << 1, STRING_ID);
checkMem();
U32[ptr >>> 2] = dataLength;
for (let i = 0; i < dataLength; ++i) U16[dataOffset + i] = str.charCodeAt(i);
for (let i = 0, j = ptr >>> 1; i < length; ++i) U16[j + i] = str.charCodeAt(i);
return ptr;
}
@ -109,88 +110,88 @@ function postInstantiate(baseModule, instance) {
baseModule.getString = getString;
function computeBufferSize(byteLength) {
const HEADER_SIZE = 8;
return 1 << (32 - Math.clz32(byteLength + HEADER_SIZE - 1));
}
// function computeBufferSize(byteLength) {
// const HEADER_SIZE = 8;
// return 1 << (32 - Math.clz32(byteLength + HEADER_SIZE - 1));
// }
/** Creates a new typed array in the module's memory and returns its pointer. */
function newArray(view, length, unsafe) {
var ctor = view.constructor;
if (ctor === Function) { // TypedArray constructor created in memory
ctor = view;
view = null;
} else { // TypedArray instance copied into memory
if (length === undefined) length = view.length;
}
var elementSize = ctor.BYTES_PER_ELEMENT;
if (!elementSize) throw Error("not a typed array");
var byteLength = elementSize * length;
var ptr = memory_allocate(12); // TypedArray header
var buf = memory_allocate(computeBufferSize(byteLength)); // ArrayBuffer
checkMem();
U32[ ptr >>> 2] = buf; // .buffer
U32[(ptr + 4) >>> 2] = 0; // .byteOffset
U32[(ptr + 8) >>> 2] = byteLength; // .byteLength
U32[ buf >>> 2] = byteLength; // .byteLength
U32[(buf + 4) >>> 2] = 0; // 0
if (view) {
new ctor(buffer, buf + 8, length).set(view);
if (view.length < length && !unsafe) {
let setLength = elementSize * view.length;
memory_fill(buf + 8 + setLength, 0, byteLength - setLength);
}
} else if (!unsafe) {
memory_fill(buf + 8, 0, byteLength);
}
return ptr;
}
// /** Creates a new typed array in the module's memory and returns its pointer. */
// function newArray(view, length, unsafe) {
// var ctor = view.constructor;
// if (ctor === Function) { // TypedArray constructor created in memory
// ctor = view;
// view = null;
// } else { // TypedArray instance copied into memory
// if (length === undefined) length = view.length;
// }
// var elementSize = ctor.BYTES_PER_ELEMENT;
// if (!elementSize) throw Error("not a typed array");
// var byteLength = elementSize * length;
// var ptr = alloc(12); // TypedArray header
// var buf = alloc(computeBufferSize(byteLength)); // ArrayBuffer
// checkMem();
// U32[ ptr >>> 2] = buf; // .buffer
// U32[(ptr + 4) >>> 2] = 0; // .byteOffset
// U32[(ptr + 8) >>> 2] = byteLength; // .byteLength
// U32[ buf >>> 2] = byteLength; // .byteLength
// U32[(buf + 4) >>> 2] = 0; // 0
// if (view) {
// new ctor(buffer, buf + 8, length).set(view);
// if (view.length < length && !unsafe) {
// let setLength = elementSize * view.length;
// memory_fill(buf + 8 + setLength, 0, byteLength - setLength);
// }
// } else if (!unsafe) {
// memory_fill(buf + 8, 0, byteLength);
// }
// return ptr;
// }
baseModule.newArray = newArray;
// baseModule.newArray = newArray;
/** Gets a view on a typed array in the module's memory by its pointer. */
function getArray(ctor, ptr) {
var elementSize = ctor.BYTES_PER_ELEMENT;
if (!elementSize) throw Error("not a typed array");
checkMem();
var buf = U32[ ptr >>> 2];
var byteOffset = U32[(ptr + 4) >>> 2];
var byteLength = U32[(ptr + 8) >>> 2];
return new ctor(buffer, buf + 8 + byteOffset, (byteLength - byteOffset) / elementSize);
}
// /** Gets a view on a typed array in the module's memory by its pointer. */
// function getArray(ctor, ptr) {
// var elementSize = ctor.BYTES_PER_ELEMENT;
// if (!elementSize) throw Error("not a typed array");
// checkMem();
// var buf = U32[ ptr >>> 2];
// var byteOffset = U32[(ptr + 4) >>> 2];
// var byteLength = U32[(ptr + 8) >>> 2];
// return new ctor(buffer, buf + 8 + byteOffset, (byteLength - byteOffset) / elementSize);
// }
baseModule.getArray = getArray;
// baseModule.getArray = getArray;
/** Frees a typed array in the module's memory. Must not be accessed anymore afterwards. */
function freeArray(ptr) {
checkMem();
var buf = U32[ptr >>> 2];
memory_free(buf);
memory_free(ptr);
}
// /** Frees a typed array in the module's memory. Must not be accessed anymore afterwards. */
// function freeArray(ptr) {
// checkMem();
// var buf = U32[ptr >>> 2];
// free(buf);
// free(ptr);
// }
baseModule.freeArray = freeArray;
// baseModule.freeArray = freeArray;
/**
* Creates a new function in the module's table and returns its pointer. Note that only actual
* WebAssembly functions, i.e. as exported by the module, are supported.
*/
function newFunction(fn) {
if (typeof fn.original === "function") fn = fn.original;
var index = table.length;
table.grow(1);
table.set(index, fn);
return index;
}
// /**
// * Creates a new function in the module's table and returns its pointer. Note that only actual
// * WebAssembly functions, i.e. as exported by the module, are supported.
// */
// function newFunction(fn) {
// if (typeof fn.original === "function") fn = fn.original;
// var index = table.length;
// table.grow(1);
// table.set(index, fn);
// return index;
// }
baseModule.newFunction = newFunction;
// baseModule.newFunction = newFunction;
/** Gets a function by its pointer. */
function getFunction(ptr) {
return wrapFunction(table.get(ptr), setargc);
}
// /** Gets a function by its pointer. */
// function getFunction(ptr) {
// return wrapFunction(table.get(ptr), setargc);
// }
baseModule.getFunction = getFunction;
// baseModule.getFunction = getFunction;
// Pull basic exports to baseModule so code in preInstantiate can use them
baseModule.memory = baseModule.memory || memory;
@ -253,7 +254,7 @@ exports.instantiateStreaming = instantiateStreaming;
/** Demangles an AssemblyScript module's exports to a friendly object structure. */
function demangle(exports, baseModule) {
var module = baseModule ? Object.create(baseModule) : {};
var setargc = exports[".setargc"] || function() {};
var setargc = exports["__setargc"] || function() {};
function hasOwnProperty(elem, prop) {
return Object.prototype.hasOwnProperty.call(elem, prop);
}