Subzero. Wasm. Implement sbrk and correctly do bounds checks.

runtime/wasm-runtime.cpp

 //===- subzero/runtime/wasm-runtime.cpp - Subzero WASM runtime source -----===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the system calls required by the libc that is included
 // in WebAssembly programs.
 //
 //===----------------------------------------------------------------------===//
 
+#include <cassert>
 #include <cmath>
+#include <stdint.h>

[Jim Stichnoth, 2016/04/22 20:48:53]

<cstdint> ?
(I think cstdint requires C++11 or later)

[Eric Holk, 2016/04/22 22:32:47]

So far I've been avoiding using C++11 because of some silliness with how Clang
tries to apply -std=c++11 to .c files as well. I'd rather delay the shift to
C++11 until I have a more principled way of building the runtime.

I'll add a TODO to remind me to switch this.

+
+namespace {
+int32_t HeapBreak;
+const int32_t PageSizeLog2 = 16;

[Jim Stichnoth, 2016/04/22 20:48:53]

constexpr

[Jim Stichnoth, 2016/04/22 20:48:54]

If it's a Log2 value, make it uint32_t

[Eric Holk, 2016/04/22 22:32:47]

Done.

[Eric Holk, 2016/04/22 22:32:47]

See my previous comment about C++11. I added a TODO to add constexpr once I get
C++11 enabled.

+const int32_t PageSize = 1 << PageSizeLog2; // 64KB

[Jim Stichnoth, 2016/04/22 20:48:53]

uint32_t ?

[Eric Holk, 2016/04/22 22:32:47]

Done. I'll replace most of the other int32_t with uint32_t now. Since I'm
explicitly setting the stack pointer now, negative memory addresses aren't being
used which means most of what was signed should be unsigned.

+const int32_t StackPtrLoc = 1024;           // defined by emscripten
+
+int32_t pageNum(int32_t Index) { return Index >> PageSizeLog2; }
+} // end of anonymous namespace
 
 namespace env {
 double floor(double X) { return std::floor(X); }
 
 float floor(float X) { return std::floor(X); }
-}
+} // end of env namespace

[Jim Stichnoth, 2016/04/22 20:48:53]

end of namespace env

[Eric Holk, 2016/04/22 22:32:48]

