[WIP] Decompiler

.gitignore

@@ -3,3 +3,6 @@ docs/
 node_modules/
 out/
 raw/
+.history
+.vscode
+.idea

cli/asc.js

@@ -92,35 +92,43 @@ exports.definitionFiles = exports.isBundle ? BUNDLE_DEFINITIONS : (() => { // se
 })();
 
 /** Convenience function that parses and compiles source strings directly. */
-exports.compileString = (sources, options) => {
+exports.compileString = async (sources, options) => {
   if (typeof sources === "string") sources = { "input.ts": sources };
   const output = Object.create({
     stdout: createMemoryStream(),
     stderr: createMemoryStream(),
     binary: null,
     text: null
   });
-  var argv = [
-    "--binaryFile", "binary",
-    "--textFile", "text",
-  ];
+  debugger;
+  var argv = [];
   Object.keys(options || {}).forEach(key => {
-    var val = options[key];
-    if (Array.isArray(val)) val.forEach(val => argv.push("--" + key, String(val)));
-    else argv.push("--" + key, String(val));
+    if (key != "readFile" && key != 'writeFile'){
+      var val = options[key];
+      debugger;
+      if (Array.isArray(val)) val.forEach(val => argv.push("--" + key, String(val)));
+      else argv.push("--" + key, String(val));
+    }
   });
-  exports.main(argv.concat(Object.keys(sources)), {
+  await exports.main(argv.concat(Object.keys(sources)), {
     stdout: output.stdout,
     stderr: output.stderr,
-    readFile: name => sources.hasOwnProperty(name) ? sources[name] : null,
-    writeFile: (name, contents) => output[name] = contents,
+    readFile: async (name) =>  {
+      try {
+        return await options.readFile(name);
+      }catch (e){
+        return null;
+      }
+      },
+    writeFile: async (name, contents) => await options.writeFile(name, contents),
     listFiles: () => []
   });
+  debugger;
   return output;
 }
 
 /** Runs the command line utility using the specified arguments array. */
-exports.main = function main(argv, options, callback) {
+exports.main = async function main(argv, options, callback) {
   if (typeof options === "function") {
     callback = options;
     options = {};
@@ -228,7 +236,7 @@ exports.main = function main(argv, options, callback) {
 
   // Begin parsing
   var parser = null;
-
+  debugger;
   // Include library files
   if (!args.noLib) {
     Object.keys(exports.libraryFiles).forEach(libPath => {
@@ -270,7 +278,7 @@ exports.main = function main(argv, options, callback) {
       }
       for (let j = 0, l = libFiles.length; j < l; ++j) {
         let libPath = libFiles[j];
-        let libText = readFile(path.join(libDir, libPath));
+        let libText = await readFile(path.join(libDir, libPath));
         if (libText === null) return callback(Error("Library file '" + libPath + "' not found."));
         stats.parseCount++;
         stats.parseTime += measure(() => {
@@ -288,13 +296,14 @@ exports.main = function main(argv, options, callback) {
   // Include entry files
   for (let i = 0, k = argv.length; i < k; ++i) {
     const filename = argv[i];
+    if (filename == "undefined") continue;
 
     let sourcePath = String(filename).replace(/\\/g, "/").replace(/(\.ts|\/)$/, "");
 
     // Try entryPath.ts, then entryPath/index.ts
-    let sourceText = readFile(path.join(baseDir, sourcePath) + ".ts");
+    let sourceText = await readFile(path.join(baseDir, sourcePath) + ".ts");
     if (sourceText === null) {
-      sourceText = readFile(path.join(baseDir, sourcePath, "index.ts"));
+      sourceText = await readFile(path.join(baseDir, sourcePath, "index.ts"));
       if (sourceText === null) {
         return callback(Error("Entry file '" + sourcePath + ".ts' not found."));
       } else {
@@ -303,6 +312,7 @@ exports.main = function main(argv, options, callback) {
     } else {
       sourcePath += ".ts";
     }
+    debugger;
 
     stats.parseCount++;
     stats.parseTime += measure(() => {
@@ -326,12 +336,12 @@ exports.main = function main(argv, options, callback) {
         } else {
           for (let i = 0, k = customLibDirs.length; i < k; ++i) {
             const dir = customLibDirs[i];
-            sourceText = readFile(path.join(dir, plainName + ".ts"));
+            sourceText = await readFile(path.join(dir, plainName + ".ts"));
             if (sourceText !== null) {
               sourcePath = exports.libraryPrefix + plainName + ".ts";
               break;
             } else {
-              sourceText = readFile(path.join(dir, indexName + ".ts"));
+              sourceText = await readFile(path.join(dir, indexName + ".ts"));
               if (sourceText !== null) {
                 sourcePath = exports.libraryPrefix + indexName + ".ts";
                 break;
@@ -344,11 +354,11 @@ exports.main = function main(argv, options, callback) {
       } else {
         const plainName = sourcePath;
         const indexName = sourcePath + "/index";
-        sourceText = readFile(path.join(baseDir, plainName + ".ts"));
+        sourceText = await readFile(path.join(baseDir, plainName + ".ts"));
         if (sourceText !== null) {
           sourcePath = plainName + ".ts";
         } else {
-          sourceText = readFile(path.join(baseDir, indexName + ".ts"));
+          sourceText = await readFile(path.join(baseDir, indexName + ".ts"));
           if (sourceText !== null) {
             sourcePath = indexName + ".ts";
           } else if (!plainName.startsWith(".")) {
@@ -361,12 +371,12 @@ exports.main = function main(argv, options, callback) {
             } else {
               for (let i = 0, k = customLibDirs.length; i < k; ++i) {
                 const dir = customLibDirs[i];
-                sourceText = readFile(path.join(dir, plainName + ".ts"));
+                sourceText = await readFile(path.join(dir, plainName + ".ts"));
                 if (sourceText !== null) {
                   sourcePath = exports.libraryPrefix + plainName + ".ts";
                   break;
                 } else {
-                  sourceText = readFile(path.join(dir, indexName + ".ts"));
+                  sourceText = await readFile(path.join(dir, indexName + ".ts"));
                   if (sourceText !== null) {
                     sourcePath = exports.libraryPrefix + indexName + ".ts";
                     break;
@@ -417,7 +427,9 @@ exports.main = function main(argv, options, callback) {
   assemblyscript.setNoTreeShaking(compilerOptions, args.noTreeShaking);
   assemblyscript.setNoAssert(compilerOptions, args.noAssert);
   assemblyscript.setImportMemory(compilerOptions, args.importMemory);
+  assemblyscript.setSharedMemory(compilerOptions, args.sharedMemory);
   assemblyscript.setImportTable(compilerOptions, args.importTable);
+  assemblyscript.ignoreDataSegments(compilerOptions, args.ignoreDataSegments);
   assemblyscript.setMemoryBase(compilerOptions, args.memoryBase >>> 0);
   assemblyscript.setSourceMap(compilerOptions, args.sourceMap != null);
   assemblyscript.setOptimizeLevelHints(compilerOptions, optimizeLevel, shrinkLevel);
@@ -550,7 +562,7 @@ exports.main = function main(argv, options, callback) {
         args.binaryFile = args.outFile;
       }
     }
-
+    debugger;
     // Write binary
     if (args.binaryFile != null) {
       let sourceMapURL = args.sourceMap != null
@@ -566,7 +578,7 @@ exports.main = function main(argv, options, callback) {
       });
 
       if (args.binaryFile.length) {
-        writeFile(path.join(baseDir, args.binaryFile), wasm.output);
+        await writeFile(path.join(baseDir, args.binaryFile), wasm.output);
       } else {
         writeStdout(wasm.output);
         hasStdout = true;
@@ -578,31 +590,31 @@ exports.main = function main(argv, options, callback) {
         if (args.binaryFile.length) {
           let sourceMap = JSON.parse(wasm.sourceMap);
           sourceMap.sourceRoot = exports.sourceMapRoot;
-          sourceMap.sources.forEach((name, index) => {
+          sourceMap.sources.forEach(async (name, index) => {
             let text = null;
             if (name.startsWith(exports.libraryPrefix)) {
               let stdName = name.substring(exports.libraryPrefix.length).replace(/\.ts$/, "");
               if (exports.libraryFiles.hasOwnProperty(stdName)) {
                 text = exports.libraryFiles[stdName];
               } else {
                 for (let i = 0, k = customLibDirs.length; i < k; ++i) {
-                  text = readFile(path.join(
+                  text = await readFile(path.join(
                     customLibDirs[i],
                     name.substring(exports.libraryPrefix.length))
                   );
                   if (text !== null) break;
                 }
               }
             } else {
-              text = readFile(path.join(baseDir, name));
+              text = await readFile(path.join(baseDir, name));
             }
             if (text === null) {
               return callback(Error("Source file '" + name + "' not found."));
             }
             if (!sourceMap.sourceContents) sourceMap.sourceContents = [];
             sourceMap.sourceContents[index] = text;
           });
-          writeFile(path.join(
+          await writeFile(path.join(
             baseDir,
             path.dirname(args.binaryFile),
             path.basename(sourceMapURL)
@@ -621,7 +633,7 @@ exports.main = function main(argv, options, callback) {
         stats.emitTime += measure(() => {
           asm = module.toAsmjs();
         });
-        writeFile(path.join(baseDir, args.asmjsFile), asm);
+        await writeFile(path.join(baseDir, args.asmjsFile), asm);
       } else if (!hasStdout) {
         stats.emitCount++;
         stats.emitTime += measure(() => {
@@ -641,7 +653,7 @@ exports.main = function main(argv, options, callback) {
         stats.emitTime += measure(() => {
           idl = assemblyscript.buildIDL(program);
         });
-        writeFile(path.join(baseDir, args.idlFile), idl);
+        await writeFile(path.join(baseDir, args.idlFile), idl);
       } else if (!hasStdout) {
         stats.emitCount++;
         stats.emitTime += measure(() => {
@@ -661,7 +673,7 @@ exports.main = function main(argv, options, callback) {
         stats.emitTime += measure(() => {
           tsd = assemblyscript.buildTSD(program);
         });
-        writeFile(path.join(baseDir, args.tsdFile), tsd);
+        await writeFile(path.join(baseDir, args.tsdFile), tsd);
       } else if (!hasStdout) {
         stats.emitCount++;
         stats.emitTime += measure(() => {
@@ -681,7 +693,7 @@ exports.main = function main(argv, options, callback) {
         stats.emitTime += measure(() => {
           wat = module.toText();
         });
-        writeFile(path.join(baseDir, args.textFile), wat);
+        await writeFile(path.join(baseDir, args.textFile), wat);
       } else if (!hasStdout) {
         stats.emitCount++;
         stats.emitTime += measure(() => {

cli/asc.json

@@ -106,6 +106,16 @@
     "type": "b",
     "default": false
   },
+  "sharedMemory": {
+    "description": "Declare memory as shared.",
+    "type": "i",
+    "default": 0
+  },
+  "ignoreDataSegments": {
+    "description": "Ingore data segments to binary. Default false.",
+    "type": "b",
+    "default": false
+  },
   "memoryBase": {
     "description": "Sets the start offset of compiler-generated static memory.",
     "type": "i",

examples/atomic-shared-memory/assembly/index.js

@@ -0,0 +1,23 @@
+const fs   = require("fs");
+const path = require("path");
+
+const compiled = new WebAssembly.Module(
+  fs.readFileSync(path.resolve(__dirname, "..", "build", "atomic.builtins.wasm"))
+);
+const memory = new WebAssembly.Memory({
+  initial: 256,
+  maximum: 256,
+  shared: true
+})
+const imports = {
+  env: {
+    memory,
+    abort: (filename, line, column) => {
+      throw Error("abort called at " + line + ":" + colum);
+    }
+  }
+};
+
+Object.defineProperty(module, "exports", {
+  get: () => new WebAssembly.Instance(compiled, imports).exports
+});

examples/atomic-shared-memory/assembly/index.ts

@@ -0,0 +1,105 @@
+declare function log(v: i32): void;
+
+export function test(): void {
+  var i: i32 = 0;
+  var u: u32 = 0;
+  var I: i64 = 0;
+  var U: u64 = 0;
+
+  // Atomic store
+  Atomic.store<i8>(120, <i32>8);
+  Atomic.store<i16>(121, <i32>16);
+  Atomic.store<i32>(123, <i32>32);
+
+  Atomic.store<i8>(120, <i64>8);
+  Atomic.store<i16>(121, <i64>16);
+  Atomic.store<i32>(123, <i64>32);
+  Atomic.store<i64>(127, <i64>64);
+
+  // Atomic load
+  i = Atomic.load<i8>(120);
+  i = Atomic.load<i16>(121);
+  i = Atomic.load<i32>(123);
+  u = Atomic.load<i8>(120);
+  u = Atomic.load<i16>(121);
+  u = Atomic.load<i32>(123);
+
+  I = Atomic.load<i8>(120);
+  I = Atomic.load<i16>(121);
+  I = Atomic.load<i32>(123);
+  I = Atomic.load<i64>(127);
+  U = Atomic.load<i8>(120);
+  U = Atomic.load<i16>(121);
+  U = Atomic.load<i32>(123);
+  U = Atomic.load<i64>(127);
+
+  // Atomic add
+  i = Atomic.add<i8>(120, 1);
+  i = Atomic.add<i16>(121, 1);
+  i = Atomic.add<i32>(123, 1);
+
+  I = Atomic.add<i8>(120, <i64>1);
+  I = Atomic.add<i16>(121, <i64>1);
+  I = Atomic.add<i32>(123, <i64>1);
+  I = Atomic.add<i64>(127, <i64>1);
+
+  // Atomic subtract
+  Atomic.sub<i8>(120, 1);
+  Atomic.sub<i16>(121, 1);
+  Atomic.sub<i32>(123, 1);
+
+  I = Atomic.sub<i8>(120, <i64>1);
+  I = Atomic.sub<i16>(121, <i64>1);
+  I = Atomic.sub<i32>(123, <i64>1);
+  I = Atomic.sub<i64>(127, <i64>1);
+
+  // Atomic AND
+  Atomic.and<i8>(120, 1);
+  Atomic.and<i16>(121, 1);
+  Atomic.and<i32>(123, 1);
+
+  I = Atomic.and<i8>(120, <i64>1);
+  I = Atomic.and<i16>(121, <i64>1);
+  I = Atomic.and<i32>(123, <i64>1);
+  I = Atomic.and<i64>(127, <i64>1);
+
+  // Atomic OR
+  Atomic.or<i8>(120, 1);
+  Atomic.or<i16>(121, 1);
+  Atomic.or<i32>(123, 1);
+
+  I = Atomic.or<i8>(120, <i64>1);
+  I = Atomic.or<i16>(121, <i64>1);
+  I = Atomic.or<i32>(123, <i64>1);
+  I = Atomic.or<i64>(127, <i64>1);
+
+  // Atomic XOR
+  Atomic.xor<i8>(120, 1);
+  Atomic.xor<i16>(121, 1);
+  Atomic.xor<i32>(123, 1);
+
+  I = Atomic.xor<i8>(120, <i64>1);
+  I = Atomic.xor<i16>(121, <i64>1);
+  I = Atomic.xor<i32>(123, <i64>1);
+  I = Atomic.xor<i64>(127, <i64>1);
+
+  // Atomic xchg
+  Atomic.xchg<i8>(120, 1);
+  Atomic.xchg<i16>(121, 1);
+  Atomic.xchg<i32>(123, 1);
+
+  I = Atomic.xchg<i8>(120, <i64>1);
+  I = Atomic.xchg<i16>(121, <i64>1);
+  I = Atomic.xchg<i32>(123, <i64>1);
+  I = Atomic.xchg<i64>(127, <i64>1);
+
+  // Atomic cmpxchg
+  Atomic.cmpxchg<i8>(120, 1, 2);
+  Atomic.cmpxchg<i16>(121, 1, 2);
+  Atomic.cmpxchg<i32>(123, 1, 2);
+
+  I = Atomic.cmpxchg<i8>(120, <i64>1, <i64>2);
+  I = Atomic.cmpxchg<i16>(121, <i64>1, <i64>2);
+  I = Atomic.cmpxchg<i32>(123, <i64>1, <i64>2);
+  I = Atomic.cmpxchg<i64>(127, <i64>1, <i64>2);
+}