Heap fill/compare; Std string experiments

Author: dcodeIO

bin/asc.js

@@ -93,9 +93,8 @@ function checkDiagnostics(parser) {
 if (!args.noLib) {
   var stdlibDir = path.join(__dirname + "..", "std", "assembly");
   glob.sync("*.ts", { cwd: stdlibDir }).forEach(file => {
-    var nextPath = "std/" + file;
     var nextText = fs.readFileSync(path.join(stdlibDir, file), { encoding: "utf8" });
-    parser = assemblyscript.parseFile(nextText, nextPath, parser, false);
+    parser = assemblyscript.parseFile(nextText, "std:" + file, parser, false);
   });
 }
 

package.json

@@ -11,7 +11,6 @@
     "url": "https://github.com/AssemblyScript/next/issues"
   },
   "dependencies": {
-    "@types/node": "^8.5.1",
     "binaryen": "40.0.0-nightly.20171209",
     "glob": "^7.1.2",
     "minimist": "^1.2.0",
@@ -23,6 +22,7 @@
     "@types/glob": "^5.0.34",
     "@types/long": "^3.0.32",
     "@types/minimist": "^1.2.0",
+    "@types/node": "^8.5.1",
     "chalk": "^2.3.0",
     "diff": "^3.4.0",
     "long": "^3.2.0",

src/program.ts

@@ -914,7 +914,13 @@ export enum ElementFlags {
   /** Is global. */
   GLOBAL = 1 << 11,
   /** Is read-only. */
-  READONLY = 1 << 12
+  READONLY = 1 << 12,
+  /** Is a public member. */
+  PUBLIC = 1 << 13,
+  /** Is a protected member. */
+  PROTECTED = 1 << 14,
+  /** Is a private member. */
+  PRIVATE = 1 << 15
 }
 
 /** Base class of all program elements. */
@@ -1441,8 +1447,11 @@ export class FieldPrototype extends Element {
         switch (this.declaration.modifiers[i].modifierKind) {
           case ModifierKind.EXPORT: this.isExported = true; break;
           case ModifierKind.READONLY: this.isReadonly = true; break;
+          case ModifierKind.PRIVATE:
+          case ModifierKind.PROTECTED:
+          case ModifierKind.PUBLIC:
           case ModifierKind.STATIC: break; // already handled
-          default: throw new Error("unexpected modifier");
+          default: throw new Error("unexpected modifier: " + this.declaration.modifiers[i]);
         }
       }
     }

std/assembly.d.ts

