Subzero, Wasm: Dynamically reallocate read buffer. Runtime improvements.

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 <errno.h>
+#include <fcntl.h>
+#include <iostream>
+#include <math.h>
 // TODO (eholk): change to cstdint

[Jim Stichnoth, 2016/04/26 22:36:43]

You can probably just remove this TODO...  It made more sense when there was
only one C-style .h file.

[Eric Holk, 2016/04/27 21:45:20]

Done.

 #include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <termios.h>
+#include <time.h>
+#include <unistd.h>
+
+#ifdef WASM_TRACE_RUNTIME
+#define TRACE_ENTRY()                                                          \
+  { std::cerr << __func__ << "(...) = "; }
+template <typename T> T trace(T x) {
+  std::cerr << x << std::endl;
+  return x;
+}
+void trace() { std::cerr << "(void)" << std::endl; }
+#else
+#define TRACE_ENTRY()
+template <typename T> T trace(T x) { return x; }
+void trace() {}
+#endif // WASM_TRACE_RUNTIME
 
 namespace {
 uint32_t HeapBreak;
 
 // TODO (eholk): make all of these constexpr.
 const uint32_t PageSizeLog2 = 16;
 const uint32_t PageSize = 1 << PageSizeLog2; // 64KB
 const uint32_t StackPtrLoc = 1024;           // defined by emscripten
 
 uint32_t pageNum(uint32_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 namespace env
 
 // TODO (eholk): move the C parts outside and use C++ name mangling.
+
+typedef int32_t WasmPtr;
+
+namespace {
+
+/// Some runtime functions need to return pointers. The WasmData struct is used
+/// to preallocate space for these on the heap.
+struct WasmData {
+
+  /// StrBuf is returned by functions that return strings.
+  char StrBuf[256];
+};
+
+WasmData *GlobalData = NULL;
+
+long double makeLongDouble(int64_t A, int64_t B) {
+  union {
+    int64_t Parts[2];
+    long double X;
+  } Union;
+
+  Union.Parts[0] = A;
+  Union.Parts[1] = B;
+
+  return Union.X;

[Jim Stichnoth, 2016/04/26 22:36:43]

This kind of type punning is undefined behavior - you're not allowed to write
one field of the union and then read it from a different field (common as this
is in practice).

You could probably use Utils::bitCopy() instead.

[Eric Holk, 2016/04/27 21:45:20]

The functions that call this are meant to provide software emulation of long
double support and are normally implemented in compiler-rt. My understanding is
that these functions are pretty much only needed for musl to implement printf on
long doubles, but are rarely used in practice.

In the interest of not having to maintain a floating point emulation library,
I've decided to replace all these functions with UNIMPLEMENTED. They are needed
in order to link, but I've never seen one called in practice.

+}
+} // end of anonymous namespace;

[Jim Stichnoth, 2016/04/26 22:36:43]

no semicolon

[Eric Holk, 2016/04/27 21:45:20]

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>
+
+void __sz_bounds_fail() {
+  std::cerr << "Bounds check failure" << std::endl;
+  abort();
+}
+
+void __sz_indirect_fail() {
+  std::cerr << "Invalid indirect call target" << std::endl;
+  abort();
+}
 
 extern char WASM_MEMORY[];
 extern uint32_t WASM_DATA_SIZE;
 extern uint32_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); }
+double env$$floor_f(float X) {
+  TRACE_ENTRY();
+  return env::floor(X);
+}
+double env$$floor_d(double X) {
+  TRACE_ENTRY();
+  return env::floor(X);
+}
 
-void env$$exit(int Status) { exit(Status); }
-void env$$_exit(int Status) { env$$exit(Status); }
+void env$$exit(int Status) {
+  TRACE_ENTRY();
+  exit(Status);
+}
+void env$$_exit(int Status) {
+  TRACE_ENTRY();
+  env$$exit(Status);
+}
 
 #define UNIMPLEMENTED(f)                                                       \
   void env$$##f() {                                                            \
     fprintf(stderr, "Unimplemented: " #f "\n");                                \
     abort();                                                                   \
   }
 
 int32_t env$$sbrk(int32_t Increment) {
+  TRACE_ENTRY();
+  uint32_t OldBreak = HeapBreak;
   HeapBreak += Increment;
-  return HeapBreak;
+  return trace(OldBreak);
 }
 
 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(__syscall221) // sys_fcntl64
 UNIMPLEMENTED(__unordtf2)
 UNIMPLEMENTED(__fixunstfsi)
 UNIMPLEMENTED(__floatunsitf)
