hijack dylink section

dcodeIO · dcodeIO · commit a2cc5d651faa · 2019-10-12T17:15:02.000+02:00
diff --git a/lib/binaryen.js b/lib/binaryen.js
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -12,7 +12,7 @@
   },
   "dependencies": {
     "@protobufjs/utf8": "^1.1.0",
-    "binaryen": "89.0.0-nightly.20190918",
+    "binaryen": "89.0.0-nightly.20191012",
     "glob": "^7.1.4",
     "long": "^4.0.0",
     "opencollective-postinstall": "^2.0.0",
diff --git a/src/compiler.ts b/src/compiler.ts
@@ -178,7 +178,9 @@ import {
   writeI64,
   writeF32,
   writeF64,
-  makeMap
+  makeMap,
+  writeU32Leb128,
+  lengthU32Leb128
 } from "./util";
 
 /** Compiler options. */
@@ -471,17 +473,21 @@ export class Compiler extends DiagnosticEmitter {
       if (file.source.sourceKind == SourceKind.USER_ENTRY) this.ensureModuleExports(file);
     }
 
-    // set up relocation hints
+    // add dylink section if relocatable
     if (options.relocatable) {
-      let memorySize = i64_align(memoryOffset, 16);
-      if (options.isWasm64) {
-        module.addGlobal("__memory_size", NativeType.I64, false, module.i64(i64_low(memorySize), i64_high(memorySize)));
-      } else {
-        module.addGlobal("__memory_size", NativeType.I32, false, module.i32(i64_low(memorySize)));
-      }
-      module.addGlobalExport("__memory_size", "__memory_size");
-      module.addGlobal("__table_size", NativeType.I32, false, module.i32(functionTable.length));
-      module.addGlobalExport("__table_size", "__table_size");
+      let memorySize64 = i64_align(memoryOffset, 16);
+      assert(i64_is_u32(memorySize64));
+      let msize = i64_low(memorySize64);
+      let tsize = functionTable.length;
+      let size = lengthU32Leb128(msize) + lengthU32Leb128(tsize) + 3;
+      let buffer = new Uint8Array(size);
+      let offset = writeU32Leb128(msize, buffer, 0);  // memory_size
+      offset = writeU32Leb128(4, buffer, offset);     // memory_align
+      offset = writeU32Leb128(tsize, buffer, offset); // table_size
+      offset = writeU32Leb128(0, buffer, offset);     // table_align
+      offset = writeU32Leb128(0, buffer, offset);     // lib_count
+      assert(offset == size);
+      module.addCustomSection("dylink", buffer);
     }
 
     return module;
diff --git a/src/glue/binaryen.d.ts b/src/glue/binaryen.d.ts
@@ -706,6 +706,8 @@ declare function _BinaryenModuleGetDebugInfoFileName(module: BinaryenModuleRef,
 declare function _BinaryenModuleGetFeatures(module: BinaryenModuleRef): BinaryenFeatureFlags;
 declare function _BinaryenModuleSetFeatures(module: BinaryenModuleRef, featureFlags: BinaryenFeatureFlags): void;
 
+declare function _BinaryenAddCustomSection(module: BinaryenModuleRef, name: usize, contents: usize, contentsSize: BinaryenIndex): void;
+
 declare type BinaryenRelooperRef = usize;
 declare type BinaryenRelooperBlockRef = usize;
 
diff --git a/src/module.ts b/src/module.ts
@@ -1248,6 +1248,16 @@ export class Module {
     _BinaryenSetStart(this.ref, func);
   }
 
+  addCustomSection(name: string, contents: Uint8Array): void {
+    var cStr = this.allocStringCached(name);
+    var cArr = allocU8Array(contents);
+    try {
+      _BinaryenAddCustomSection(this.ref, cStr, cArr, contents.length);
+    } finally {
+      memory.free(cArr);
+    }
+  }
+
   getOptimizeLevel(): i32 {
     return _BinaryenGetOptimizeLevel();
   }
diff --git a/src/util/binary.ts b/src/util/binary.ts
@@ -72,3 +72,24 @@ export function writeF64(value: f64, buffer: Uint8Array, offset: i32): void {
   writeI32(i64_low(valueI64), buffer, offset);
   writeI32(i64_high(valueI64), buffer, offset + 4);
 }
+
+/** Computes the length of a 32-bit unsigned integer when encoded as LEB128. */
+export function lengthU32Leb128(value: u32): i32 {
+  var length = 1;
+  while (value >>>= 7) ++length;
+  return length;
+}
+
+/** Writes a 32-bit unsigned integer to the specified buffer using LEB128 encoding. */
+export function writeU32Leb128(value: u32, buffer: Uint8Array, offset: i32): i32 {
+  do {
+    let b = value & 0x7f;
+    if (value >>>= 7) {
+      buffer[offset++] = b | 0x80;
+    } else {
+      buffer[offset++] = b;
+      break;
+    }
+  } while (true);
+  return offset;
+}
diff --git a/tests/compiler/relocatable.js b/tests/compiler/relocatable.js
@@ -1,8 +1,42 @@
+function readU32Leb128(buffer, offset) {
+  var value = 0;
+  var shift = 0;
+  var length = buffer.length;
+  while (offset < length) {
+    let b = buffer[offset++];
+    value |= (b & 0x7f) << shift;
+    if (!(b & 0x80)) break;
+    shift += 7;
+  }
+  return { value, offset };
+}
+
+function readDylinkSection(buffer) {
+  var view = new Uint8Array(buffer);
+  var temp = readU32Leb128(view, 0);
+  var memory_size = temp.value;
+  temp = readU32Leb128(view, temp.offset);
+  var memory_align = temp.value;
+  temp = readU32Leb128(view, temp.offset);
+  var table_size = temp.value;
+  temp = readU32Leb128(view, temp.offset);
+  var table_align = temp.value;
+  // TODO: read required libraries
+  // temp = readU32Leb128(view, temp.offset);
+  // var lib_count = temp.value;
+  // ...
+  return { memory_size, memory_align, table_size, table_align };
+}
+
 exports.preInstantiate = function(imports, exports, module) {
   // compiler generates initial = 1 because it doesn't know the imported value
   // of env.memory_base yet, hence we need to import a suitable memory as well:
   imports["env"]["memory"] = new WebAssembly.Memory({ initial: 2 });
   imports["env"]["memory_base"] = 65536;
   imports["env"]["table"] = new WebAssembly.Table({ element: "anyfunc", initial: 20 });
   imports["env"]["table_base"] = 10;
+
+  var dylink = WebAssembly.Module.customSections(module, "dylink");
+  if (dylink && dylink.length) console.log(readDylinkSection(dylink[0]));
+  else throw Error("missing dylink section");
 };