@@ -191,10 +191,25 @@ declare class Array<T> {
 
 /** Class representing a sequence of characters. */
 declare class String {
+
   static fromCharCode(ls: i32, hs?: i32): string;
   static fromCharCodes(arr: u16[]): string;
   static fromCodePoint(cp: i32): string;
   static fromCodePoints(arr: i32[]): string;
+
+  readonly length: u32;
+
+  charAt(index: u32): string;
+  charCodeAt(index: u32): u16;
+  concat(other: string): string;
+  endsWith(other: string): bool;
+  indexOf(other: string): u32;
+  startsWith(other: string): bool;
+  substr(start: u32, length?: u32): string;
+  substring(start: u32, end?: u32): string;
+  trim(): string;
+  trimLeft(): string;
+  trimRight(): string;
 }
 
 /** Class for representing a runtime error. Base class of all errors. */
@@ -237,6 +252,12 @@ declare class Heap {
   /** Copies a chunk of memory from one location to another. */
   static copy(dest: usize, src: usize, n: usize): usize;
 
+  /** Fills a chunk of memory with the specified byte value. */
+  static fill(dest: usize, c: u8, n: usize): usize;
+
+  /** Compares two chunks of memory. Returns `0` if equal, otherwise the difference of the first differing bytes. */
+  static compare(vl: usize, vr: usize, n: usize): i32;
+
   private constructor();
 }
 
@@ -251,3 +272,6 @@ interface RegExp {}
 
 /** Annotates an element being part of the global namespace. */
 declare function global(): any;
+
+/** Annotates a method being an operator overload. */
+declare function operator(token: string): any;

std/assembly/heap.ts

@@ -29,7 +29,7 @@ export class Heap {
     // just a big chunk of non-disposable memory for now
   }
 
-  static copy(dest: usize, src: usize, n: usize): usize {
+  static copy(dest: usize, src: usize, n: usize): usize { // TODO: use move_memory op once available
     assert(dest >= HEAP_BASE);
 
     // the following is based on musl's implementation of memcpy
@@ -174,5 +174,76 @@ export class Heap {
     return dest;
   }
 
+  static fill(dest: usize, c: u8, n: usize): usize { // TODO: use set_memory op once available
+    assert(dest >= HEAP_BASE);
+
+    // the following is based on musl's implementation of memset
+    if (!n) return dest;
+
+    let s: usize = dest;
+
+    // Fill head and tail with minimal branching
+    store<u8>(s, c); store<u8>(s + n - 1, c);
+    if (n <= 2) return dest;
+    store<u8>(s + 1, c); store<u8>(s + n - 2, c);
+    store<u8>(s + 2, c); store<u8>(s + n - 3, c);
+    if (n <= 6) return dest;
+    store<u8>(s + 3, c); store<u8>(s + n - 4, c);
+    if (n <= 8) return dest;
+
+    // Align to 4 bytes
+    let k: usize = -s & 3;
+    s += k;
+    n -= k;
+    n &= -4;
+
+    let c32: u32 = -1 / 255 * c;
+
+    // Fill head and tail in preparation of setting 32 bytes at a time
+    store<u32>(s, c32);
+    store<u32>(s + n - 4, c32);
+    if (n <= 8) return dest;
+    store<u32>(s + 4, c32);
+    store<u32>(s + 8, c32);
+    store<u32>(s + n - 12, c32);
+    store<u32>(s + n - 8, c32);
+    if (n <= 24) return dest;
+    store<u32>(s + 12, c32);
+    store<u32>(s + 16, c32);
+    store<u32>(s + 20, c32);
+    store<u32>(s + 24, c32);
+    store<u32>(s + n - 28, c32);
+    store<u32>(s + n - 24, c32);
+    store<u32>(s + n - 20, c32);
+    store<u32>(s + n - 16, c32);
+
+    // Align to 8 bytes
+    k = 24 + (s & 4);
+    s += k;
+    n -= k;
+
+    // Set 32 bytes at a time
+    let c64: u64 = <u64>c32 | (<u64>c32 << 32);
+    while (n >= 32) {
+      store<u64>(s, c64);
+      store<u64>(s + 8, c64);
+      store<u64>(s + 16, c64);
+      store<u64>(s + 24, c64);
+      n -= 32; s += 32;
+    }
+
+    return dest;
+  }
+
+  static compare(vl: usize, vr: usize, n: usize): i32 {
+    if (vl == vr) return 0;
+
+    // the following is based on musl's implementation of memcmp
+    while (n && load<u8>(vl) == load<u8>(vr)) {
+      n--; vl++; vr++;
+    }
+    return n ? <i32>load<u8>(vl) - <i32>load<u8>(vr) : 0;
+  }
+
   private constructor() {}
 }

std/assembly/string.ts

@@ -1,4 +1,98 @@
 @global()
 export class String {
-  // TODO
+
+  private ptr: usize;
+  readonly length: u32;
+
+  constructor(ptr: usize, len: u32) {
+    this.ptr = ptr;
+    this.length = len;
+  }
+
+  charAt(index: u32): String {
+    assert(this != null && index < this.length);
+    return new String(this.ptr + (index << 1), 1);
+  }
+
+  charCodeAt(index: u32): u16 {
+    assert(this != null && index < this.length);
+    return load<u16>(this.ptr + (index << 1));
+  }
+
+  @operator("+")
+  concat(other: String): String {
+    assert(this != null && other != null);
+    const len: u32 = this.length + other.length;
+    const ptr: usize = Heap.allocate(len << 1);
+    Heap.copy(ptr, this.ptr, this.length << 1);
+    Heap.copy(ptr, this.ptr + (len << 1), other.length << 1);
+    return new String(ptr, len);
+  }
+
+  endsWith(other: String): bool {
+    assert(this != null && other != null);
+    if (other.length > this.length)
+      return false;
+    for (let i: u32 = this.length - other.length, j: u32 = 0, k: u32 = this.length; i < k;)
+      if (this.charCodeAt(i++) != other.charCodeAt(j++))
+        return false;
+    return true;
+  }
+
+  @operator("==")
+  equals(other: String): bool {
+    assert(this != null && other != null);
+    if (this.length != other.length)
+      return false;
+    for (let i: u32 = 0, k: u32 = this.length; i < k; ++i)
+      if (this.charCodeAt(i) != other.charCodeAt(i))
+        return false;
+    return true;
+  }
+
+  indexOf(other: String): u32 {
+    assert(this != null && other != null);
+    throw new Error("not implemented");
+  }
+
+  startsWith(other: String): bool {
+    assert(this != null && other != null);
+    if (other.length > this.length)
+      return false;
+    for (let i: u32 = 0, k: u32 = other.length; i < k; ++i)
+      if (this.charCodeAt(i) != other.charCodeAt(i))
+        return false;
+    return true;
+  }
+
+  substr(start: u32, length: u32 = <u32>-1): String {
+    assert(this != null);
+    if (start >= this.length)
+      return changetype<string,String>("");
+    const len: u32 = min<u32>(length, this.length - start);
+    return new String(this.ptr + (start << 1), len);
+  }
+
+  substring(start: u32, end: u32 = <u32>-1): String {
+    assert(this != null);
+    if (start >= this.length || end <= start)
+      return changetype<string,String>("");
+    const len: u32 = min<u32>(end - start, this.length - start);
+    return new String(this.ptr + (start << 1), len);
+  }
+
+  trim(): string {
+    assert(this != null);
+    throw new Error("not implemented");
+  }
+
+  trimLeft(): string {
+    assert(this != null);
+    throw new Error("not implemented");
+  }
+
+  trimRight(): string {
+    assert(this != null);
+    throw new Error("not implemented");
+  }
 }

tests/compiler.js

@@ -26,7 +26,7 @@ glob.sync(filter, { cwd: __dirname + "/compiler" }).forEach(filename => {
   var parser = new Parser();
   if (filename.startsWith("std/")) {
     stdFiles.forEach(file => {
-      parser.parseFile(fs.readFileSync(__dirname + "/../std/assembly/" + file, { encoding: "utf8" }), file, false);
+      parser.parseFile(fs.readFileSync(__dirname + "/../std/assembly/" + file, { encoding: "utf8" }), "std:" + path.basename(file), false);
     });
     fixture = "std/" + fixture;
   }

tests/compiler/recursive.optimized.wast

@@ -0,0 +1,31 @@
+(module
+ (type $ii (func (param i32) (result i32)))
+ (memory $0 1)
+ (export "fib" (func $recursive/fib))
+ (export "memory" (memory $0))
+ (func $recursive/fib (; 0 ;) (type $ii) (param $0 i32) (result i32)
+  (if
+   (i32.le_s
+    (get_local $0)
+    (i32.const 1)
+   )
+   (return
+    (i32.const 1)
+   )
+  )
+  (i32.add
+   (call $recursive/fib
+    (i32.sub
+     (get_local $0)
+     (i32.const 1)
+    )
+   )
+   (call $recursive/fib
+    (i32.sub
+     (get_local $0)
+     (i32.const 2)
+    )
+   )
+  )
+ )
+)

tests/compiler/recursive.ts

@@ -0,0 +1,4 @@
+export function fib(n: i32): i32 {
+  if (n <= 1) return 1;
+  return fib(n - 1) + fib(n - 2);
+}