webpack 4.9.1 → 4.10.2

package/lib/wasm/WebAssemblyGenerator.js

@@ -5,14 +5,40 @@
 "use strict";
 
 const Generator = require("../Generator");
+const Template = require("../Template");
+const WebAssemblyUtils = require("./WebAssemblyUtils");
 const { RawSource } = require("webpack-sources");
 
+const { shrinkPaddedLEB128 } = require("@webassemblyjs/wasm-opt");
 const { editWithAST, addWithAST } = require("@webassemblyjs/wasm-edit");
 const { decode } = require("@webassemblyjs/wasm-parser");
 const t = require("@webassemblyjs/ast");
 
+/** @typedef {import("../Module")} Module */
+/** @typedef {import("./WebAssemblyUtils").UsedWasmDependency} UsedWasmDependency */
+
+/**
+ * @typedef {(ArrayBuffer) => ArrayBuffer} ArrayBufferTransform
+ */
+
+/**
+ * Run some preprocessing on the binary before wasm-edit
+ *
+ * @param {ArrayBuffer} ab - original binary
+ * @returns {ArrayBufferTransform} transform
+ */
+function preprocess(ab) {
+	const optBin = shrinkPaddedLEB128(new Uint8Array(ab));
+	return optBin.buffer;
+}
+
+/**
+ * @template T
+ * @param {Function[]} fns transforms
+ * @returns {Function} composed transform
+ */
 function compose(...fns) {
-	return fns.reverse().reduce((prevFn, nextFn) => {
+	return fns.reduce((prevFn, nextFn) => {
 		return value => nextFn(prevFn(value));
 	}, value => value);
 }
@@ -31,12 +57,7 @@ const isGlobalImport = n => n.descr.type === "GlobalType";
  */
 const isFuncImport = n => n.descr.type === "FuncImportDescr";
 
-const initFuncId = t.identifier("__webpack_init__");
-
 // TODO replace with @callback
-/**
- * @typedef {(ArrayBuffer) => ArrayBuffer} ArrayBufferTransform
- */
 
 /**
  * Removes the start instruction
@@ -166,14 +187,33 @@ const rewriteImportedGlobals = state => bin => {
 
 				globalType.mutability = "var";
 
-				newGlobals.push(
-					t.global(globalType, [
-						t.objectInstruction("const", "i32", [t.numberLiteral(0)])
-					])
-				);
+				let init;
+
+				if (globalType.valtype[0] === "i") {
+					// create NumberLiteral global initializer
+					init = t.objectInstruction("const", globalType.valtype, [
+						t.numberLiteralFromRaw(0)
+					]);
+				} else if (globalType.valtype[0] === "f") {
+					// create FloatLiteral global initializer
+					init = t.objectInstruction("const", globalType.valtype, [
+						t.floatLiteral(0, false, false, "0")
+					]);
+				} else {
+					throw new Error("unknown type: " + globalType.valtype);
+				}
+
+				newGlobals.push(t.global(globalType, [init]));
 
 				path.remove();
 			}
+		},
+
+		// in order to preserve non-imported global's order we need to re-inject
+		// those as well
+		Global(path) {
+			newGlobals.push(path.node);
+			path.remove();
 		}
 	});
 
@@ -181,6 +221,49 @@ const rewriteImportedGlobals = state => bin => {
 	return addWithAST(state.ast, bin, newGlobals);
 };
 
+/**
+ * Rewrite the export names
+ * @param {Object} state state
+ * @param {Object} state.ast Module's ast
+ * @param {Object} state.module Module
+ * @returns {ArrayBufferTransform} transform
+ */
+const rewriteExportNames = ({ ast, module }) => bin => {
+	return editWithAST(ast, bin, {
+		ModuleExport(path) {
+			const usedName = module.isUsed(path.node.name);
+			if (usedName) {
+				path.node.name = usedName;
+			} else {
+				path.remove();
+			}
+		}
+	});
+};
+
+/**
+ * Mangle import names and modules
+ * @param {Object} state state
+ * @param {Object} state.ast Module's ast
+ * @param {Map<string, UsedWasmDependency>} state.usedDependencyMap mappings to mangle names
+ * @returns {ArrayBufferTransform} transform
+ */
+const rewriteImports = ({ ast, usedDependencyMap }) => bin => {
+	return editWithAST(ast, bin, {
+		ModuleImport(path) {
+			const result = usedDependencyMap.get(
+				path.node.module + ":" + path.node.name
+			);
+			if (result === undefined) {
+				path.remove();
+			} else {
+				path.node.module = WebAssemblyUtils.MANGLED_MODULE;
+				path.node.name = result.name;
+			}
+		}
+	});
+};
+
 /**
  * Add an init function.
  *
@@ -188,6 +271,7 @@ const rewriteImportedGlobals = state => bin => {
  *
  * @param {Object} state transformation state
  * @param {Object} state.ast - Module's ast
+ * @param {t.Identifier} state.initFuncId identifier of the init function
  * @param {t.IndexLiteral} state.startAtFuncIndex index of the start function
  * @param {t.ModuleImport[]} state.importedGlobals list of imported globals
  * @param {t.IndexLiteral} state.nextFuncIndex index of the next function
@@ -196,6 +280,7 @@ const rewriteImportedGlobals = state => bin => {
  */
 const addInitFunction = ({
 	ast,
+	initFuncId,
 	startAtFuncIndex,
 	importedGlobals,
 	nextFuncIndex,
@@ -225,30 +310,56 @@ const addInitFunction = ({
 	const funcResults = [];
 
 	// Code section
-	const func = t.func(initFuncId, funcParams, funcResults, funcBody);
+	const funcSignature = t.signature(funcParams, funcResults);
+	const func = t.func(initFuncId, funcSignature, funcBody);
 
 	// Type section
-	const functype = t.typeInstructionFunc(
-		func.signature.params,
-		func.signature.result
-	);
+	const functype = t.typeInstruction(undefined, funcSignature);
 
 	// Func section
 	const funcindex = t.indexInFuncSection(nextTypeIndex);
 
 	// Export section
-	const moduleExport = t.moduleExport(initFuncId.value, "Func", nextFuncIndex);
+	const moduleExport = t.moduleExport(
+		initFuncId.value,
+		t.moduleExportDescr("Func", nextFuncIndex)
+	);
 
 	return addWithAST(ast, bin, [func, moduleExport, funcindex, functype]);
 };
 
+/**
+ * Extract mangle mappings from module
+ * @param {Module} module current module
+ * @returns {Map<string, UsedWasmDependency>} mappings to mangled names
+ */
+const getUsedDependencyMap = module => {
+	/** @type {Map<string, UsedWasmDependency>} */
+	const map = new Map();
+	for (const usedDep of WebAssemblyUtils.getUsedDependencies(module)) {
+		const dep = usedDep.dependency;
+		const request = dep.request;
+		const exportName = dep.name;
+		map.set(request + ":" + exportName, usedDep);
+	}
+	return map;
+};
+
 class WebAssemblyGenerator extends Generator {
 	generate(module) {
-		const bin = module.originalSource().source();
+		let bin = module.originalSource().source();
+		bin = preprocess(bin);
+
+		const initFuncId = t.identifier(
+			Array.isArray(module.usedExports)
+				? Template.numberToIdentifer(module.usedExports.length)
+				: "__webpack_init__"
+		);
 
 		const ast = decode(bin, {
 			ignoreDataSection: true,
-			ignoreCodeSection: true
+			ignoreCodeSection: true,
+			ignoreCustomNameSection: true
 		});
 
 		const importedGlobals = getImportedGlobals(ast);
@@ -257,13 +368,26 @@ class WebAssemblyGenerator extends Generator {
 		const nextFuncIndex = getNextFuncIndex(ast, countImportedFunc);
 		const nextTypeIndex = getNextTypeIndex(ast);
 
+		const usedDependencyMap = getUsedDependencyMap(module);
+
 		const transform = compose(
+			rewriteExportNames({
+				ast,
+				module
+			}),
+
 			removeStartFunc({ ast }),
 
 			rewriteImportedGlobals({ ast }),
 
+			rewriteImports({
+				ast,
+				usedDependencyMap
+			}),
+
 			addInitFunction({
 				ast,
+				initFuncId,
 				importedGlobals,
 				startAtFuncIndex,
 				nextFuncIndex,

package/lib/wasm/WebAssemblyJavascriptGenerator.js

@@ -1,107 +1,90 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const Generator = require("../Generator");
-const Template = require("../Template");
-const { RawSource } = require("webpack-sources");
-const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
-
-function generateInitParams(module) {
-	const list = [];
-
-	for (const dep of module.dependencies) {
-		if (dep instanceof WebAssemblyImportDependency) {
-			if (dep.description.type === "GlobalType") {
-				const exportName = dep.name;
-				const usedName = dep.module && dep.module.isUsed(exportName);
-
-				if (dep.module === null) {
-					// Dependency was not found, an error will be thrown later
-					continue;
-				}
-
-				if (usedName !== false) {
-					list.push(
-						`__webpack_require__(${JSON.stringify(
-							dep.module.id
-						)})[${JSON.stringify(usedName)}]`
-					);
-				}
-			}
-		}
-	}
-
-	return list;
-}
-
-class WebAssemblyJavascriptGenerator extends Generator {
-	generate(module, dependencyTemplates, runtimeTemplate) {
-		const generateExports = () => {
-			if (
-				Array.isArray(module.buildMeta.providedExports) &&
-				Array.isArray(module.usedExports)
-			) {
-				// generate mangled exports
-				return Template.asString(
-					module.buildMeta.providedExports.map(exp => {
-						const usedName = module.isUsed(exp);
-						if (usedName) {
-							return `${module.exportsArgument}[${JSON.stringify(
-								usedName
-							)}] = instance.exports[${JSON.stringify(exp)}];`;
-						} else {
-							return `// unused ${JSON.stringify(exp)} export`;
-						}
-					})
-				);
-			} else {
-				// generate simple export
-				return `${module.moduleArgument}.exports = instance.exports;`;
-			}
-		};
-
-		const generateImports = () => {
-			const modules = new Map();
-			for (const dep of module.dependencies) {
-				if (dep.module) modules.set(dep.module, dep.userRequest);
-			}
-			return Template.asString(
-				Array.from(modules, ([m, r]) => {
-					return `${runtimeTemplate.moduleRaw({
-						module: m,
-						request: r
-					})};`;
-				})
-			);
-		};
-
-		// FIXME(sven): assert that the exports exists in the modules
-		// otherwise it will default to i32 0
-		const initParams = generateInitParams(module).join(",");
-
-		// create source
-		const source = new RawSource(
-			[
-				'"use strict";',
-				"// Instantiate WebAssembly module",
-				"var instance = __webpack_require__.w[module.i];",
-
-				// this must be before import for circular dependencies
-				"// export exports from WebAssembly module",
-				generateExports(),
-
-				"// exec imports from WebAssembly module (for esm order)",
-				generateImports(),
-
-				"// exec wasm module",
-				`instance.exports.__webpack_init__(${initParams})`
-			].join("\n")
-		);
-		return source;
-	}
-}
-
-module.exports = WebAssemblyJavascriptGenerator;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const Generator = require("../Generator");
+const Template = require("../Template");
+const { RawSource } = require("webpack-sources");
+const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
+
+function generateInitParams(module) {
+	const list = [];
+
+	for (const dep of module.dependencies) {
+		if (dep instanceof WebAssemblyImportDependency) {
+			if (dep.description.type === "GlobalType") {
+				const exportName = dep.name;
+				const usedName = dep.module && dep.module.isUsed(exportName);
+
+				if (dep.module === null) {
+					// Dependency was not found, an error will be thrown later
+					continue;
+				}
+
+				if (usedName !== false) {
+					list.push(
+						`__webpack_require__(${JSON.stringify(
+							dep.module.id
+						)})[${JSON.stringify(usedName)}]`
+					);
+				}
+			}
+		}
+	}
+
+	return list;
+}
+
+class WebAssemblyJavascriptGenerator extends Generator {
+	generate(module, dependencyTemplates, runtimeTemplate) {
+		const initIdentifer = Array.isArray(module.usedExports)
+			? Template.numberToIdentifer(module.usedExports.length)
+			: "__webpack_init__";
+
+		const generateImports = () => {
+			const modules = new Map();
+			for (const dep of module.dependencies) {
+				if (dep.module) modules.set(dep.module, dep.userRequest);
+			}
+			return Template.asString(
+				Array.from(modules, ([m, r]) => {
+					return `${runtimeTemplate.moduleRaw({
+						module: m,
+						request: r
+					})};`;
+				})
+			);
+		};
+
+		// FIXME(sven): assert that the exports exists in the modules
+		// otherwise it will default to i32 0
+		const initParams = generateInitParams(module).join(",");
+
+		// create source
+		const source = new RawSource(
+			[
+				'"use strict";',
+				"// Instantiate WebAssembly module",
+				"var wasmExports = __webpack_require__.w[module.i];",
+
+				// this must be before import for circular dependencies
+				"// export exports from WebAssembly module",
+				Array.isArray(module.usedExports)
+					? `${module.moduleArgument}.exports = wasmExports;`
+					: "for(var name in wasmExports) " +
+					  `if(name != ${JSON.stringify(initIdentifer)}) ` +
+					  `${module.exportsArgument}[name] = wasmExports[name];`,
+				"// exec imports from WebAssembly module (for esm order)",
+				generateImports(),
+
+				"// exec wasm module",
+				`wasmExports[${JSON.stringify(initIdentifer)}](${initParams})`
+			].join("\n")
+		);
+		return source;
+	}
+}
+
+module.exports = WebAssemblyJavascriptGenerator;

package/lib/wasm/WebAssemblyModulesPlugin.js

@@ -1,80 +1,80 @@
-/*
-	MIT License http://www.opensource.org/licenses/mit-license.php
-	Author Tobias Koppers @sokra
-*/
-"use strict";
-
-const Generator = require("../Generator");
-const WebAssemblyParser = require("./WebAssemblyParser");
-const WebAssemblyGenerator = require("./WebAssemblyGenerator");
-const WebAssemblyJavascriptGenerator = require("./WebAssemblyJavascriptGenerator");
-const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
-
-class WebAssemblyModulesPlugin {
-	apply(compiler) {
-		compiler.hooks.compilation.tap(
-			"WebAssemblyModulesPlugin",
-			(compilation, { normalModuleFactory }) => {
-				compilation.dependencyFactories.set(
-					WebAssemblyImportDependency,
-					normalModuleFactory
-				);
-
-				normalModuleFactory.hooks.createParser
-					.for("webassembly/experimental")
-					.tap("WebAssemblyModulesPlugin", () => {
-						return new WebAssemblyParser();
-					});
-
-				normalModuleFactory.hooks.createGenerator
-					.for("webassembly/experimental")
-					.tap("WebAssemblyModulesPlugin", () => {
-						return Generator.byType({
-							javascript: new WebAssemblyJavascriptGenerator(),
-							webassembly: new WebAssemblyGenerator()
-						});
-					});
-
-				compilation.chunkTemplate.hooks.renderManifest.tap(
-					"WebAssemblyModulesPlugin",
-					(result, options) => {
-						const chunk = options.chunk;
-						const outputOptions = options.outputOptions;
-						const moduleTemplates = options.moduleTemplates;
-						const dependencyTemplates = options.dependencyTemplates;
-
-						for (const module of chunk.modulesIterable) {
-							if (module.type && module.type.startsWith("webassembly")) {
-								const filenameTemplate =
-									outputOptions.webassemblyModuleFilename;
-
-								result.push({
-									render: () =>
-										this.renderWebAssembly(
-											module,
-											moduleTemplates.webassembly,
-											dependencyTemplates
-										),
-									filenameTemplate,
-									pathOptions: {
-										module
-									},
-									identifier: `webassemblyModule${module.id}`,
-									hash: module.hash
-								});
-							}
-						}
-
-						return result;
-					}
-				);
-			}
-		);
-	}
-
-	renderWebAssembly(module, moduleTemplate, dependencyTemplates) {
-		return moduleTemplate.render(module, dependencyTemplates, {});
-	}
-}
-
-module.exports = WebAssemblyModulesPlugin;
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+"use strict";
+
+const Generator = require("../Generator");
+const WebAssemblyParser = require("./WebAssemblyParser");
+const WebAssemblyGenerator = require("./WebAssemblyGenerator");
+const WebAssemblyJavascriptGenerator = require("./WebAssemblyJavascriptGenerator");
+const WebAssemblyImportDependency = require("../dependencies/WebAssemblyImportDependency");
+
+class WebAssemblyModulesPlugin {
+	apply(compiler) {
+		compiler.hooks.compilation.tap(
+			"WebAssemblyModulesPlugin",
+			(compilation, { normalModuleFactory }) => {
+				compilation.dependencyFactories.set(
+					WebAssemblyImportDependency,
+					normalModuleFactory
+				);
+
+				normalModuleFactory.hooks.createParser
+					.for("webassembly/experimental")
+					.tap("WebAssemblyModulesPlugin", () => {
+						return new WebAssemblyParser();
+					});
+
+				normalModuleFactory.hooks.createGenerator
+					.for("webassembly/experimental")
+					.tap("WebAssemblyModulesPlugin", () => {
+						return Generator.byType({
+							javascript: new WebAssemblyJavascriptGenerator(),
+							webassembly: new WebAssemblyGenerator()
+						});
+					});
+
+				compilation.chunkTemplate.hooks.renderManifest.tap(
+					"WebAssemblyModulesPlugin",
+					(result, options) => {
+						const chunk = options.chunk;
+						const outputOptions = options.outputOptions;
+						const moduleTemplates = options.moduleTemplates;
+						const dependencyTemplates = options.dependencyTemplates;
+
+						for (const module of chunk.modulesIterable) {
+							if (module.type && module.type.startsWith("webassembly")) {
+								const filenameTemplate =
+									outputOptions.webassemblyModuleFilename;
+
+								result.push({
+									render: () =>
+										this.renderWebAssembly(
+											module,
+											moduleTemplates.webassembly,
+											dependencyTemplates
+										),
+									filenameTemplate,
+									pathOptions: {
+										module
+									},
+									identifier: `webassemblyModule${module.id}`,
+									hash: module.hash
+								});
+							}
+						}
+
+						return result;
+					}
+				);
+			}
+		);
+	}
+
+	renderWebAssembly(module, moduleTemplate, dependencyTemplates) {
+		return moduleTemplate.render(module, dependencyTemplates, {});
+	}
+}
+
+module.exports = WebAssemblyModulesPlugin;

package/lib/wasm/WebAssemblyParser.js

@@ -24,6 +24,25 @@ const isMemoryImport = n => n.descr.type === "Memory";
  */
 const isTableImport = n => n.descr.type === "Table";
 
+const JS_COMPAT_TYPES = new Set(["i32", "f32", "f64"]);
+
+/**
+ * @param {t.ModuleImport} moduleImport the import
+ * @returns {null | string} the type incompatible with js types
+ */
+const getJsIncompatibleType = moduleImport => {
+	if (moduleImport.descr.type !== "FuncImportDescr") return null;
+	const signature = moduleImport.descr.signature;
+	for (const param of signature.params) {
+		if (!JS_COMPAT_TYPES.has(param.valtype))
+			return `${param.valtype} as parameter`;
+	}
+	for (const type of signature.results) {
+		if (!JS_COMPAT_TYPES.has(type)) return `${type} as result`;
+	}
+	return null;
+};
+
 const decoderOpts = {
 	ignoreCodeSection: true,
 	ignoreDataSection: true
@@ -51,14 +70,18 @@ class WebAssemblyParser extends Tapable {
 			},
 
 			ModuleImport({ node }) {
+				/** @type {false | string} */
 				let onlyDirectImport = false;
 
 				if (isMemoryImport(node) === true) {
-					onlyDirectImport = true;
-				}
-
-				if (isTableImport(node) === true) {
-					onlyDirectImport = true;
+					onlyDirectImport = "Memory";
+				} else if (isTableImport(node) === true) {
+					onlyDirectImport = "Table";
+				} else {
+					const incompatibleType = getJsIncompatibleType(node);
+					if (incompatibleType) {
+						onlyDirectImport = `Non-JS-compatible Func Sigurature (${incompatibleType})`;
+					}
 				}
 
 				const dep = new WebAssemblyImportDependency(