Move isConst into validation, check mutability of globals

packages/helper-module-context/src/index.js

@@ -207,7 +207,7 @@ export class ModuleContext {
 
   defineGlobal(global /*: Global*/) {
     const type = global.globalType.valtype;
-    const mutability = global.mutability;
+    const mutability = global.globalType.mutability;
 
     this.globals.push({ type, mutability });
 

packages/validation/src/index.js

@@ -1,13 +1,12 @@
 // @flow
 
 import importOrderValidate from "./import-order";
+import isConst from "./is-const";
 import typeChecker from "./type-checker";
+import { moduleContextFromModuleAST } from "@webassemblyjs/helper-module-context";
 
 export default function validateAST(ast: Program) {
-  const errors = [];
-
-  errors.push(...importOrderValidate(ast));
-  errors.push(...typeChecker(ast));
+  const errors = getValidationErrors(ast);
 
   if (errors.length !== 0) {
     const errorMessage = "Validation errors:\n" + errors.join("\n");
@@ -16,7 +15,19 @@ export default function validateAST(ast: Program) {
   }
 }
 
-export { isConst } from "./is-const";
+export function getValidationErrors(ast: Program): Array<string> {
+  const errors = [];
+  const moduleContext = moduleContextFromModuleAST(ast.body[0]);
+
+  errors.push(...isConst(ast, moduleContext));
+  errors.push(...importOrderValidate(ast));
+  errors.push(...typeChecker(ast, moduleContext));
+
+  return errors
+}
+
 export { getType, typeEq } from "./type-inference";
+export { isConst };
 
 export const stack = typeChecker;
+

packages/validation/src/is-const.js

@@ -1,5 +1,7 @@
 // @flow
 
+import { traverse } from "@webassemblyjs/ast";
+
 /**
  * Determine if a sequence of instructions form a constant expression
  *
@@ -8,31 +10,39 @@
  * TODO(sven): get_global x should check the mutability of x, but we don't have
  * access to the program at this point.
  */
-export function isConst(instrs: Array<Instruction>): boolean {
-  if (instrs.length === 0) {
-    return false;
-  }
+export default function isConst(ast: Program, moduleContext): Array<string> {
 
-  return instrs.reduce((acc, instr) => {
-    // Bailout
-    if (acc === false) {
-      return acc;
-    }
+  function isConstInstruction(instr) {
+      if (instr.id === "const") {
+        return true;
+      }
 
-    if (instr.id === "const") {
-      return true;
-    }
+      if (instr.id === "get_global") {
+        const index = instr.args[0].value
+        return !moduleContext.isMutableGlobal(index);
+      }
 
-    if (instr.id === "get_global") {
-      return true;
-    }
+      // FIXME(sven): this shoudln't be needed, we need to inject our end
+      // instructions after the validations
+      if (instr.id === "end") {
+        return true;
+      }
 
-    // FIXME(sven): this shoudln't be needed, we need to inject our end
-    // instructions after the validations
-    if (instr.id === "end") {
-      return true;
+      return false;
+  }
+
+  let index = 0;
+  const errors = []
+
+  traverse(ast, {
+    Global(path) {
+      const isValid = path.node.init.reduce((acc, instr) => acc && isConstInstruction(instr), true)
+      if(!isValid) {
+        errors.push('initializer expression cannot reference mutable global')
+      }
     }
+  })
 
-    return false;
-  }, true);
+  return errors;
 }
+

packages/validation/src/type-checker.js

@@ -30,14 +30,11 @@ function checkTypes(a, b) {
   }
 }
 
-export default function validate(ast) {
+export default function validate(ast, moduleContext) {
   if (!ast.body || !ast.body[0] || !ast.body[0].fields) {
     return [];
   }
 
-  // Module context
-  const moduleContext = moduleContextFromModuleAST(ast.body[0]);
-
   errors = [];
 
   // Simulate stack types throughout all function bodies

packages/validation/test/fixtures/global-initilizer/module.wast → packages/validation/test/fixtures/global-initializer/module.wast

@@ -1,4 +1,7 @@
 (module
   (global (mut i32) (i32.const 1))
   (global i32 (get_global 0))
+
+  (global i32 (i32.const 0))
+  (global i32 (get_global 1))
 )

packages/validation/test/fixtures/global-initializer/output.txt

@@ -0,0 +1 @@
+initializer expression cannot reference mutable global

packages/validation/test/index.js

@@ -22,7 +22,7 @@ describe("validation", () => {
 
   describe("wast", () => {
     const pre = f => {
-      const errors = validations.stack(parse(f));
+      const errors = validations.getValidationErrors(parse(f));
 
       return errorsToString(errors);
     };
@@ -35,7 +35,7 @@ describe("validation", () => {
       const module = wabt.parseWat(suite, f);
       const { buffer } = module.toBinary({ write_debug_names: false });
 
-      const errors = validations.stack(decode(buffer));
+      const errors = validations.getValidationErrors(decode(buffer));
 
       return errorsToString(errors);
     };

packages/webassemblyjs/src/interpreter/runtime/values/global.js

@@ -1,6 +1,6 @@
 // @flow
 
-import { isConst, getType, typeEq } from "@webassemblyjs/validation";
+import { getType, typeEq } from "@webassemblyjs/validation";
 
 const { evaluate } = require("../../partial-evaluation");
 const { CompileError } = require("../../../errors");
@@ -12,10 +12,6 @@ export function createInstance(
   let value;
   const { valtype, mutability } = node.globalType;
 
-  if (node.init.length > 0 && isConst(node.init) === false) {
-    throw new CompileError("constant expression required");
-  }
-
   // None or multiple constant expressions in the initializer seems not possible
   // TODO(sven): find a specification reference for that
   // FIXME(sven): +1 because of the implicit end, change the order of validations