-UNIMPLEMENTED(__extenddftf2)
-
-void *wasmPtr(uint32_t Index) {
+
+void *wasmPtr(int Index) {
   if (pageNum(Index) < WASM_NUM_PAGES) {
     return WASM_MEMORY + Index;
   }
   abort();
 }
 
-extern int __szwasm_main(int, const char **);
+WasmPtr toWasm(void *Ptr) {
+  return reinterpret_cast<WasmPtr>(reinterpret_cast<char *>(Ptr) - WASM_MEMORY);
+}
+
+extern int __szwasm_main(int, WasmPtr);
 
 #define WASM_REF(Type, Index) ((Type *)wasmPtr(Index))
 #define WASM_DEREF(Type, Index) (*WASM_REF(Type, Index))
 
 int main(int argc, const char **argv) {
+  // fprintf(stderr, "main(%d)\n", argc);
+
+  // TODO (eholk): align these allocations correctly.
+
+  // Allocate space for the global data.
+  HeapBreak = WASM_DATA_SIZE;
+  GlobalData = WASM_REF(WasmData, HeapBreak);
+  HeapBreak += sizeof(WasmData);
+
+  // copy the command line arguments.
+  WasmPtr WasmArgV = HeapBreak;
+  WasmPtr *WasmArgVPtr = WASM_REF(WasmPtr, WasmArgV);
+  HeapBreak += argc * sizeof(WasmPtr);
+
+  for (int i = 0; i < argc; ++i) {
+    WasmArgVPtr[i] = HeapBreak;
+    strcpy(WASM_REF(char, HeapBreak), argv[i]);
+    HeapBreak += strlen(argv[i]) + 1;
+  }
+
   // 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 << PageSizeLog2;
 
-  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) {
+  return __szwasm_main(argc, WasmArgV);
+}
+
+int env$$abs(int a) {
+  TRACE_ENTRY();
+  return trace(abs(a));
+}
+
+clock_t env$$clock() {
+  TRACE_ENTRY();
+  return trace(clock());
+}
+
+WasmPtr env$$ctime(WasmPtr Time) {
+  TRACE_ENTRY();
+  time_t *TimePtr = WASM_REF(time_t, Time);
+  char *CTime = ctime(TimePtr);
+  strncpy(GlobalData->StrBuf, CTime, sizeof(GlobalData->StrBuf));
+  GlobalData->StrBuf[sizeof(GlobalData->StrBuf) - 1] = '\0';
+  return trace(toWasm(GlobalData->StrBuf));
+}
+
+void env$$__extenddftf2(WasmPtr Dest, double X) {
+  TRACE_ENTRY();
+  long double *DestPtr = WASM_REF(long double, Dest);
+  *DestPtr = X;
+  trace();
+}
+
+void env$$__extendsftf2(WasmPtr Dest, float X) {
+  TRACE_ENTRY();
+  long double *DestPtr = WASM_REF(long double, Dest);
+  *DestPtr = X;
+  trace();
+}
+
+int32_t env$$__letf2(int64_t HighA, int64_t LowA, int64_t HighB, int64_t LowB) {
+  TRACE_ENTRY();
+  return trace(makeLongDouble(HighA, LowA) < makeLongDouble(HighB, LowB));
+}
+
+double env$$pow(double x, double y) {
+  TRACE_ENTRY();
+  return trace(pow(x, y));
+}
+
+time_t env$$time(WasmPtr Time) {
+  TRACE_ENTRY();
+  time_t *TimePtr = WASM_REF(time_t, Time);
+  return trace(time(TimePtr));
+}
+
+double env$$__trunctfdf2(int64_t High, int64_t Low) {
+  TRACE_ENTRY();
+  return trace(makeLongDouble(High, Low));
+}
+
+float env$$__trunctfsf2(int64_t High, int64_t Low) {
+  TRACE_ENTRY();
+  return trace(makeLongDouble(High, Low));
+}
+
+// lock and unlock are no-ops in wasm.js, so we mimic that behavior.
+void env$$__lock(int32_t _) {
+  TRACE_ENTRY();
+  (void)_;
+  trace();
+}
+
+void env$$__unlock(int32_t _) {
+  TRACE_ENTRY();
+  (void)_;
+  trace();
+}
+
+/// sys_read
+int env$$__syscall3(int Which, int VarArgs) {
+  TRACE_ENTRY();
   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));
 