Done.

 
 // TODO (eholk): move the C parts outside and use C++ name mangling.
 extern "C" {
 #include <errno.h>
 #include <fcntl.h>
 #include <math.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <unistd.h>
 
 extern char WASM_MEMORY[];
+extern int32_t WASM_DATA_SIZE;

[Jim Stichnoth, 2016/04/22 20:48:53]

uint32_t ?

[Eric Holk, 2016/04/22 22:32:48]

Done.

+extern int32_t WASM_NUM_PAGES;
 
 void env$$abort() {
   fprintf(stderr, "Aborting...\n");
   abort();
 }
 
 void env$$_abort() { env$$abort(); }
 
 double env$$floor_f(float X) { return env::floor(X); }
 double env$$floor_d(double X) { return env::floor(X); }
 
 void env$$exit(int Status) { exit(Status); }
 void env$$_exit(int Status) { env$$exit(Status); }
 
 #define UNIMPLEMENTED(f)                                                       \
   void env$$##f() {                                                            \
     fprintf(stderr, "Unimplemented: " #f "\n");                                \
     abort();                                                                   \
   }
 
-UNIMPLEMENTED(sbrk)
+int32_t env$$sbrk(int32_t Increment) {
+  HeapBreak += Increment;
+  return HeapBreak;
+}
+
 UNIMPLEMENTED(setjmp)
 UNIMPLEMENTED(longjmp)
 UNIMPLEMENTED(__assert_fail)
 UNIMPLEMENTED(__builtin_malloc)
 UNIMPLEMENTED(__builtin_isinff)
 UNIMPLEMENTED(__builtin_isinfl)
 UNIMPLEMENTED(__builtin_apply)
 UNIMPLEMENTED(__builtin_apply_args)
 UNIMPLEMENTED(pthread_cleanup_push)
 UNIMPLEMENTED(pthread_cleanup_pop)
 UNIMPLEMENTED(pthread_self)
 UNIMPLEMENTED(__floatditf)
 UNIMPLEMENTED(__floatsitf)
 UNIMPLEMENTED(__fixtfdi)
 UNIMPLEMENTED(__fixtfsi)
 UNIMPLEMENTED(__fixsfti)
 UNIMPLEMENTED(__netf2)
 UNIMPLEMENTED(__getf2)
 UNIMPLEMENTED(__eqtf2)
 UNIMPLEMENTED(__lttf2)
 UNIMPLEMENTED(__addtf3)
 UNIMPLEMENTED(__subtf3)
 UNIMPLEMENTED(__divtf3)
 UNIMPLEMENTED(__multf3)
 UNIMPLEMENTED(__multi3)
 UNIMPLEMENTED(__lock)
 UNIMPLEMENTED(__unlock)
 UNIMPLEMENTED(__syscall6)   // sys_close
 UNIMPLEMENTED(__syscall140) // sys_llseek
-UNIMPLEMENTED(__syscall192) // sys_mmap?
 UNIMPLEMENTED(__unordtf2)
 UNIMPLEMENTED(__fixunstfsi)
 UNIMPLEMENTED(__floatunsitf)
 UNIMPLEMENTED(__extenddftf2)
 
 void *wasmPtr(int Index) {
-  // TODO (eholk): get the mask from the WASM file.
-  const int MASK = 0xffffff;
-  Index &= MASK;
-
-  return WASM_MEMORY + Index;
+  if (pageNum(Index) < WASM_NUM_PAGES && pageNum(Index) >= 0) {
+    return WASM_MEMORY + Index;
+  }
+  abort();
 }
 
 extern int __szwasm_main(int, const char **);
 
 #define WASM_REF(Type, Index) ((Type *)wasmPtr(Index))
 #define WASM_DEREF(Type, Index) (*WASM_REF(Type, Index))
 
-int main(int argc, const char **argv) { return __szwasm_main(argc, argv); }
+int main(int argc, const char **argv) {
+  // Initialize the break to the nearest page boundary after the data segment
+  HeapBreak = (WASM_DATA_SIZE + PageSize - 1) & ~(PageSize - 1);
+
+  // Initialize the stack pointer.
+  WASM_DEREF(int32_t, StackPtrLoc) = WASM_NUM_PAGES * PageSize;

[Jim Stichnoth, 2016/04/22 20:48:53]

Instead of "* PageSize", how about "<< PageSizeLog2" ?

This is more in line with the previous statement using PageSize-1 as a bitmask
and therefore counting on PageSize to be a power of 2.

Alternatively or in addition, make PageSize a local var within main().

[Eric Holk, 2016/04/22 22:32:47]

I like the shift better, so done.

I'd rather keep both PageSize and PageSizeLog2 as a global, since it'll probably
be convenient to have both in other portions of the runtime too.

+
+  return __szwasm_main(argc, argv);
+}
 
 int env$$abs(int a) { return abs(a); }
 
 double env$$pow(double x, double y) { return pow(x, y); }
 
 /// sys_write
 int env$$__syscall4(int Which, int VarArgs) {
   int Fd = WASM_DEREF(int, VarArgs + 0 * sizeof(int));
   int Buffer = WASM_DEREF(int, VarArgs + 1 * sizeof(int));
   int Length = WASM_DEREF(int, VarArgs + 2 * sizeof(int));
@@ skipping 45 matching lines @@
 
     int Curr = write(Fd, Ptr, Length);
 
     if (Curr < 0) {
       return -1;
     }
     Count += Curr;
   }
   return Count;
 }
+
+/// sys_mmap_pgoff
+int env$$__syscall192(int Which, int VarArgs) {
+  (void)Which;
+  (void)VarArgs;
+
+  // TODO (eholk): figure out how to implement this.
+
+  return -ENOMEM;
+}
 } // end of extern "C"