-  return write(Fd, WASM_REF(char *, Buffer), Length);
+  return trace(read(Fd, WASM_REF(char *, Buffer), Length));
+}
+
+/// sys_write
+int env$$__syscall4(int Which, int VarArgs) {
+  TRACE_ENTRY();
+  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));
+
+  return trace(write(Fd, WASM_REF(char *, Buffer), Length));
 }
 
 /// sys_open
 int env$$__syscall5(int Which, int VarArgs) {
+  TRACE_ENTRY();
   int WasmPath = WASM_DEREF(int, VarArgs);

[Jim Stichnoth, 2016/04/26 22:36:43]

These WASM_DEREFs should be in terms of <x> * sizeof(int)

   int Flags = WASM_DEREF(int, VarArgs + 4);
   int Mode = WASM_DEREF(int, VarArgs + 8);
   const char *Path = WASM_REF(char, WasmPath);
 
-  fprintf(stderr, "sys_open(%s, %d, %d)\n", Path, Flags, Mode);
-
-  return open(Path, Flags, Mode);
+  return trace(open(Path, Flags, Mode));
+}
+
+/// sys_close
+int env$$__syscall6(int Which, int VarArgs) {
+  TRACE_ENTRY();
+  int Fd = WASM_DEREF(int, VarArgs + 0 * sizeof(int));
+
+  return trace(close(Fd));
+}
+
+/// sys_unlink
+int env$$__syscall10(int Which, int VarArgs) {
+  TRACE_ENTRY();
+  int WasmPath = WASM_DEREF(int, VarArgs);

[Jim Stichnoth, 2016/04/26 22:36:43]

Above, you have "WASM_DEREF(int, VarArgs + 0 * sizeof(int))".

If this is the only WASM_DEREF in the function, I think it's OK to omit the "0 *
", but be consistent.

But note that using "0 * " even for single-WASM_DEREF functions, makes it more
future-proof.

+  const char *Path = WASM_REF(char, WasmPath);
+
+  return trace(unlink(Path));
 }
 
 /// sys_getpid
 int env$$__syscall20(int Which, int VarArgs) {
+  TRACE_ENTRY();
   (void)Which;
   (void)VarArgs;
 
-  return getpid();
+  return trace(getpid());
+}
+
+/// sys_rmdir
+int env$$__syscall40(int Which, int VarArgs) {
+  TRACE_ENTRY();
+  int WasmPath = WASM_DEREF(int, VarArgs);
+  const char *Path = WASM_REF(char, WasmPath);
+
+  return trace(rmdir(Path));
 }
 
 /// sys_ioctl
 int env$$__syscall54(int A, int B) {
+  TRACE_ENTRY();
   int Fd = WASM_DEREF(int, B + 0 * sizeof(int));
   int Op = WASM_DEREF(int, B + 1 * sizeof(int));
   int ArgP = WASM_DEREF(int, B + 2 * sizeof(int));
-  // TODO (eholk): implement sys_ioctl
-  return -ENOTTY;
-}
-
-/// sys_write
-int env$$__syscall146(int Which, int VarArgs) {
-
+
+  switch (Op) {
+  case TCGETS: {
+    // struct termios has no pointers. Otherwise, we'd have to rewrite them.
+    struct termios *TermIOS = WASM_REF(struct termios, ArgP);
+    return trace(ioctl(Fd, TCGETS, TermIOS));
+  }
+  default:
+    // TODO (eholk): implement more ioctls
+    return trace(-ENOTTY);
+  }
+}
+
+/// sys_readv
+int env$$__syscall145(int Which, int VarArgs) {
+  TRACE_ENTRY();
   int Fd = WASM_DEREF(int, VarArgs);
   int Iov = WASM_DEREF(int, VarArgs + sizeof(int));
   int Iovcnt = WASM_DEREF(int, VarArgs + 2 * sizeof(int));
+
+  int Count = 0;
+
+  for (int I = 0; I < Iovcnt; ++I) {
+    void *Ptr = WASM_REF(void, WASM_DEREF(int, Iov + I * 8));

[Jim Stichnoth, 2016/04/26 22:36:43]

Can this be done without the magic 4/8 constants?

+    int Length = WASM_DEREF(int, Iov + I * 8 + 4);
+
+    int Curr = read(Fd, Ptr, Length);
+
+    if (Curr < 0) {
+      return trace(-1);
+    }
+    Count += Curr;
+  }
+  return trace(Count);
+}
+
+/// sys_writev
+int env$$__syscall146(int Which, int VarArgs) {
+  TRACE_ENTRY();
+  int Fd = WASM_DEREF(int, VarArgs);

[Jim Stichnoth, 2016/04/26 22:36:43]

VarArgs + <n> * sizeof(int)

Given all this repetition, what do you think of using a 3-arg macro instead of
most of these WASM_DEREF uses, and that macro does the <n>*sizeof(int)
adjustment?

[Eric Holk, 2016/04/27 21:45:20]

Actually, I think this is better done using C++. What about something like
`WasmHeap.asArray<int>[n]`?

+  int Iov = WASM_DEREF(int, VarArgs + sizeof(int));
+  int Iovcnt = WASM_DEREF(int, VarArgs + 2 * sizeof(int));
 
   int Count = 0;
 
   for (int I = 0; I < Iovcnt; ++I) {
     void *Ptr = WASM_REF(void, WASM_DEREF(int, Iov + I * 8));
     int Length = WASM_DEREF(int, Iov + I * 8 + 4);
 
     int Curr = write(Fd, Ptr, Length);
 
     if (Curr < 0) {
-      return -1;
+      return trace(-1);
     }
     Count += Curr;
   }
-  return Count;
+  return trace(Count);
 }
 
 /// sys_mmap_pgoff
 int env$$__syscall192(int Which, int VarArgs) {
+  TRACE_ENTRY();
   (void)Which;
   (void)VarArgs;
 
   // TODO (eholk): figure out how to implement this.
 
-  return -ENOMEM;
+  return trace(-ENOMEM);
 }
 } // end of extern "C"